You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 lines
18 KiB
551 lines
18 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2005 Jaroslaw Staniek <js@iidea.pl>
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this program; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "kexisimpleprintingpagesetup.h"
|
|
#include "kexisimpleprintingpagesetupbase.h"
|
|
#include "kexisimpleprintpreviewwindow.h"
|
|
|
|
#include <core/keximainwindow.h>
|
|
#include <kexiutils/utils.h>
|
|
#include <kexi_version.h>
|
|
|
|
#include <tdeapplication.h>
|
|
#include <kiconloader.h>
|
|
#include <tdelocale.h>
|
|
#include <tdefontdialog.h>
|
|
#include <kurllabel.h>
|
|
#include <kdebug.h>
|
|
#include <klineedit.h>
|
|
#include <kprinter.h>
|
|
#include <kpushbutton.h>
|
|
#include <tdeversion.h>
|
|
|
|
#include <tqlabel.h>
|
|
#include <tqtimer.h>
|
|
#include <tqlayout.h>
|
|
#include <tqpainter.h>
|
|
#include <tqcheckbox.h>
|
|
#include <tqwhatsthis.h>
|
|
#include <tqtooltip.h>
|
|
|
|
#include <kexiutils/tristate.h>
|
|
|
|
KexiSimplePrintingCommand::KexiSimplePrintingCommand(
|
|
KexiMainWindow* mainWin, int objectId, TQObject* parent)
|
|
: TQObject(parent, "KexiSimplePrintCommand")
|
|
, m_previewEngine(0)
|
|
, m_mainWin(mainWin)
|
|
, m_objectId(objectId)
|
|
, m_previewWindow(0)
|
|
, m_printPreviewNeedsReloading(false)
|
|
{
|
|
connect(this, TQ_SIGNAL(showPageSetupRequested(KexiPart::Item*)),
|
|
m_mainWin, TQ_SLOT(showPageSetupForItem(KexiPart::Item*)));
|
|
}
|
|
|
|
KexiSimplePrintingCommand::~KexiSimplePrintingCommand()
|
|
{
|
|
delete m_previewWindow;
|
|
delete m_previewEngine;
|
|
// delete m_settings;
|
|
}
|
|
|
|
|
|
bool KexiSimplePrintingCommand::print(const KexiSimplePrintingSettings& settings,
|
|
const TQString& aTitleText)
|
|
{
|
|
m_settings = settings;
|
|
return print(aTitleText);
|
|
}
|
|
|
|
bool KexiSimplePrintingCommand::print(const TQString& aTitleText)
|
|
{
|
|
KexiDB::Connection *conn = m_mainWin->project()->dbConnection();
|
|
KexiDB::TableOrQuerySchema tableOrQuery(conn, m_objectId);
|
|
if (!tableOrQuery.table() && !tableOrQuery.query()) {
|
|
//! @todo item not found
|
|
return false;
|
|
}
|
|
TQString titleText(aTitleText.stripWhiteSpace());
|
|
if (titleText.isEmpty())
|
|
titleText = tableOrQuery.captionOrName();
|
|
|
|
KexiSimplePrintingEngine engine(m_settings, this);
|
|
TQString errorMessage;
|
|
if (!engine.init(*conn, tableOrQuery, titleText, errorMessage)) {
|
|
if (!errorMessage.isEmpty())
|
|
KMessageBox::sorry(m_mainWin, errorMessage, i18n("Printing"));
|
|
return false;
|
|
}
|
|
|
|
//setup printing
|
|
#ifdef TQ_WS_WIN
|
|
TQPrinter printer(TQPrinter::HighResolution);
|
|
printer.setOrientation( m_settings.pageLayout.orientation == PG_PORTRAIT
|
|
? TQPrinter::Portrait : TQPrinter::Landscape );
|
|
printer.setPageSize(
|
|
(TQPrinter::PageSize)KoPageFormat::printerPageSize( m_settings.pageLayout.format ) );
|
|
|
|
// "chicken-egg" problem:
|
|
// we cannot use real from/to values in setMinMax() and setFromTo()
|
|
// because page count is known after obtaining print settings
|
|
printer.setFromTo(1,1);
|
|
#else
|
|
KPrinter printer;
|
|
printer.setOrientation( m_settings.pageLayout.orientation == PG_PORTRAIT
|
|
? KPrinter::Portrait : KPrinter::Landscape );
|
|
printer.setPageSize(
|
|
(KPrinter::PageSize)KoPageFormat::printerPageSize( m_settings.pageLayout.format ) );
|
|
#endif
|
|
|
|
printer.setFullPage(true);
|
|
TQString docName( titleText );
|
|
printer.setDocName( docName );
|
|
printer.setCreator(KEXI_APP_NAME);
|
|
if ( !printer.setup( m_mainWin ) ) {
|
|
return true;
|
|
}
|
|
|
|
// now we have final settings
|
|
|
|
//! @todo get printer.pageOrder() (for reversed order requires improved engine)
|
|
TQPainter painter;
|
|
|
|
if (!painter.begin(&printer)) {
|
|
//! @todo msg
|
|
return false;
|
|
}
|
|
engine.calculatePagesCount(painter);
|
|
|
|
uint loops, loopsPerPage;
|
|
TQValueList<int> pagesToPrint;
|
|
int fromPage = 0;
|
|
#ifdef TQ_WS_WIN
|
|
int toPage = 0;
|
|
if (TQPrinter::PageRange == printer.printRange()) {
|
|
fromPage = printer.fromPage();
|
|
toPage = printer.toPage();
|
|
}
|
|
if (fromPage==0 || toPage==0) {
|
|
fromPage = 0;
|
|
toPage = (int)engine.pagesCount()-1;
|
|
}
|
|
else {
|
|
fromPage--;
|
|
if (toPage > (int)engine.pagesCount())
|
|
toPage = (int)engine.pagesCount();
|
|
toPage--;
|
|
}
|
|
// win32 only supports one range, build the list
|
|
for (int i = fromPage; i<=toPage; i++) {
|
|
pagesToPrint.append(i);
|
|
}
|
|
// on win32 the OS does perform buffering (only when collation is off, each copy needs to be repeated)
|
|
loops = 1;
|
|
loopsPerPage = printer.collateCopies() ? 1 : printer.numCopies();
|
|
#else
|
|
// on !win32 print TQPrinter::numCopies() times (the OS does not perform buffering)
|
|
pagesToPrint = printer.pageList();
|
|
kdDebug() << pagesToPrint << endl;
|
|
if (pagesToPrint.isEmpty()) {
|
|
fromPage = 0;
|
|
for (int i = 0; i<(int)engine.pagesCount(); i++) {
|
|
pagesToPrint.append(i);
|
|
}
|
|
}
|
|
else
|
|
fromPage = pagesToPrint.first();
|
|
if (printer.collate()==KPrinter::Collate) {
|
|
//collation: p1, p2,..pn; p1, p2,..pn; ......; p1, p2,..pn
|
|
loops = printer.numCopies();
|
|
loopsPerPage = 1;
|
|
}
|
|
else {
|
|
//no collation: p1, p1, ..., p1; p2, p2, ..., p2; ......; pn, pn,..pn
|
|
loops = 1;
|
|
loopsPerPage = printer.numCopies();
|
|
}
|
|
//! @todo also look at printer.pageSet() option : all/odd/even pages
|
|
#endif
|
|
// now, total number of printed pages is printer.numCopies()*printer.pageList().count()
|
|
|
|
kdDebug() << "printing..." << endl;
|
|
bool firstPage = true;
|
|
for (uint copy = 0;copy < loops; copy++) {
|
|
kdDebug() << "copy " << (copy+1) << " of " << loops << endl;
|
|
uint pageNumber = fromPage;
|
|
TQValueList<int>::ConstIterator pagesIt = pagesToPrint.constBegin();
|
|
for(;(int)pageNumber == fromPage || !engine.eof(); ++pageNumber) {
|
|
kdDebug() << "printing..." << endl;
|
|
if (pagesIt == pagesToPrint.constEnd()) //no more pages to print
|
|
break;
|
|
if ((int)pageNumber < *pagesIt) { //skip pages without printing (needed for computation)
|
|
engine.paintPage(pageNumber, painter, false);
|
|
continue;
|
|
}
|
|
if (*pagesIt < (int)pageNumber) { //sanity
|
|
++pagesIt;
|
|
continue;
|
|
}
|
|
for (uint onePageCounter = 0; onePageCounter < loopsPerPage; onePageCounter++) {
|
|
if (!firstPage)
|
|
printer.newPage();
|
|
else
|
|
firstPage = false;
|
|
kdDebug() << "page #" << pageNumber << endl;
|
|
engine.paintPage(pageNumber, painter);
|
|
}
|
|
++pagesIt;
|
|
}
|
|
}
|
|
kdDebug() << "end of printing." << endl;
|
|
|
|
// stop painting, this will automatically send the print data to the printer
|
|
if (!painter.end())
|
|
return false;
|
|
|
|
if (!engine.done())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool KexiSimplePrintingCommand::showPrintPreview(const KexiSimplePrintingSettings& settings,
|
|
const TQString& aTitleText, bool reload)
|
|
{
|
|
m_settings = settings;
|
|
if (!m_previewEngine)
|
|
m_previewEngine = new KexiSimplePrintingEngine(m_settings, this);
|
|
|
|
if (reload)
|
|
m_printPreviewNeedsReloading = true;
|
|
|
|
bool backToPage0 = true;
|
|
TQString titleText(aTitleText.stripWhiteSpace());
|
|
KexiDB::Connection *conn = m_mainWin->project()->dbConnection();
|
|
KexiDB::TableOrQuerySchema tableOrQuery(conn, m_objectId);
|
|
if (!tableOrQuery.table() && !tableOrQuery.query()) {
|
|
//! @todo item not found
|
|
return false;
|
|
}
|
|
if (titleText.isEmpty())
|
|
titleText = tableOrQuery.captionOrName();
|
|
if (!m_previewWindow || m_printPreviewNeedsReloading) {
|
|
TQString errorMessage;
|
|
if (!m_previewEngine->init(
|
|
*conn, tableOrQuery, titleText, errorMessage)) {
|
|
if (!errorMessage.isEmpty())
|
|
KMessageBox::sorry(m_mainWin, errorMessage, i18n("Print Preview"));
|
|
return false;
|
|
}
|
|
}
|
|
if (!m_previewWindow) {
|
|
backToPage0 = false;
|
|
m_previewWindow = new KexiSimplePrintPreviewWindow(
|
|
*m_previewEngine, tableOrQuery.captionOrName(), 0,
|
|
TQt::WStyle_Customize|TQt::WStyle_NormalBorder|TQt::WStyle_Title|
|
|
TQt::WStyle_SysMenu|TQt::WStyle_MinMax|TQt::WStyle_ContextHelp);
|
|
connect(m_previewWindow, TQ_SIGNAL(printRequested()), this, TQ_SLOT(print()));
|
|
connect(m_previewWindow, TQ_SIGNAL(pageSetupRequested()), this, TQ_SLOT(slotShowPageSetupRequested()));
|
|
m_previewWindow->show();
|
|
KDialog::centerOnScreen(m_previewWindow);
|
|
m_printPreviewNeedsReloading = false;
|
|
}
|
|
|
|
if (m_printPreviewNeedsReloading) {//dirty
|
|
m_previewEngine->clear();
|
|
//! @todo progress bar...
|
|
m_previewEngine->setTitleText( titleText );
|
|
m_previewWindow->setFullWidth();
|
|
m_previewWindow->updatePagesCount();
|
|
m_printPreviewNeedsReloading = false;
|
|
}
|
|
if (backToPage0)
|
|
m_previewWindow->goToPage(0);
|
|
m_previewWindow->show();
|
|
m_previewWindow->raise();
|
|
// m_previewWindow->setPagesCount(INT_MAX); //will be properly set on demand
|
|
return true;
|
|
}
|
|
|
|
void KexiSimplePrintingCommand::slotShowPageSetupRequested()
|
|
{
|
|
m_mainWin->raise();
|
|
emit showPageSetupRequested( m_mainWin->project()->item( m_objectId ) );
|
|
}
|
|
|
|
/*void KexiSimplePrintingCommand::setPrintPreviewNeedsReloading()
|
|
{
|
|
m_printPreviewNeedsReloading = true;
|
|
}*/
|
|
|
|
//----------------------------------------------------------
|
|
|
|
KexiSimplePrintingPageSetup::KexiSimplePrintingPageSetup( KexiMainWindow *mainWin, TQWidget *parent,
|
|
TQMap<TQString,TQString>* args )
|
|
: KexiViewBase( mainWin, parent, "KexiSimplePrintingPageSetup" )
|
|
, m_settings( KexiSimplePrintingSettings::load() )
|
|
// , m_command(0)
|
|
{
|
|
// object to print
|
|
bool ok = args;
|
|
int objectId;
|
|
if (ok)
|
|
objectId = (*args)["identifier"].toInt();
|
|
ok = objectId<=0;
|
|
m_item = mainWin->project()->item( objectId );
|
|
ok = m_item;
|
|
|
|
bool printPreview = false;
|
|
bool print = false;
|
|
bool pageSetup = false;
|
|
if (ok) {
|
|
printPreview = (*args)["action"]=="printPreview";
|
|
print = (*args)["action"]=="print";
|
|
pageSetup = (*args)["action"]=="pageSetup";
|
|
ok = printPreview || print || pageSetup;
|
|
}
|
|
|
|
// settings
|
|
//! @todo default?
|
|
m_unit = TDELocale::Metric == TDEGlobal::locale()->measureSystem() ? KoUnit::U_CM : KoUnit::U_INCH;
|
|
|
|
// GUI
|
|
TQVBoxLayout *lyr = new TQVBoxLayout(this);
|
|
m_contents = new KexiSimplePrintingPageSetupBase(this, "KexiSimplePrintingPageSetupBase");
|
|
lyr->addWidget(m_contents);
|
|
|
|
setViewWidget(m_contents, true);
|
|
// setFocusPolicy(WheelFocus);
|
|
m_contents->setFocusProxy(m_contents->headerTitleLineEdit);
|
|
|
|
m_contents->printButton->setIconSet( KStdGuiItem::print().iconSet(TDEIcon::Small) );
|
|
m_contents->printButton->setText( KStdGuiItem::print().text() );
|
|
connect(m_contents->printButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(print()));
|
|
|
|
m_contents->printPreviewButton->setIconSet( SmallIconSet("document-print-preview") );
|
|
m_contents->printPreviewButton->setText( i18n("Print Previe&w...") );
|
|
connect(m_contents->printPreviewButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(printPreview()));
|
|
|
|
m_contents->iconLabel->setFixedWidth(32+6);
|
|
m_contents->iconLabel->setPixmap( DesktopIcon("text-x-generic", 32) );
|
|
TQWhatsThis::add(m_contents->headerTitleFontButton, i18n("Changes font for title text."));
|
|
connect(m_contents->headerTitleFontButton, TQ_SIGNAL(clicked()),
|
|
this, TQ_SLOT(slotChangeTitleFont()));
|
|
|
|
if (m_item) {
|
|
m_origCaptionLabelText = m_contents->captionLabel->text();
|
|
m_contents->headerTitleLineEdit->setText( m_item->captionOrName() );
|
|
if (m_item->mimeType()=="kexi/query") {
|
|
m_contents->openDataLink->setText( i18n("Open This Query") );
|
|
m_origCaptionLabelText = i18n("<h2>Page setup for printing \"%1\" query data</h2>");
|
|
}
|
|
m_contents->captionLabel->setText( m_origCaptionLabelText.arg(m_item->name()) );
|
|
}
|
|
connect(m_contents->headerTitleLineEdit,TQ_SIGNAL(textChanged(const TQString&)),
|
|
this, TQ_SLOT(slotTitleTextChanged(const TQString&)));
|
|
m_contents->headerTitleLineEdit->setFont( m_settings.pageTitleFont );
|
|
|
|
TQWhatsThis::add(m_contents->openDataLink,
|
|
i18n("Shows data for table or query associated with this page setup."));
|
|
TQToolTip::add(m_contents->openDataLink,
|
|
i18n("Shows data for table or query associated with this page setup."));
|
|
connect(m_contents->openDataLink, TQ_SIGNAL(leftClickedURL()), this, TQ_SLOT(slotOpenData()));
|
|
|
|
TQWhatsThis::add(m_contents->saveSetupLink, i18n("Saves settings for this setup as default."));
|
|
connect(m_contents->saveSetupLink, TQ_SIGNAL(leftClickedURL()), this, TQ_SLOT(slotSaveSetup()));
|
|
#if !KDE_IS_VERSION(3,5,1) && !defined(TQ_WS_WIN)
|
|
//a fix for problems with focusable KUrlLabel on KDElibs<=3.5.0
|
|
m_contents->openDataLink->setFocusPolicy(NoFocus);
|
|
m_contents->saveSetupLink->setFocusPolicy(NoFocus);
|
|
#endif
|
|
|
|
TQWhatsThis::add(m_contents->addDateTimeCheckbox, i18n("Adds date and time to the header."));
|
|
TQWhatsThis::add(m_contents->addPageNumbersCheckbox, i18n("Adds page numbers to the footer."));
|
|
TQWhatsThis::add(m_contents->addTableBordersCheckbox, i18n("Adds table borders."));
|
|
|
|
#ifdef KEXI_NO_UNFINISHED
|
|
m_contents->addDateTimeCheckbox->hide();
|
|
m_contents->addPageNumbersCheckbox->hide();
|
|
#endif
|
|
|
|
updatePageLayoutAndUnitInfo();
|
|
TQWhatsThis::add(m_contents->changePageSizeAndMarginsButton,
|
|
i18n("Changes page size and margins."));
|
|
connect(m_contents->changePageSizeAndMarginsButton, TQ_SIGNAL(clicked()),
|
|
this, TQ_SLOT(slotChangePageSizeAndMargins()));
|
|
|
|
connect(m_contents->addPageNumbersCheckbox, TQ_SIGNAL(toggled(bool)),
|
|
this, TQ_SLOT(slotAddPageNumbersCheckboxToggled(bool)));
|
|
connect(m_contents->addDateTimeCheckbox, TQ_SIGNAL(toggled(bool)),
|
|
this, TQ_SLOT(slotAddDateTimeCheckboxToggled(bool)));
|
|
connect(m_contents->addTableBordersCheckbox, TQ_SIGNAL(toggled(bool)),
|
|
this, TQ_SLOT(slotAddTableBordersCheckboxToggled(bool)));
|
|
|
|
if (!ok) {
|
|
// no data!
|
|
setEnabled(false);
|
|
}
|
|
|
|
m_contents->addPageNumbersCheckbox->setChecked( m_settings.addPageNumbers );
|
|
m_contents->addDateTimeCheckbox->setChecked( m_settings.addDateAndTime );
|
|
m_contents->addTableBordersCheckbox->setChecked( m_settings.addTableBorders );
|
|
setDirty(false);
|
|
|
|
// m_engine = new KexiSimplePrintingEngine(m_settings, this);
|
|
|
|
//clear it back to false after widgets initialization
|
|
m_printPreviewNeedsReloading = false;
|
|
|
|
/* if (printPreview)
|
|
TQTimer::singleShot(50, this, TQ_SLOT(printPreview()));
|
|
else if (print)
|
|
TQTimer::singleShot(50, this, TQ_SLOT(print()));*/
|
|
connect(this, TQ_SIGNAL(printItemRequested(KexiPart::Item*,const KexiSimplePrintingSettings&,
|
|
const TQString&)),
|
|
m_mainWin, TQ_SLOT(printItem(KexiPart::Item*,const KexiSimplePrintingSettings&,
|
|
const TQString&)));
|
|
connect(this, TQ_SIGNAL(printPreviewForItemRequested(KexiPart::Item*,
|
|
const KexiSimplePrintingSettings&,const TQString&,bool)),
|
|
m_mainWin, TQ_SLOT(printPreviewForItem(KexiPart::Item*,
|
|
const KexiSimplePrintingSettings&,const TQString&,bool)));
|
|
}
|
|
|
|
KexiSimplePrintingPageSetup::~KexiSimplePrintingPageSetup()
|
|
{
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::slotSaveSetup()
|
|
{
|
|
m_settings.save();
|
|
setDirty(false);
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::updatePageLayoutAndUnitInfo()
|
|
{
|
|
TQString s;
|
|
if (m_settings.pageLayout.format == PG_CUSTOM) {
|
|
s += TQString(" (%1 %2 x %3 %4)")
|
|
.arg(m_settings.pageLayout.ptWidth).arg(KoUnit::unitName(m_unit))
|
|
.arg(m_settings.pageLayout.ptHeight).arg(KoUnit::unitName(m_unit));
|
|
}
|
|
else
|
|
s += KoPageFormat::name(m_settings.pageLayout.format);
|
|
s += TQString(", ")
|
|
+ (m_settings.pageLayout.orientation == PG_PORTRAIT ? i18n("Portrait") : i18n("Landscape"))
|
|
+ ", " + i18n("margins:")
|
|
+ " " + KoUnit::toUserStringValue(m_settings.pageLayout.ptLeft, m_unit)
|
|
+ "/" + KoUnit::toUserStringValue(m_settings.pageLayout.ptRight, m_unit)
|
|
+ "/" + KoUnit::toUserStringValue(m_settings.pageLayout.ptTop, m_unit)
|
|
+ "/" + KoUnit::toUserStringValue(m_settings.pageLayout.ptBottom, m_unit)
|
|
+ " " + KoUnit::unitName(m_unit);
|
|
m_contents->pageSizeAndMarginsLabel->setText( s );
|
|
}
|
|
|
|
/*void KexiSimplePrintingPageSetup::setupPrintingCommand()
|
|
{
|
|
if (!m_command) {
|
|
m_command = new KexiSimplePrintingCommand(
|
|
m_mainWin, m_item->identifier(), m_settings, false/!owned/, this);
|
|
}
|
|
}*/
|
|
|
|
void KexiSimplePrintingPageSetup::print()
|
|
{
|
|
// setupPrintingCommand();
|
|
// m_command->print(m_contents->headerTitleLineEdit->text());
|
|
emit printItemRequested(m_item, m_settings, m_contents->headerTitleLineEdit->text());
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::printPreview()
|
|
{
|
|
// setupPrintingCommand();
|
|
// m_command->showPrintPreview(m_contents->headerTitleLineEdit->text());
|
|
emit printPreviewForItemRequested(m_item, m_settings,
|
|
m_contents->headerTitleLineEdit->text(), m_printPreviewNeedsReloading);
|
|
m_printPreviewNeedsReloading = false;
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::slotOpenData()
|
|
{
|
|
bool openingCancelled;
|
|
m_mainWin->openObject(m_item, Kexi::DataViewMode, openingCancelled);
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::slotTitleTextChanged(const TQString&)
|
|
{
|
|
if (m_contents->headerTitleLineEdit->isModified()) {
|
|
m_printPreviewNeedsReloading = true;
|
|
// if (m_command)
|
|
// m_command->setPrintPreviewNeedsReloading();
|
|
}
|
|
|
|
m_contents->headerTitleLineEdit->clearModified();
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::slotChangeTitleFont()
|
|
{
|
|
if (TQDialog::Accepted != TDEFontDialog::getFont(m_settings.pageTitleFont, false, this))
|
|
return;
|
|
m_contents->headerTitleLineEdit->setFont( m_settings.pageTitleFont );
|
|
setDirty(true);
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::slotChangePageSizeAndMargins()
|
|
{
|
|
KoHeadFoot headfoot; //dummy
|
|
|
|
if (int(TQDialog::Accepted) != KoPageLayoutDia::pageLayout(
|
|
m_settings.pageLayout, headfoot, FORMAT_AND_BORDERS | DISABLE_UNIT, m_unit, this ))
|
|
return;
|
|
|
|
//update
|
|
updatePageLayoutAndUnitInfo();
|
|
setDirty(true);
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::setDirty(bool set)
|
|
{
|
|
m_contents->saveSetupLink->setEnabled(set);
|
|
// if (m_command)
|
|
// m_command->setPrintPreviewNeedsReloading();
|
|
if (set)
|
|
m_printPreviewNeedsReloading = true;
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::slotAddPageNumbersCheckboxToggled(bool set)
|
|
{
|
|
m_settings.addPageNumbers = set;
|
|
setDirty(true);
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::slotAddDateTimeCheckboxToggled(bool set)
|
|
{
|
|
m_settings.addDateAndTime = set;
|
|
setDirty(true);
|
|
}
|
|
|
|
void KexiSimplePrintingPageSetup::slotAddTableBordersCheckboxToggled(bool set)
|
|
{
|
|
m_settings.addTableBorders = set;
|
|
setDirty(true);
|
|
}
|
|
|
|
#include "kexisimpleprintingpagesetup.moc"
|