LCOV - code coverage report
Current view: top level - vcl/unx/gtk/gdi - salprn-gtk.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 1 472 0.2 %
Date: 2015-06-13 12:38:46 Functions: 2 35 5.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11