Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : */
9 :
10 : #include "gtkprintwrapper.hxx"
11 :
12 : #include "unx/gtk/gtkdata.hxx"
13 : #include "unx/gtk/gtkframe.hxx"
14 : #include "unx/gtk/gtkinst.hxx"
15 : #include "unx/gtk/gtkprn.hxx"
16 :
17 : #include "vcl/configsettings.hxx"
18 : #include "vcl/help.hxx"
19 : #include "vcl/print.hxx"
20 : #include "vcl/svapp.hxx"
21 : #include "vcl/window.hxx"
22 :
23 : #include <gtk/gtk.h>
24 : #include <gtk/gtkunixprint.h>
25 :
26 : #include <comphelper/processfactory.hxx>
27 :
28 : #include <com/sun/star/beans/PropertyValue.hpp>
29 : #include <com/sun/star/container/XNamed.hpp>
30 : #include <com/sun/star/document/XExporter.hpp>
31 : #include <com/sun/star/document/XFilter.hpp>
32 : #include <com/sun/star/frame/XFrame.hpp>
33 : #include <com/sun/star/io/XOutputStream.hpp>
34 : #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
35 : #include <com/sun/star/sheet/XSpreadsheet.hpp>
36 : #include <com/sun/star/sheet/XSpreadsheetView.hpp>
37 : #include <com/sun/star/view/PrintableState.hpp>
38 : #include <com/sun/star/view/XSelectionSupplier.hpp>
39 :
40 : #include <officecfg/Office/Common.hxx>
41 :
42 : #include <rtl/ustring.hxx>
43 :
44 : #include <unotools/streamwrap.hxx>
45 :
46 : #include <cstring>
47 : #include <map>
48 :
49 : namespace frame = com::sun::star::frame;
50 : namespace beans = com::sun::star::beans;
51 : namespace container = com::sun::star::container;
52 : namespace uno = com::sun::star::uno;
53 : namespace document = com::sun::star::document;
54 : namespace sheet = com::sun::star::sheet;
55 : namespace io = com::sun::star::io;
56 : namespace view = com::sun::star::view;
57 :
58 : using vcl::unx::GtkPrintWrapper;
59 :
60 : using uno::UNO_QUERY;
61 :
62 : class GtkPrintDialog
63 : {
64 : public:
65 : GtkPrintDialog(vcl::PrinterController& io_rController);
66 : bool run();
67 0 : GtkPrinter* getPrinter() const
68 : {
69 0 : return m_pWrapper->print_unix_dialog_get_selected_printer(GTK_PRINT_UNIX_DIALOG(m_pDialog));
70 : }
71 0 : GtkPrintSettings* getSettings() const
72 : {
73 0 : return m_pWrapper->print_unix_dialog_get_settings(GTK_PRINT_UNIX_DIALOG(m_pDialog));
74 : }
75 : void updateControllerPrintRange();
76 : #if 0
77 : void ExportAsPDF(const OUString &rFileURL, GtkPrintSettings* pSettings) const;
78 : #endif
79 : ~GtkPrintDialog();
80 :
81 0 : static void UIOption_CheckHdl(GtkWidget* i_pWidget, GtkPrintDialog* io_pThis)
82 : {
83 0 : io_pThis->impl_UIOption_CheckHdl(i_pWidget);
84 0 : }
85 0 : static void UIOption_RadioHdl(GtkWidget* i_pWidget, GtkPrintDialog* io_pThis)
86 : {
87 0 : io_pThis->impl_UIOption_RadioHdl(i_pWidget);
88 0 : }
89 0 : static void UIOption_SelectHdl(GtkWidget* i_pWidget, GtkPrintDialog* io_pThis)
90 : {
91 0 : io_pThis->impl_UIOption_SelectHdl(i_pWidget);
92 0 : }
93 :
94 : private:
95 : beans::PropertyValue* impl_queryPropertyValue(GtkWidget* i_pWidget) const;
96 : void impl_checkOptionalControlDependencies();
97 :
98 : void impl_UIOption_CheckHdl(GtkWidget* i_pWidget);
99 : void impl_UIOption_RadioHdl(GtkWidget* i_pWidget);
100 : void impl_UIOption_SelectHdl(GtkWidget* i_pWidget);
101 :
102 : void impl_initDialog();
103 : void impl_initCustomTab();
104 : void impl_initPrintContent(uno::Sequence<sal_Bool> const& i_rDisabled);
105 :
106 : void impl_readFromSettings();
107 : void impl_storeToSettings() const;
108 :
109 : private:
110 : GtkWidget* m_pDialog;
111 : vcl::PrinterController& m_rController;
112 : std::map<GtkWidget*, OUString> m_aControlToPropertyMap;
113 : std::map<GtkWidget*, sal_Int32> m_aControlToNumValMap;
114 : boost::shared_ptr<GtkPrintWrapper> m_pWrapper;
115 : };
116 :
117 : struct GtkSalPrinter_Impl
118 : {
119 : OString m_sSpoolFile;
120 : OUString m_sJobName;
121 : GtkPrinter* m_pPrinter;
122 : GtkPrintSettings* m_pSettings;
123 :
124 : GtkSalPrinter_Impl();
125 : ~GtkSalPrinter_Impl();
126 : };
127 :
128 0 : GtkSalPrinter_Impl::GtkSalPrinter_Impl()
129 : : m_pPrinter(0)
130 0 : , m_pSettings(0)
131 : {
132 0 : }
133 :
134 0 : GtkSalPrinter_Impl::~GtkSalPrinter_Impl()
135 : {
136 0 : if (m_pPrinter)
137 : {
138 0 : g_object_unref(G_OBJECT(m_pPrinter));
139 0 : m_pPrinter = NULL;
140 : }
141 0 : if (m_pSettings)
142 : {
143 0 : g_object_unref(G_OBJECT(m_pSettings));
144 0 : m_pSettings = NULL;
145 : }
146 0 : }
147 :
148 : namespace
149 : {
150 :
151 : static GtkInstance const&
152 0 : lcl_getGtkSalInstance()
153 : {
154 : // we _know_ this is GtkInstance
155 0 : return *static_cast<GtkInstance*>(GetGtkSalData()->m_pInstance);
156 : }
157 :
158 : static bool
159 0 : lcl_useSystemPrintDialog()
160 : {
161 0 : return officecfg::Office::Common::Misc::UseSystemPrintDialog::get()
162 0 : && officecfg::Office::Common::Misc::ExperimentalMode::get()
163 0 : && lcl_getGtkSalInstance().getPrintWrapper()->supportsPrinting();
164 : }
165 :
166 : }
167 :
168 0 : GtkSalPrinter::GtkSalPrinter(SalInfoPrinter* const i_pInfoPrinter)
169 0 : : PspSalPrinter(i_pInfoPrinter)
170 : {
171 0 : }
172 :
173 : bool
174 0 : GtkSalPrinter::impl_doJob(
175 : const OUString* const i_pFileName,
176 : const OUString& i_rJobName,
177 : const OUString& i_rAppName,
178 : ImplJobSetup* const io_pSetupData,
179 : const int i_nCopies,
180 : const bool i_bCollate,
181 : vcl::PrinterController& io_rController)
182 : {
183 0 : io_rController.setJobState(view::PrintableState_JOB_STARTED);
184 0 : io_rController.jobStarted();
185 : const bool bJobStarted(
186 : PspSalPrinter::StartJob(i_pFileName, i_rJobName, i_rAppName,
187 0 : i_nCopies, i_bCollate, true, io_pSetupData))
188 : ;
189 :
190 0 : if (bJobStarted)
191 : {
192 0 : io_rController.createProgressDialog();
193 0 : const int nPages(io_rController.getFilteredPageCount());
194 0 : for (int nPage(0); nPage != nPages; ++nPage)
195 : {
196 0 : if (nPage == nPages - 1)
197 0 : io_rController.setLastPage(true);
198 0 : io_rController.printFilteredPage(nPage);
199 : }
200 0 : io_rController.setJobState(view::PrintableState_JOB_COMPLETED);
201 : }
202 :
203 0 : return bJobStarted;
204 : }
205 :
206 : bool
207 0 : GtkSalPrinter::StartJob(
208 : const OUString* const i_pFileName,
209 : const OUString& i_rJobName,
210 : const OUString& i_rAppName,
211 : ImplJobSetup* io_pSetupData,
212 : vcl::PrinterController& io_rController)
213 : {
214 0 : if (!lcl_useSystemPrintDialog())
215 0 : return PspSalPrinter::StartJob(i_pFileName, i_rJobName, i_rAppName, io_pSetupData, io_rController);
216 :
217 : assert(!m_pImpl);
218 :
219 0 : m_pImpl.reset(new GtkSalPrinter_Impl());
220 0 : m_pImpl->m_sJobName = i_rJobName;
221 :
222 0 : OString sFileName;
223 0 : if (i_pFileName)
224 0 : sFileName = OUStringToOString(*i_pFileName, osl_getThreadTextEncoding());
225 :
226 0 : GtkPrintDialog aDialog(io_rController);
227 0 : if (!aDialog.run())
228 : {
229 0 : io_rController.abortJob();
230 0 : return false;
231 : }
232 0 : aDialog.updateControllerPrintRange();
233 0 : m_pImpl->m_pPrinter = aDialog.getPrinter();
234 0 : m_pImpl->m_pSettings = aDialog.getSettings();
235 :
236 : #if 0
237 : if (const gchar *uri = gtk_print_settings_get(m_pImpl->m_pSettings, GTK_PRINT_SETTINGS_OUTPUT_URI))
238 : {
239 : const gchar *pStr = gtk_print_settings_get(m_pImpl->m_pSettings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
240 : if (pStr && !strcmp(pStr, "pdf"))
241 : {
242 : aDialog.ExportAsPDF(OUString((const sal_Char *)uri, strlen((const sal_Char *)uri), RTL_TEXTENCODING_UTF8), m_pImpl->m_pSettings);
243 : bDoJob = false;
244 : }
245 : }
246 :
247 : if (!bDoJob)
248 : return false;
249 : #endif
250 0 : int nCopies = 1;
251 0 : bool bCollate = false;
252 :
253 : //To-Do proper name, watch for encodings
254 0 : sFileName = OString("/tmp/hacking.ps");
255 0 : m_pImpl->m_sSpoolFile = sFileName;
256 :
257 0 : OUString aFileName = OStringToOUString(sFileName, osl_getThreadTextEncoding());
258 :
259 : //To-Do, swap ps/pdf for gtk_printer_accepts_ps()/gtk_printer_accepts_pdf() ?
260 :
261 0 : return impl_doJob(&aFileName, i_rJobName, i_rAppName, io_pSetupData, nCopies, bCollate, io_rController);
262 : }
263 :
264 : bool
265 0 : GtkSalPrinter::EndJob()
266 : {
267 0 : bool bRet = PspSalPrinter::EndJob();
268 :
269 0 : if (!lcl_useSystemPrintDialog())
270 0 : return bRet;
271 :
272 : assert(m_pImpl);
273 :
274 0 : if (!bRet || m_pImpl->m_sSpoolFile.isEmpty())
275 0 : return bRet;
276 :
277 0 : boost::shared_ptr<GtkPrintWrapper> const pWrapper(lcl_getGtkSalInstance().getPrintWrapper());
278 :
279 0 : GtkPageSetup* pPageSetup = pWrapper->page_setup_new();
280 : #if 0
281 : //todo
282 : gtk_page_setup_set_orientation(pPageSetup,);
283 : gtk_page_setup_set_paper_size(pPageSetup,);
284 : gtk_page_setup_set_top_margin(pPageSetup,);
285 : gtk_page_setup_set_bottom_margin(pPageSetup,);
286 : gtk_page_setup_set_left_margin(pPageSetup,);
287 : gtk_page_setup_set_right_margin(pPageSetup,);
288 : #endif
289 :
290 : GtkPrintJob* const pJob = pWrapper->print_job_new(
291 0 : OUStringToOString(m_pImpl->m_sJobName, RTL_TEXTENCODING_UTF8).getStr(),
292 0 : m_pImpl->m_pPrinter, m_pImpl->m_pSettings, pPageSetup);
293 :
294 0 : GError* error = NULL;
295 0 : bRet = pWrapper->print_job_set_source_file(pJob, m_pImpl->m_sSpoolFile.getStr(), &error);
296 0 : if (bRet)
297 0 : pWrapper->print_job_send(pJob, NULL, NULL, NULL);
298 : else
299 : {
300 : //To-Do, do something with this
301 0 : fprintf(stderr, "error was %s\n", error->message);
302 0 : g_error_free(error);
303 : }
304 :
305 0 : g_object_unref(pPageSetup);
306 0 : m_pImpl.reset();
307 :
308 : //To-Do, remove temp spool file
309 :
310 0 : return bRet;
311 : }
312 :
313 : namespace
314 : {
315 :
316 : static void
317 0 : lcl_setHelpText(
318 : GtkWidget* const io_pWidget,
319 : const uno::Sequence<OUString>& i_rHelpTexts,
320 : const sal_Int32 i_nIndex)
321 : {
322 : #if GTK_CHECK_VERSION(2,12,0)
323 0 : if (i_nIndex >= 0 && i_nIndex < i_rHelpTexts.getLength())
324 : gtk_widget_set_tooltip_text(io_pWidget,
325 0 : OUStringToOString(i_rHelpTexts.getConstArray()[i_nIndex], RTL_TEXTENCODING_UTF8).getStr());
326 : #else
327 : (void)io_pWidget;
328 : (void)i_rHelpTexts;
329 : (void)i_nIndex;
330 : #endif
331 0 : }
332 :
333 : static GtkWidget*
334 0 : lcl_makeFrame(
335 : GtkWidget* const i_pChild,
336 : const OUString &i_rText,
337 : const uno::Sequence<OUString> &i_rHelpTexts,
338 : sal_Int32* const io_pCurHelpText)
339 : {
340 0 : GtkWidget* const pLabel = gtk_label_new(NULL);
341 0 : lcl_setHelpText(pLabel, i_rHelpTexts, !io_pCurHelpText ? 0 : (*io_pCurHelpText)++);
342 0 : gtk_misc_set_alignment(GTK_MISC(pLabel), 0.0, 0.5);
343 :
344 : {
345 : gchar* const pText = g_markup_printf_escaped("<b>%s</b>",
346 0 : OUStringToOString(i_rText, RTL_TEXTENCODING_UTF8).getStr());
347 0 : gtk_label_set_markup_with_mnemonic(GTK_LABEL(pLabel), pText);
348 0 : g_free(pText);
349 : }
350 :
351 0 : GtkWidget* const pFrame = gtk_vbox_new(FALSE, 6);
352 0 : gtk_box_pack_start(GTK_BOX(pFrame), pLabel, FALSE, FALSE, 0);
353 :
354 0 : GtkWidget* const pAlignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
355 0 : gtk_alignment_set_padding(GTK_ALIGNMENT(pAlignment), 0, 0, 12, 0);
356 0 : gtk_box_pack_start(GTK_BOX(pFrame), pAlignment, FALSE, FALSE, 0);
357 :
358 0 : gtk_container_add(GTK_CONTAINER(pAlignment), i_pChild);
359 0 : return pFrame;
360 : }
361 :
362 : static void
363 0 : lcl_extractHelpTextsOrIds(
364 : const beans::PropertyValue& rEntry,
365 : uno::Sequence<OUString>& rHelpStrings)
366 : {
367 0 : if (!(rEntry.Value >>= rHelpStrings))
368 : {
369 0 : OUString aHelpString;
370 0 : if ((rEntry.Value >>= aHelpString))
371 : {
372 0 : rHelpStrings.realloc(1);
373 0 : *rHelpStrings.getArray() = aHelpString;
374 0 : }
375 : }
376 0 : }
377 :
378 : static GtkWidget*
379 0 : lcl_combo_box_text_new()
380 : {
381 : #if GTK_CHECK_VERSION(3,0,0)
382 : return gtk_combo_box_text_new();
383 : #else
384 0 : return gtk_combo_box_new_text();
385 : #endif
386 : }
387 :
388 : static void
389 0 : lcl_combo_box_text_append(GtkWidget* const pWidget, gchar const* const pText)
390 : {
391 : #if GTK_CHECK_VERSION(3,0,0)
392 : gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(pWidget), pText);
393 : #else
394 0 : gtk_combo_box_append_text(GTK_COMBO_BOX(pWidget), pText);
395 : #endif
396 0 : }
397 :
398 : }
399 :
400 0 : GtkPrintDialog::GtkPrintDialog(vcl::PrinterController& io_rController)
401 : : m_rController(io_rController)
402 0 : , m_pWrapper(lcl_getGtkSalInstance().getPrintWrapper())
403 : {
404 : assert(m_pWrapper->supportsPrinting());
405 0 : impl_initDialog();
406 0 : impl_initCustomTab();
407 0 : impl_readFromSettings();
408 0 : }
409 :
410 : void
411 0 : GtkPrintDialog::impl_initDialog()
412 : {
413 : //To-Do, like fpicker, set UI language
414 0 : m_pDialog = m_pWrapper->print_unix_dialog_new(NULL, NULL);
415 :
416 0 : Window* const pTopWindow(Application::GetActiveTopWindow());
417 0 : if (pTopWindow)
418 : {
419 0 : GtkSalFrame* const pFrame(dynamic_cast<GtkSalFrame*>(pTopWindow->ImplGetFrame()));
420 0 : if (pFrame)
421 : {
422 0 : GtkWindow* const pParent(GTK_WINDOW(pFrame->getWindow()));
423 0 : if (pParent)
424 0 : gtk_window_set_transient_for(GTK_WINDOW(m_pDialog), pParent);
425 : }
426 : }
427 :
428 0 : m_pWrapper->print_unix_dialog_set_manual_capabilities(GTK_PRINT_UNIX_DIALOG(m_pDialog),
429 : GtkPrintCapabilities(GTK_PRINT_CAPABILITY_COPIES
430 : | GTK_PRINT_CAPABILITY_COLLATE
431 : | GTK_PRINT_CAPABILITY_REVERSE
432 : | GTK_PRINT_CAPABILITY_GENERATE_PS
433 : #if GTK_CHECK_VERSION(2,12,0)
434 : | GTK_PRINT_CAPABILITY_NUMBER_UP
435 : #endif
436 : #if GTK_CHECK_VERSION(2,14,0)
437 : | GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT
438 : #endif
439 0 : ));
440 0 : }
441 :
442 : void
443 0 : GtkPrintDialog::impl_initCustomTab()
444 : {
445 : typedef std::map<OUString, GtkWidget*> DependencyMap_t;
446 : typedef std::vector<std::pair<GtkWidget*, OUString> > CustomTabs_t;
447 :
448 0 : const uno::Sequence<beans::PropertyValue>& rOptions(m_rController.getUIOptions());
449 0 : DependencyMap_t aPropertyToDependencyRowMap;
450 0 : CustomTabs_t aCustomTabs;
451 0 : GtkWidget* pCurParent = NULL;
452 0 : GtkWidget* pCurTabPage = NULL;
453 0 : GtkWidget* pCurSubGroup = NULL;
454 0 : GtkWidget* pStandardPrintRangeContainer = NULL;
455 0 : bool bIgnoreSubgroup = false;
456 0 : for (int i = 0; i != rOptions.getLength(); i++)
457 : {
458 0 : uno::Sequence<beans::PropertyValue> aOptProp;
459 0 : rOptions[i].Value >>= aOptProp;
460 :
461 0 : OUString aCtrlType;
462 0 : OUString aText;
463 0 : OUString aPropertyName;
464 0 : uno::Sequence<OUString> aChoices;
465 0 : uno::Sequence<sal_Bool> aChoicesDisabled;
466 0 : uno::Sequence<OUString> aHelpTexts;
467 0 : sal_Int64 nMinValue = 0, nMaxValue = 0;
468 0 : sal_Int32 nCurHelpText = 0;
469 0 : OUString aDependsOnName;
470 0 : sal_Int32 nDependsOnValue = 0;
471 0 : bool bUseDependencyRow = false;
472 0 : bool bIgnore = false;
473 0 : GtkWidget* pGroup = NULL;
474 0 : bool bGtkInternal = false;
475 :
476 : //Fix fdo#69381
477 : //Next options if this one is empty
478 0 : if ( aOptProp.getLength() == 0)
479 0 : continue;
480 :
481 0 : for (int n = 0; n != aOptProp.getLength(); n++)
482 : {
483 0 : const beans::PropertyValue& rEntry(aOptProp[ n ]);
484 0 : if ( rEntry.Name == "Text" )
485 : {
486 0 : OUString aValue;
487 0 : rEntry.Value >>= aValue;
488 0 : aText = aValue.replace('~', '_');
489 : }
490 0 : else if ( rEntry.Name == "ControlType" )
491 0 : rEntry.Value >>= aCtrlType;
492 0 : else if ( rEntry.Name == "Choices" )
493 0 : rEntry.Value >>= aChoices;
494 0 : else if ( rEntry.Name == "ChoicesDisabled" )
495 0 : rEntry.Value >>= aChoicesDisabled;
496 0 : else if ( rEntry.Name == "Property" )
497 : {
498 0 : beans::PropertyValue aVal;
499 0 : rEntry.Value >>= aVal;
500 0 : aPropertyName = aVal.Name;
501 : }
502 0 : else if ( rEntry.Name == "DependsOnName" )
503 0 : rEntry.Value >>= aDependsOnName;
504 0 : else if ( rEntry.Name == "DependsOnEntry" )
505 0 : rEntry.Value >>= nDependsOnValue;
506 0 : else if ( rEntry.Name == "AttachToDependency" )
507 0 : rEntry.Value >>= bUseDependencyRow;
508 0 : else if ( rEntry.Name == "MinValue" )
509 0 : rEntry.Value >>= nMinValue;
510 0 : else if ( rEntry.Name == "MaxValue" )
511 0 : rEntry.Value >>= nMaxValue;
512 0 : else if ( rEntry.Name == "HelpId" )
513 : {
514 0 : uno::Sequence<OUString> aHelpIds;
515 0 : lcl_extractHelpTextsOrIds(rEntry, aHelpIds);
516 0 : Help* const pHelp = Application::GetHelp();
517 0 : if (pHelp)
518 : {
519 0 : const int nLen = aHelpIds.getLength();
520 0 : aHelpTexts.realloc(nLen);
521 0 : for (int j = 0; j != nLen; ++j)
522 0 : aHelpTexts[j] = pHelp->GetHelpText(aHelpIds[j], 0);
523 : }
524 : else // fallback
525 0 : aHelpTexts = aHelpIds;
526 : }
527 0 : else if ( rEntry.Name == "HelpText" )
528 0 : lcl_extractHelpTextsOrIds(rEntry, aHelpTexts);
529 0 : else if ( rEntry.Name == "InternalUIOnly" )
530 0 : rEntry.Value >>= bIgnore;
531 0 : else if ( rEntry.Name == "Enabled" )
532 : {
533 : // Ignore this. We use UIControlOptions::isUIOptionEnabled
534 : // to check whether a control should be enabled.
535 : }
536 0 : else if ( rEntry.Name == "GroupingHint" )
537 : {
538 : // Ignore this. We cannot add/modify controls to/on existing
539 : // tabs of the Gtk print dialog.
540 : }
541 : else
542 : {
543 : SAL_INFO("vcl.gtk", "unhandled UI option entry: " << rEntry.Name);
544 : }
545 : }
546 :
547 0 : if ( aPropertyName == "PrintContent" )
548 0 : bGtkInternal = true;
549 :
550 0 : if (aCtrlType == "Group" || !pCurParent)
551 : {
552 0 : pCurTabPage = gtk_vbox_new(FALSE, 12);
553 0 : gtk_container_set_border_width(GTK_CONTAINER(pCurTabPage), 6);
554 0 : lcl_setHelpText(pCurTabPage, aHelpTexts, 0);
555 :
556 0 : pCurParent = pCurTabPage;
557 0 : aCustomTabs.push_back(std::make_pair(pCurTabPage, aText));
558 : }
559 0 : else if (aCtrlType == "Subgroup" && (pCurParent /*|| bOnJobPageValue*/))
560 : {
561 0 : bIgnoreSubgroup = bIgnore;
562 0 : if (bIgnore)
563 0 : continue;
564 0 : pCurParent = gtk_vbox_new(FALSE, 12);
565 0 : gtk_container_set_border_width(GTK_CONTAINER(pCurParent), 0);
566 :
567 0 : pCurSubGroup = lcl_makeFrame(pCurParent, aText, aHelpTexts, NULL);
568 0 : gtk_box_pack_start(GTK_BOX(pCurTabPage), pCurSubGroup, FALSE, FALSE, 0);
569 : }
570 : // special case: we need to map these to controls of the gtk print dialog
571 0 : else if (bGtkInternal)
572 : {
573 0 : if ( aPropertyName == "PrintContent" )
574 : {
575 : // What to print? And, more importantly, is there a selection?
576 0 : impl_initPrintContent(aChoicesDisabled);
577 : }
578 : }
579 0 : else if (bIgnoreSubgroup || bIgnore)
580 0 : continue;
581 : else
582 : {
583 : // change handlers for all the controls set up in this block
584 : // should be set _after_ the control has been made (in)active,
585 : // because:
586 : // 1. value of the property is _known_--we are using it to
587 : // _set_ the control, right?--no need to change it back .-)
588 : // 2. it may cause warning because the widget may not
589 : // have been placed in m_aControlToPropertyMap yet
590 :
591 0 : GtkWidget* pWidget = NULL;
592 0 : beans::PropertyValue* pVal = NULL;
593 0 : if (aCtrlType == "Bool" && pCurParent)
594 : {
595 : pWidget = gtk_check_button_new_with_mnemonic(
596 0 : OUStringToOString(aText, RTL_TEXTENCODING_UTF8).getStr());
597 0 : lcl_setHelpText(pWidget, aHelpTexts, 0);
598 0 : m_aControlToPropertyMap[pWidget] = aPropertyName;
599 :
600 0 : bool bVal = false;
601 0 : pVal = m_rController.getValue(aPropertyName);
602 0 : if (pVal)
603 0 : pVal->Value >>= bVal;
604 0 : gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pWidget), bVal);
605 : gtk_widget_set_sensitive(pWidget,
606 0 : m_rController.isUIOptionEnabled(aPropertyName) && pVal != NULL);
607 0 : g_signal_connect(pWidget, "toggled", G_CALLBACK(GtkPrintDialog::UIOption_CheckHdl), this);
608 : }
609 0 : else if (aCtrlType == "Radio" && pCurParent)
610 : {
611 0 : GtkWidget* const pVbox = gtk_vbox_new(FALSE, 12);
612 0 : gtk_container_set_border_width(GTK_CONTAINER(pVbox), 0);
613 :
614 0 : if (!aText.isEmpty())
615 0 : pGroup = lcl_makeFrame(pVbox, aText, aHelpTexts, &nCurHelpText);
616 :
617 0 : sal_Int32 nSelectVal = 0;
618 0 : pVal = m_rController.getValue(aPropertyName);
619 0 : if (pVal && pVal->Value.hasValue())
620 0 : pVal->Value >>= nSelectVal;
621 :
622 0 : for (sal_Int32 m = 0; m != aChoices.getLength(); m++)
623 : {
624 : pWidget = gtk_radio_button_new_with_mnemonic_from_widget(
625 0 : GTK_RADIO_BUTTON(m == 0 ? NULL : pWidget),
626 0 : OUStringToOString(aChoices[m].replace('~', '_'), RTL_TEXTENCODING_UTF8).getStr());
627 0 : lcl_setHelpText(pWidget, aHelpTexts, nCurHelpText++);
628 0 : m_aControlToPropertyMap[pWidget] = aPropertyName;
629 0 : m_aControlToNumValMap[pWidget] = m;
630 0 : GtkWidget* const pRow = gtk_hbox_new(FALSE, 12);
631 0 : gtk_box_pack_start(GTK_BOX(pVbox), pRow, FALSE, FALSE, 0);
632 0 : gtk_box_pack_start(GTK_BOX(pRow), pWidget, FALSE, FALSE, 0);
633 0 : aPropertyToDependencyRowMap[aPropertyName + OUString::number(m)] = pRow;
634 0 : gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pWidget), m == nSelectVal);
635 : gtk_widget_set_sensitive(pWidget,
636 0 : m_rController.isUIOptionEnabled(aPropertyName) && pVal != NULL);
637 0 : g_signal_connect(pWidget, "toggled",
638 0 : G_CALLBACK(GtkPrintDialog::UIOption_RadioHdl), this);
639 : }
640 :
641 0 : if (pGroup)
642 0 : pWidget = pGroup;
643 : else
644 0 : pWidget = pVbox;
645 : }
646 0 : else if ((aCtrlType == "List" ||
647 0 : aCtrlType == "Range" ||
648 0 : aCtrlType == "Edit"
649 0 : ) && pCurParent)
650 : {
651 0 : GtkWidget* const pHbox = gtk_hbox_new(FALSE, 12);
652 0 : gtk_container_set_border_width(GTK_CONTAINER(pHbox), 0);
653 :
654 0 : if ( aCtrlType == "List" )
655 : {
656 0 : pWidget = lcl_combo_box_text_new();
657 :
658 0 : for (sal_Int32 m = 0; m != aChoices.getLength(); m++)
659 : {
660 : lcl_combo_box_text_append(pWidget,
661 0 : OUStringToOString(aChoices[m], RTL_TEXTENCODING_UTF8).getStr());
662 : }
663 :
664 0 : sal_Int32 nSelectVal = 0;
665 0 : pVal = m_rController.getValue(aPropertyName);
666 0 : if (pVal && pVal->Value.hasValue())
667 0 : pVal->Value >>= nSelectVal;
668 0 : gtk_combo_box_set_active(GTK_COMBO_BOX(pWidget), nSelectVal);
669 0 : g_signal_connect(pWidget, "changed", G_CALLBACK(GtkPrintDialog::UIOption_SelectHdl), this);
670 : }
671 0 : else if (aCtrlType == "Edit" && pCurParent)
672 : {
673 0 : pWidget = gtk_entry_new();
674 :
675 0 : OUString aCurVal;
676 0 : pVal = m_rController.getValue(aPropertyName);
677 0 : if (pVal && pVal->Value.hasValue())
678 0 : pVal->Value >>= aCurVal;
679 0 : gtk_entry_set_text(GTK_ENTRY(pWidget),
680 0 : OUStringToOString(aCurVal, RTL_TEXTENCODING_UTF8).getStr());
681 : }
682 0 : else if (aCtrlType == "Range" && pCurParent)
683 : {
684 0 : pWidget = gtk_spin_button_new_with_range(nMinValue, nMaxValue, 1.0);
685 :
686 0 : sal_Int64 nCurVal = 0;
687 0 : pVal = m_rController.getValue(aPropertyName);
688 0 : if (pVal && pVal->Value.hasValue())
689 0 : pVal->Value >>= nCurVal;
690 0 : gtk_spin_button_set_value(GTK_SPIN_BUTTON(pWidget), nCurVal);
691 : }
692 :
693 0 : lcl_setHelpText(pWidget, aHelpTexts, 0);
694 0 : m_aControlToPropertyMap[pWidget] = aPropertyName;
695 :
696 : gtk_widget_set_sensitive(pWidget,
697 0 : m_rController.isUIOptionEnabled(aPropertyName) && pVal != NULL);
698 :
699 0 : if (!aText.isEmpty())
700 : {
701 : GtkWidget* const pLabel = gtk_label_new_with_mnemonic(
702 0 : OUStringToOString(aText, RTL_TEXTENCODING_UTF8).getStr());
703 0 : gtk_label_set_mnemonic_widget(GTK_LABEL(pLabel), pWidget);
704 0 : gtk_box_pack_start(GTK_BOX(pHbox), pLabel, FALSE, FALSE, 0);
705 : }
706 :
707 0 : gtk_box_pack_start(GTK_BOX(pHbox), pWidget, FALSE, FALSE, 0);
708 :
709 0 : pWidget = pHbox;
710 :
711 : }
712 : else
713 : SAL_INFO("vcl.gtk", "unhandled option type: " << aCtrlType);
714 :
715 0 : GtkWidget* pRow = NULL;
716 0 : if (pWidget)
717 : {
718 0 : if (bUseDependencyRow && !aDependsOnName.isEmpty())
719 : {
720 0 : pRow = aPropertyToDependencyRowMap[aDependsOnName + OUString::number(nDependsOnValue)];
721 0 : if (!pRow)
722 : {
723 0 : gtk_widget_destroy(pWidget);
724 0 : pWidget = NULL;
725 : }
726 : }
727 : }
728 0 : if (pWidget)
729 : {
730 0 : if (!pRow)
731 : {
732 0 : pRow = gtk_hbox_new(FALSE, 12);
733 0 : gtk_box_pack_start(GTK_BOX(pCurParent), pRow, FALSE, FALSE, 0);
734 : }
735 0 : if (!pGroup)
736 0 : aPropertyToDependencyRowMap[aPropertyName + OUString::number(0)] = pRow;
737 0 : gtk_box_pack_start(GTK_BOX(pRow), pWidget, FALSE, FALSE, 0);
738 : }
739 : }
740 0 : }
741 :
742 0 : if (pStandardPrintRangeContainer)
743 0 : gtk_widget_destroy(pStandardPrintRangeContainer);
744 :
745 0 : CustomTabs_t::const_reverse_iterator aEnd = aCustomTabs.rend();
746 0 : for (CustomTabs_t::const_reverse_iterator aI = aCustomTabs.rbegin(); aI != aEnd; ++aI)
747 : {
748 0 : gtk_widget_show_all(aI->first);
749 0 : m_pWrapper->print_unix_dialog_add_custom_tab(GTK_PRINT_UNIX_DIALOG(m_pDialog), aI->first,
750 0 : gtk_label_new(OUStringToOString(aI->second, RTL_TEXTENCODING_UTF8).getStr()));
751 0 : }
752 0 : }
753 :
754 : void
755 0 : GtkPrintDialog::impl_initPrintContent(uno::Sequence<sal_Bool> const& i_rDisabled)
756 : {
757 : SAL_WARN_IF(i_rDisabled.getLength() != 3, "vcl.gtk", "there is more choices than we expected");
758 0 : if (i_rDisabled.getLength() != 3)
759 0 : return;
760 :
761 0 : GtkPrintUnixDialog* const pDialog(GTK_PRINT_UNIX_DIALOG(m_pDialog));
762 :
763 : // XXX: This is a hack that depends on the number and the ordering of
764 : // the controls in the rDisabled sequence (cf. the intialization of
765 : // the "PrintContent" UI option in SwPrintUIOptions::SwPrintUIOptions,
766 : // sw/source/core/view/printdata.cxx)
767 0 : if (m_pWrapper->supportsPrintSelection() && !i_rDisabled[2])
768 : {
769 0 : m_pWrapper->print_unix_dialog_set_support_selection(pDialog, TRUE);
770 0 : m_pWrapper->print_unix_dialog_set_has_selection(pDialog, TRUE);
771 : }
772 :
773 : beans::PropertyValue* const pPrintContent(
774 0 : m_rController.getValue(OUString("PrintContent")));
775 :
776 0 : if (pPrintContent)
777 : {
778 0 : sal_Int32 nSelectionType(0);
779 0 : pPrintContent->Value >>= nSelectionType;
780 0 : GtkPrintSettings* const pSettings(getSettings());
781 0 : GtkPrintPages ePrintPages(GTK_PRINT_PAGES_ALL);
782 0 : switch (nSelectionType)
783 : {
784 : case 0:
785 0 : ePrintPages = GTK_PRINT_PAGES_ALL;
786 0 : break;
787 : case 1:
788 0 : ePrintPages = GTK_PRINT_PAGES_RANGES;
789 0 : break;
790 : case 2:
791 : #if GTK_CHECK_VERSION(2,14,0)
792 0 : if (m_pWrapper->supportsPrintSelection())
793 0 : ePrintPages = GTK_PRINT_PAGES_SELECTION;
794 : else
795 : #endif
796 : SAL_INFO("vcl.gtk", "the application wants to print a selection, but the present gtk version does not support it");
797 0 : break;
798 : default:
799 : SAL_WARN("vcl.gtk", "unexpected selection type: " << nSelectionType);
800 : }
801 0 : m_pWrapper->print_settings_set_print_pages(pSettings, ePrintPages);
802 0 : m_pWrapper->print_unix_dialog_set_settings(pDialog, pSettings);
803 0 : g_object_unref(G_OBJECT(pSettings));
804 : }
805 : }
806 :
807 : void
808 0 : GtkPrintDialog::impl_checkOptionalControlDependencies()
809 : {
810 0 : for (std::map<GtkWidget*, OUString>::iterator it = m_aControlToPropertyMap.begin();
811 0 : it != m_aControlToPropertyMap.end(); ++it)
812 : {
813 0 : gtk_widget_set_sensitive(it->first, m_rController.isUIOptionEnabled(it->second));
814 : }
815 0 : }
816 :
817 : beans::PropertyValue*
818 0 : GtkPrintDialog::impl_queryPropertyValue(GtkWidget* const i_pWidget) const
819 : {
820 0 : beans::PropertyValue* pVal(0);
821 0 : std::map<GtkWidget*, OUString>::const_iterator aIt(m_aControlToPropertyMap.find(i_pWidget));
822 0 : if (aIt != m_aControlToPropertyMap.end())
823 : {
824 0 : pVal = m_rController.getValue(aIt->second);
825 : SAL_WARN_IF(!pVal, "vcl.gtk", "property value not found");
826 : }
827 : else
828 : {
829 : SAL_WARN("vcl.gtk", "changed control not in property map");
830 : }
831 0 : return pVal;
832 : }
833 :
834 : void
835 0 : GtkPrintDialog::impl_UIOption_CheckHdl(GtkWidget* const i_pWidget)
836 : {
837 0 : beans::PropertyValue* const pVal = impl_queryPropertyValue(i_pWidget);
838 0 : if (pVal)
839 : {
840 0 : const bool bVal = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(i_pWidget));
841 0 : pVal->Value <<= bVal;
842 :
843 0 : impl_checkOptionalControlDependencies();
844 : }
845 0 : }
846 :
847 : void
848 0 : GtkPrintDialog::impl_UIOption_RadioHdl(GtkWidget* const i_pWidget)
849 : {
850 0 : if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(i_pWidget)))
851 : {
852 0 : beans::PropertyValue* const pVal = impl_queryPropertyValue(i_pWidget);
853 0 : std::map<GtkWidget*, sal_Int32>::const_iterator it = m_aControlToNumValMap.find(i_pWidget);
854 0 : if (pVal && it != m_aControlToNumValMap.end())
855 : {
856 :
857 0 : const sal_Int32 nVal = it->second;
858 0 : pVal->Value <<= nVal;
859 :
860 0 : impl_checkOptionalControlDependencies();
861 : }
862 : }
863 0 : }
864 :
865 : void
866 0 : GtkPrintDialog::impl_UIOption_SelectHdl(GtkWidget* const i_pWidget)
867 : {
868 0 : beans::PropertyValue* const pVal = impl_queryPropertyValue(i_pWidget);
869 0 : if (pVal)
870 : {
871 0 : const sal_Int32 nVal(gtk_combo_box_get_active(GTK_COMBO_BOX(i_pWidget)));
872 0 : pVal->Value <<= nVal;
873 :
874 0 : impl_checkOptionalControlDependencies();
875 : }
876 0 : }
877 :
878 : bool
879 0 : GtkPrintDialog::run()
880 : {
881 0 : bool bDoJob = false;
882 0 : bool bContinue = true;
883 0 : while (bContinue)
884 : {
885 0 : bContinue = false;
886 0 : const gint nStatus = gtk_dialog_run(GTK_DIALOG(m_pDialog));
887 0 : switch (nStatus)
888 : {
889 : case GTK_RESPONSE_HELP:
890 0 : fprintf(stderr, "To-Do: Help ?\n");
891 0 : bContinue = true;
892 0 : break;
893 : case GTK_RESPONSE_OK:
894 0 : bDoJob = true;
895 0 : break;
896 : default:
897 0 : break;
898 : }
899 : }
900 0 : gtk_widget_hide(m_pDialog);
901 0 : impl_storeToSettings();
902 0 : return bDoJob;
903 : }
904 :
905 : #if 0
906 : void GtkPrintDialog::ExportAsPDF(const OUString &rFileURL, GtkPrintSettings *pSettings) const
907 : {
908 : uno::Reference < XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );
909 : uno::Reference < XFrame > xFrame(xDesktop->getActiveFrame());
910 : if (!xFrame.is())
911 : xFrame = uno::Reference < XFrame >(xDesktop, UNO_QUERY);
912 :
913 : uno::Reference < XFilter > xFilter(
914 : ::comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.PDFFilter"),
915 : UNO_QUERY);
916 :
917 : if (xFilter.is())
918 : {
919 : uno::Reference< XController > xController;
920 : uno::Reference< XComponent > xDoc;
921 : if (xFrame.is())
922 : xController = xFrame->getController();
923 : if (xController.is())
924 : xDoc = uno::Reference< XComponent >(xController->getModel(), UNO_QUERY);
925 :
926 : SvFileStream aStream(rFileURL, STREAM_READWRITE | STREAM_SHARE_DENYWRITE | STREAM_TRUNC);
927 : uno::Reference< XOutputStream > xOStm(new utl::OOutputStreamWrapper(aStream));
928 :
929 : uno::Reference< XExporter > xExport(xFilter, UNO_QUERY);
930 : xExport->setSourceDocument(xDoc);
931 : uno::Sequence<beans::PropertyValue> aFilterData(2);
932 : aFilterData[0].Name = "PageLayout";
933 : aFilterData[0].Value <<= sal_Int32(0);
934 : aFilterData[1].Name = "FirstPageOnLeft";
935 : aFilterData[1].Value <<= sal_False;
936 :
937 : const gchar *pStr = gtk_print_settings_get(pSettings, GTK_PRINT_SETTINGS_PRINT_PAGES);
938 : if (pStr && !strcmp(pStr, "ranges"))
939 : {
940 : String aRangeText;
941 : gint num_ranges;
942 : const GtkPageRange* pRanges = gtk_print_settings_get_page_ranges(pSettings, &num_ranges);
943 : for (gint i = 0; i < num_ranges; ++i)
944 : {
945 : aRangeText.Append(OUString::number(pRanges[i].start+1));
946 : if (pRanges[i].start != pRanges[i].end)
947 : {
948 : aRangeText.AppendAscii("-");
949 : aRangeText.Append(OUString::number(pRanges[i].end+1));
950 : }
951 :
952 : if (i != num_ranges-1)
953 : aRangeText.AppendAscii(",");
954 : }
955 : aFilterData.realloc(aFilterData.getLength()+1);
956 : aFilterData[aFilterData.getLength()-1].Name = "PageRange";
957 : aFilterData[aFilterData.getLength()-1].Value <<= OUString(aRangeText);
958 : }
959 : else if (pStr && !strcmp(pStr, "current"))
960 : {
961 : try
962 : {
963 : uno::Reference< XSpreadsheetView > xSpreadsheetView;
964 : uno::Reference< XSpreadsheet> xSheet;
965 : uno::Reference< XSpreadsheetDocument > xSheetDoc;
966 : uno::Reference< XIndexAccess > xSheets;
967 : uno::Reference< XNamed > xName;
968 :
969 : if (xController.is())
970 : xSpreadsheetView = uno::Reference< XSpreadsheetView >(xController, UNO_QUERY);
971 : if (xSpreadsheetView.is())
972 : xSheet = uno::Reference< XSpreadsheet>(xSpreadsheetView->getActiveSheet());
973 : if (xSheet.is())
974 : xName = uno::Reference < XNamed >(xSheet, UNO_QUERY);
975 : if (xName.is())
976 : xSheetDoc = uno::Reference< XSpreadsheetDocument >(xController->getModel(), UNO_QUERY);
977 : if (xSheetDoc.is())
978 : xSheets = uno::Reference< XIndexAccess >(xSheetDoc->getSheets(), UNO_QUERY);
979 : if (xSheets.is())
980 : {
981 : const OUString &rName = xName->getName();
982 :
983 : sal_Int32 i;
984 :
985 : for (i = 0; i < xSheets->getCount(); ++i)
986 : {
987 : uno::Reference < XNamed > xItem =
988 : uno::Reference < XNamed >(xSheets->getByIndex(i), UNO_QUERY);
989 : if (rName == xItem->getName())
990 : break;
991 : }
992 :
993 : if (i < xSheets->getCount())
994 : {
995 : aFilterData.realloc(aFilterData.getLength()+1);
996 : aFilterData[aFilterData.getLength()-1].Name = "PageRange";
997 : aFilterData[aFilterData.getLength()-1].Value <<= OUString(OUString::number(i + 1));
998 : }
999 : }
1000 : }
1001 : catch (...) {}
1002 : }
1003 : #if GTK_CHECK_VERSION(2,17,5)
1004 : if (gtk_print_unix_dialog_get_has_selection(GTK_PRINT_UNIX_DIALOG(m_pDialog)))
1005 : {
1006 : uno::Any aSelection;
1007 : try
1008 : {
1009 : if (xController.is())
1010 : {
1011 : uno::Reference<view::XSelectionSupplier> xView(xController, UNO_QUERY);
1012 : if (xView.is())
1013 : xView->getSelection() >>= aSelection;
1014 : }
1015 : }
1016 : catch (const uno::RuntimeException &)
1017 : {
1018 : }
1019 : if (aSelection.hasValue())
1020 : {
1021 : aFilterData.realloc(aFilterData.getLength()+1);
1022 : aFilterData[aFilterData.getLength()-1].Name = "Selection";
1023 : aFilterData[aFilterData.getLength()-1].Value <<= aSelection;
1024 : }
1025 : }
1026 : #endif
1027 : uno::Sequence<beans::PropertyValue> aArgs(2);
1028 : aArgs[0].Name = "FilterData";
1029 : aArgs[0].Value <<= aFilterData;
1030 : aArgs[1].Name = "OutputStream";
1031 : aArgs[1].Value <<= xOStm;
1032 : xFilter->filter(aArgs);
1033 : }
1034 : }
1035 : #endif
1036 :
1037 : void
1038 0 : GtkPrintDialog::updateControllerPrintRange()
1039 : {
1040 0 : GtkPrintSettings* const pSettings(getSettings());
1041 : // TODO: use get_print_pages
1042 0 : if (const gchar* const pStr = m_pWrapper->print_settings_get(pSettings, GTK_PRINT_SETTINGS_PRINT_PAGES))
1043 : {
1044 0 : beans::PropertyValue* pVal = m_rController.getValue(OUString("PrintRange"));
1045 0 : if (!pVal)
1046 0 : pVal = m_rController.getValue(OUString("PrintContent"));
1047 : SAL_WARN_IF(!pVal, "vcl.gtk", "Nothing to map standard print options to!");
1048 0 : if (pVal)
1049 : {
1050 0 : sal_Int32 nVal = 0;
1051 0 : if (!strcmp(pStr, "all"))
1052 0 : nVal = 0;
1053 0 : else if (!strcmp(pStr, "ranges"))
1054 0 : nVal = 1;
1055 0 : else if (!strcmp(pStr, "selection"))
1056 0 : nVal = 2;
1057 0 : pVal->Value <<= nVal;
1058 :
1059 0 : if (nVal == 1)
1060 : {
1061 0 : pVal = m_rController.getValue(OUString("PageRange"));
1062 : SAL_WARN_IF(!pVal, "vcl.gtk", "PageRange doesn't exist!");
1063 0 : if (pVal)
1064 : {
1065 0 : OUStringBuffer sBuf;
1066 : gint num_ranges;
1067 0 : const GtkPageRange* const pRanges = m_pWrapper->print_settings_get_page_ranges(pSettings, &num_ranges);
1068 0 : for (gint i = 0; i != num_ranges && pRanges; ++i)
1069 : {
1070 0 : sBuf.append(sal_Int32(pRanges[i].start+1));
1071 0 : if (pRanges[i].start != pRanges[i].end)
1072 : {
1073 0 : sBuf.append('-');
1074 0 : sBuf.append(sal_Int32(pRanges[i].end+1));
1075 : }
1076 :
1077 0 : if (i != num_ranges-1)
1078 0 : sBuf.append(',');
1079 : }
1080 0 : pVal->Value <<= sBuf.makeStringAndClear();
1081 : }
1082 : }
1083 : }
1084 : }
1085 0 : g_object_unref(G_OBJECT(pSettings));
1086 0 : }
1087 :
1088 0 : GtkPrintDialog::~GtkPrintDialog()
1089 : {
1090 0 : gtk_widget_destroy(m_pDialog);
1091 0 : }
1092 :
1093 : void
1094 0 : GtkPrintDialog::impl_readFromSettings()
1095 : {
1096 0 : vcl::SettingsConfigItem* const pItem(vcl::SettingsConfigItem::get());
1097 0 : GtkPrintSettings* const pSettings(getSettings());
1098 :
1099 0 : const OUString aPrintDialogStr("PrintDialog");
1100 : const OUString aCopyCount(pItem->getValue(aPrintDialogStr,
1101 0 : OUString("CopyCount")));
1102 : const OUString aCollate(pItem->getValue(aPrintDialogStr,
1103 0 : OUString("Collate")));
1104 :
1105 0 : bool bChanged(false);
1106 :
1107 0 : const gint nOldCopyCount(m_pWrapper->print_settings_get_n_copies(pSettings));
1108 0 : const sal_Int32 nCopyCount(aCopyCount.toInt32());
1109 0 : if (nCopyCount > 0 && nOldCopyCount != nCopyCount)
1110 : {
1111 0 : bChanged = true;
1112 0 : m_pWrapper->print_settings_set_n_copies(pSettings, sal::static_int_cast<gint>(nCopyCount));
1113 : }
1114 :
1115 0 : const bool bOldCollate(m_pWrapper->print_settings_get_collate(pSettings));
1116 0 : const bool bCollate(aCollate.equalsIgnoreAsciiCase("true"));
1117 0 : if (bOldCollate != bCollate)
1118 : {
1119 0 : bChanged = true;
1120 0 : m_pWrapper->print_settings_set_collate(pSettings, bCollate);
1121 : }
1122 : // TODO: wth was this var. meant for?
1123 : (void) bChanged;
1124 :
1125 0 : m_pWrapper->print_unix_dialog_set_settings(GTK_PRINT_UNIX_DIALOG(m_pDialog), pSettings);
1126 0 : g_object_unref(G_OBJECT(pSettings));
1127 0 : }
1128 :
1129 : void
1130 0 : GtkPrintDialog::impl_storeToSettings()
1131 : const
1132 : {
1133 0 : vcl::SettingsConfigItem* const pItem(vcl::SettingsConfigItem::get());
1134 0 : GtkPrintSettings* const pSettings(getSettings());
1135 :
1136 0 : const OUString aPrintDialogStr("PrintDialog");
1137 : pItem->setValue(aPrintDialogStr,
1138 : OUString("CopyCount"),
1139 0 : OUString::number(m_pWrapper->print_settings_get_n_copies(pSettings)));
1140 : pItem->setValue(aPrintDialogStr,
1141 : OUString("Collate"),
1142 0 : m_pWrapper->print_settings_get_collate(pSettings)
1143 : ? OUString("true")
1144 0 : : OUString("false"))
1145 0 : ;
1146 : // pItem->setValue(aPrintDialog, OUString("ToFile"), );
1147 0 : g_object_unref(G_OBJECT(pSettings));
1148 0 : pItem->Commit();
1149 0 : }
1150 :
1151 : sal_uLong
1152 0 : GtkSalInfoPrinter::GetCapabilities(
1153 : const ImplJobSetup* const i_pSetupData,
1154 : const sal_uInt16 i_nType)
1155 : {
1156 0 : if (i_nType == PRINTER_CAPABILITIES_EXTERNALDIALOG && lcl_useSystemPrintDialog())
1157 0 : return 1;
1158 0 : return PspSalInfoPrinter::GetCapabilities(i_pSetupData, i_nType);
1159 0 : }
1160 :
1161 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
