#
# This file is part of the LibreOffice project.
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This file incorporates work covered by the following license notice:
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed
# with this work for additional information regarding copyright
# ownership. The ASF licenses this file to you under the Apache
# License, Version 2.0 (the "License"); you may not use this file
# except in compliance with the License. You may obtain a copy of
# the License at http://www.apache.org/licenses/LICENSE-2.0 .
#
import traceback
import os.path
from .FaxWizardDialog import FaxWizardDialog, uno, HID
from .CGFaxWizard import CGFaxWizard
from .FaxDocument import FaxDocument
from ..ui.PathSelection import PathSelection
from ..ui.event.UnoDataAware import UnoDataAware
from ..ui.event.RadioDataAware import RadioDataAware
from ..ui.event.CommonListener import TerminateListenerProcAdapter
from ..text.TextFieldHandler import TextFieldHandler
from ..text.TextElement import TextElement
from ..common.Configuration import Configuration
from ..common.SystemDialog import SystemDialog
from ..common.NoValidPathException import NoValidPathException
from ..common.HelpIds import HelpIds
from ..common.FileAccess import FileAccess
from ..common.Desktop import Desktop
from ..document.OfficeDocument import OfficeDocument
from com.sun.star.awt.VclWindowPeerAttribute import YES_NO, DEF_NO
from com.sun.star.util import CloseVetoException
from com.sun.star.view.DocumentZoomType import OPTIMAL
from com.sun.star.document.UpdateDocMode import FULL_UPDATE
from com.sun.star.document.MacroExecMode import ALWAYS_EXECUTE
class FaxWizardDialogImpl(FaxWizardDialog):
def leaveStep(self, nOldStep, nNewStep):
pass
def enterStep(self, nOldStep, nNewStep):
pass
RM_SENDERRECEIVER = 3
RM_FOOTER = 4
def __init__(self, xmsf):
super(FaxWizardDialogImpl, self).__init__(xmsf)
self.lstBusinessStylePos = None
self.lstPrivateStylePos = None
self.bSaveSuccess = False
self.filenameChanged = False
def startWizard(self, xMSF):
self.running = True
try:
#Number of steps on WizardDialog
self.nMaxStep = 5
#instantiate The Document Frame for the Preview
self.terminateListener = TerminateListenerProcAdapter(self.queryTermination)
self.myFaxDoc = FaxDocument(xMSF, self.terminateListener)
#create the dialog:
self.drawNaviBar()
self.buildStep1()
self.buildStep2()
self.buildStep3()
self.buildStep4()
self.buildStep5()
self.initializeSalutation()
self.initializeGreeting()
self.initializeCommunication()
self.initializePaths()
#special Control for setting the save Path:
self.insertPathSelectionControl()
self.initializeTemplates(xMSF)
#load the last used settings
#from the registry and apply listeners to the controls:
self.initConfiguration()
if self.myPathSelection.xSaveTextBox.Text.lower() == "":
self.myPathSelection.initializePath()
xContainerWindow = self.myFaxDoc.xFrame.ContainerWindow
self.createWindowPeer(xContainerWindow)
#add the Roadmap to the dialog:
self.insertRoadmap()
#load the last used document and apply last used settings:
#TODO:
self.setConfiguration()
#If the configuration does not define
#Greeting/Salutation/CommunicationType yet choose a default
self.__setDefaultForGreetingAndSalutationAndCommunication()
#disable functionality that is not supported by the template:
self.initializeElements()
#disable the document, so that the user cannot change anything:
self.myFaxDoc.xFrame.ComponentWindow.Enable = False
self.executeDialogFromComponent(self.myFaxDoc.xFrame)
self.removeTerminateListener()
self.closeDocument()
self.running = False
except Exception:
self.removeTerminateListener()
traceback.print_exc()
self.running = False
return
def cancelWizard(self):
self.xUnoDialog.endExecute()
self.running = False
def finishWizard(self):
self.switchToStep(self.getCurrentStep(), self.nMaxStep)
endWizard = True
try:
self.sPath = self.myPathSelection.getSelectedPath()
if not self.sPath or not os.path.exists(self.sPath):
self.myPathSelection.triggerPathPicker()
self.sPath = self.myPathSelection.getSelectedPath()
#first, if the filename was not changed, thus
#it is coming from a saved session, check if the
# file exists and warn the user.
if not self.filenameChanged:
answer = SystemDialog.showMessageBox(
self.xMSF, "MessBox", YES_NO + DEF_NO,
self.resources.resOverwriteWarning,
self.xUnoDialog.Peer)
if answer == 3:
# user said: no, do not overwrite...
endWizard = False
return False
self.myFaxDoc.setWizardTemplateDocInfo( \
self.resources.resFaxWizardDialog_title,
self.resources.resTemplateDescription)
self.myFaxDoc.killEmptyUserFields()
self.myFaxDoc.keepLogoFrame = bool(self.chkUseLogo.State)
self.myFaxDoc.keepTypeFrame = \
bool(self.chkUseCommunicationType.State)
self.myFaxDoc.killEmptyFrames()
self.bSaveSuccess = OfficeDocument.store(self.xMSF,
self.myFaxDoc.xTextDocument, self.sPath, "writer8_template")
if self.bSaveSuccess:
self.saveConfiguration()
xIH = self.xMSF.createInstance( \
"com.sun.star.comp.uui.UUIInteractionHandler")
loadValues = list(range(4))
loadValues[0] = uno.createUnoStruct( \
'com.sun.star.beans.PropertyValue')
loadValues[0].Name = "AsTemplate"
loadValues[0].Value = True
loadValues[1] = uno.createUnoStruct( \
'com.sun.star.beans.PropertyValue')
loadValues[1].Name = "MacroExecutionMode"
loadValues[1].Value = ALWAYS_EXECUTE
loadValues[2] = uno.createUnoStruct( \
'com.sun.star.beans.PropertyValue')
loadValues[2].Name = "UpdateDocMode"
loadValues[2].Value = FULL_UPDATE
loadValues[3] = uno.createUnoStruct( \
'com.sun.star.beans.PropertyValue')
loadValues[3].Name = "InteractionHandler"
loadValues[3].Value = xIH
if self.bEditTemplate:
loadValues[0].Value = False
else:
loadValues[0].Value = True
oDoc = OfficeDocument.load(Desktop.getDesktop(self.xMSF),
self.sPath, "_default", loadValues)
oDoc.CurrentController.ViewSettings.ZoomType = OPTIMAL
else:
pass
#TODO: Error Handling
except Exception:
traceback.print_exc()
finally:
if endWizard:
self.xUnoDialog.endExecute()
self.running = False
return True
def closeDocument(self):
try:
self.myFaxDoc.xFrame.close(False)
except CloseVetoException:
traceback.print_exc()
def drawConstants(self):
'''Localise the template'''
constRangeList = self.myFaxDoc.searchFillInItems(1)
for i in constRangeList:
text = i.String.lower()
aux = TextElement(i, self.resources.dictConstants[text])
aux.write()
def insertRoadmap(self):
self.addRoadmap()
self.insertRoadMapItems(
self.resources.RoadmapLabels, [True, True, True, False, True])
self.setRoadmapInteractive(True)
self.setRoadmapComplete(True)
self.setCurrentRoadmapItemID(1)
def insertPathSelectionControl(self):
self.myPathSelection = PathSelection(self.xMSF,
self, PathSelection.TransferMode.SAVE,
PathSelection.DialogTypes.FILE)
self.myPathSelection.insert(
5, 97, 70, 205, 45, self.resources.reslblTemplatePath_value,
True, HelpIds.getHelpIdString(HID + 34),
HelpIds.getHelpIdString(HID + 35))
self.myPathSelection.sDefaultDirectory = self.sUserTemplatePath
self.myPathSelection.sDefaultName = "myFaxTemplate.ott"
self.myPathSelection.sDefaultFilter = "writer8_template"
self.myPathSelection.addSelectionListener(self)
def initializeTemplates(self, xMSF):
try:
self.sFaxPath = self.sTemplatePath + "/wizard/fax"
self.BusinessFiles = FileAccess.getFolderTitles(xMSF, "bus",
self.sFaxPath, self.resources.dictBusinessTemplate)
self.PrivateFiles = FileAccess.getFolderTitles(xMSF, "pri",
self.sFaxPath, self.resources.dictPrivateTemplate)
self.xDialogModel.lstBusinessStyle.StringItemList = \
tuple(self.BusinessFiles[0])
self.xDialogModel.lstPrivateStyle.StringItemList = \
tuple(self.PrivateFiles[0])
self.xDialogModel.lstBusinessStyle.SelectedItems = (0,)
self.xDialogModel.lstPrivateStyle.SelectedItems = (0,)
return True
except NoValidPathException:
traceback.print_exc()
return False
def initializeElements(self):
self.xDialogModel.chkUseLogo.Enabled = \
self.myFaxDoc.hasElement("Company Logo")
self.xDialogModel.chkUseSubject.Enabled = \
self.myFaxDoc.hasElement("Subject Line")
self.xDialogModel.chkUseDate.Enabled = \
self.myFaxDoc.hasElement("Date")
self.myFaxDoc.updateDateFields()
def initializeSalutation(self):
#'Salutation' listbox
self.xDialogModel.lstSalutation.StringItemList = \
tuple(self.resources.SalutationLabels)
def initializeGreeting(self):
#'Complimentary Close' listbox
self.xDialogModel.lstGreeting.StringItemList = \
tuple(self.resources.GreetingLabels)
def initializeCommunication(self):
#'Type of message' listbox
self.xDialogModel.lstCommunicationType.StringItemList = \
tuple(self.resources.CommunicationLabels)
def __setDefaultForGreetingAndSalutationAndCommunication(self):
if not self.lstSalutation.Text:
self.lstSalutation.setText(self.resources.SalutationLabels[0])
if not self.lstGreeting.Text:
self.lstGreeting.setText(self.resources.GreetingLabels[0])
if not self.lstCommunicationType.Text:
self.lstCommunicationType.setText( \
self.resources.CommunicationLabels[0])
def initConfiguration(self):
try:
self.myConfig = CGFaxWizard()
root = Configuration.getConfigurationRoot(self.xMSF,
"/org.openoffice.Office.Writer/Wizards/Fax", False)
self.myConfig.readConfiguration(root, "cp_")
RadioDataAware.attachRadioButtons(
self.myConfig, "cp_FaxType",
(self.optBusinessFax, self.optPrivateFax), True).updateUI()
UnoDataAware.attachListBox(
self.myConfig.cp_BusinessFax, "cp_Style",
self.lstBusinessStyle, True).updateUI()
UnoDataAware.attachListBox(
self.myConfig.cp_PrivateFax, "cp_Style", self.lstPrivateStyle,
True).updateUI()
cgl = self.myConfig.cp_BusinessFax
UnoDataAware.attachCheckBox(cgl,
"cp_PrintCompanyLogo", self.chkUseLogo, True).updateUI()
UnoDataAware.attachCheckBox(cgl,
"cp_PrintSubjectLine", self.chkUseSubject, True).updateUI()
UnoDataAware.attachCheckBox(cgl,
"cp_PrintSalutation", self.chkUseSalutation, True).updateUI()
UnoDataAware.attachCheckBox(cgl,
"cp_PrintDate", self.chkUseDate, True).updateUI()
UnoDataAware.attachCheckBox(cgl, "cp_PrintCommunicationType",
self.chkUseCommunicationType, True).updateUI()
UnoDataAware.attachCheckBox(cgl,
"cp_PrintGreeting", self.chkUseGreeting, True).updateUI()
UnoDataAware.attachCheckBox(cgl,
"cp_PrintFooter", self.chkUseFooter, True).updateUI()
UnoDataAware.attachEditControl(cgl,
"cp_Salutation", self.lstSalutation, True).updateUI()
UnoDataAware.attachEditControl(cgl,
"cp_Greeting", self.lstGreeting, True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_CommunicationType",
self.lstCommunicationType, True).updateUI()
RadioDataAware.attachRadioButtons(cgl, "cp_SenderAddressType",
(self.optSenderDefine, self.optSenderPlaceholder),
True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_SenderCompanyName",
self.txtSenderName, True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_SenderStreet",
self.txtSenderStreet, True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_SenderPostCode",
self.txtSenderPostCode, True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_SenderState",
self.txtSenderState, True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_SenderCity",
self.txtSenderCity, True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_SenderFax",
self.txtSenderFax, True).updateUI()
RadioDataAware.attachRadioButtons(cgl, "cp_ReceiverAddressType",
(self.optReceiverDatabase, self.optReceiverPlaceholder),
True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_Footer",
self.txtFooter, True).updateUI()
UnoDataAware.attachCheckBox(cgl, "cp_FooterOnlySecondPage",
self.chkFooterNextPages, True).updateUI()
UnoDataAware.attachCheckBox(cgl, "cp_FooterPageNumbers",
self.chkFooterPageNumbers, True).updateUI()
RadioDataAware.attachRadioButtons(cgl, "cp_CreationType",
(self.optCreateFax, self.optMakeChanges), True).updateUI()
UnoDataAware.attachEditControl(cgl,
"cp_TemplateName", self.txtTemplateName, True).updateUI()
UnoDataAware.attachEditControl(cgl, "cp_TemplatePath",
self.myPathSelection.xSaveTextBox, True).updateUI()
except Exception:
traceback.print_exc()
def saveConfiguration(self):
try:
root = Configuration.getConfigurationRoot(self.xMSF,
"/org.openoffice.Office.Writer/Wizards/Fax", True)
self.myConfig.writeConfiguration(root, "cp_")
root.commitChanges()
except Exception:
traceback.print_exc()
def setConfiguration(self):
#set correct Configuration tree:
if self.optBusinessFax.State:
self.optBusinessFaxItemChanged()
elif self.optPrivateFax.State:
self.optPrivateFaxItemChanged()
def optBusinessFaxItemChanged(self):
self.lstPrivateStylePos = None
self.xDialogModel.lblBusinessStyle.Enabled = True
self.xDialogModel.lstBusinessStyle.Enabled = True
self.xDialogModel.lblPrivateStyle.Enabled = False
self.xDialogModel.lstPrivateStyle.Enabled = False
self.lstBusinessStyleItemChanged()
self.__enableSenderReceiver()
self.__setPossibleFooter(True)
def lstBusinessStyleItemChanged(self):
selectedItemPos = self.lstBusinessStyle.SelectedItemPos
#avoid to load the same item again
if self.lstBusinessStylePos != selectedItemPos:
self.lstBusinessStylePos = selectedItemPos
self.myFaxDoc.loadAsPreview(
self.BusinessFiles[1][selectedItemPos], False)
self.initializeElements()
self.setElements()
self.drawConstants()
def optPrivateFaxItemChanged(self):
self.lstBusinessStylePos = None
self.xDialogModel.lblBusinessStyle.Enabled = False
self.xDialogModel.lstBusinessStyle.Enabled = False
self.xDialogModel.lblPrivateStyle.Enabled = True
self.xDialogModel.lstPrivateStyle.Enabled = True
self.lstPrivateStyleItemChanged()
self.__disableSenderReceiver()
self.__setPossibleFooter(False)
def lstPrivateStyleItemChanged(self):
selectedItemPos = self.lstPrivateStyle.SelectedItemPos
#avoid to load the same item again
if self.lstPrivateStylePos != selectedItemPos:
self.lstPrivateStylePos = selectedItemPos
self.myFaxDoc.loadAsPreview(
self.PrivateFiles[1][selectedItemPos], False)
self.initializeElements()
self.setElements()
def txtTemplateNameTextChanged(self):
# Change Template Title in Properties
xDocProps = self.myFaxDoc.xTextDocument.DocumentProperties
xDocProps.Title = self.txtTemplateName.Text
def optSenderPlaceholderItemChanged(self):
self.xDialogModel.lblSenderName.Enabled = False
self.xDialogModel.lblSenderStreet.Enabled = False
self.xDialogModel.lblPostCodeCity.Enabled = False
self.xDialogModel.lblSenderFax.Enabled = False
self.xDialogModel.txtSenderName.Enabled = False
self.xDialogModel.txtSenderStreet.Enabled = False
self.xDialogModel.txtSenderPostCode.Enabled = False
self.xDialogModel.txtSenderState.Enabled = False
self.xDialogModel.txtSenderCity.Enabled = False
self.xDialogModel.txtSenderFax.Enabled = False
self.myFaxDoc.fillSenderWithUserData()
def optSenderDefineItemChanged(self):
self.xDialogModel.lblSenderName.Enabled = True
self.xDialogModel.lblSenderStreet.Enabled = True
self.xDialogModel.lblPostCodeCity.Enabled = True
self.xDialogModel.lblSenderFax.Enabled = True
self.xDialogModel.txtSenderName.Enabled = True
self.xDialogModel.txtSenderStreet.Enabled = True
self.xDialogModel.txtSenderPostCode.Enabled = True
self.xDialogModel.txtSenderState.Enabled = True
self.xDialogModel.txtSenderCity.Enabled = True
self.xDialogModel.txtSenderFax.Enabled = True
self.myFieldHandler = TextFieldHandler(self.myFaxDoc.xMSF,
self.myFaxDoc.xTextDocument)
self.txtSenderNameTextChanged()
self.txtSenderStreetTextChanged()
self.txtSenderPostCodeTextChanged()
self.txtSenderStateTextChanged()
self.txtSenderCityTextChanged()
self.txtSenderFaxTextChanged()
def txtSenderNameTextChanged(self):
self.myFieldHandler.changeUserFieldContent(
"Company", self.txtSenderName.Text)
def txtSenderStreetTextChanged(self):
self.myFieldHandler.changeUserFieldContent(
"Street", self.txtSenderStreet.Text)
def txtSenderCityTextChanged(self):
self.myFieldHandler.changeUserFieldContent(
"City", self.txtSenderCity.Text)
def txtSenderPostCodeTextChanged(self):
self.myFieldHandler.changeUserFieldContent(
"PostCode", self.txtSenderPostCode.Text)
def txtSenderStateTextChanged(self):
self.myFieldHandler.changeUserFieldContent(
"State", self.txtSenderState.Text)
def txtSenderFaxTextChanged(self):
self.myFieldHandler.changeUserFieldContent(
"Fax", self.txtSenderFax.Text)
#switch Elements on/off --------------------------------------------------
def setElements(self):
#UI relevant:
if self.optSenderDefine.State:
self.optSenderDefineItemChanged()
if self.optSenderPlaceholder.State:
self.optSenderPlaceholderItemChanged()
self.chkUseLogoItemChanged()
self.chkUseSubjectItemChanged()
self.chkUseSalutationItemChanged()
self.chkUseGreetingItemChanged()
self.chkUseCommunicationItemChanged()
self.chkUseDateItemChanged()
self.chkUseFooterItemChanged()
self.txtTemplateNameTextChanged()
#not UI relevant:
if self.optReceiverDatabase.State:
self.optReceiverDatabaseItemChanged()
elif self.optReceiverPlaceholder.State:
self.optReceiverPlaceholderItemChanged()
if self.optCreateFax.State:
self.optCreateFromTemplateItemChanged()
elif self.optMakeChanges.State:
self.optMakeChangesItemChanged()
def chkUseLogoItemChanged(self):
if self.myFaxDoc.hasElement("Company Logo"):
self.myFaxDoc.switchElement("Company Logo",
bool(self.chkUseLogo.State))
def chkUseSubjectItemChanged(self):
if self.myFaxDoc.hasElement("Subject Line"):
self.myFaxDoc.switchElement("Subject Line",
bool(self.chkUseSubject.State))
def chkUseDateItemChanged(self):
if self.myFaxDoc.hasElement("Date"):
self.myFaxDoc.switchElement("Date",
bool(self.chkUseDate.State))
def chkUseFooterItemChanged(self):
try:
bFooterPossible = bool(self.chkUseFooter.State) \
and bool(self.xDialogModel.chkUseFooter.Enabled)
if bool(self.chkFooterNextPages.State):
self.myFaxDoc.switchFooter("First Page", False,
bool(self.chkFooterPageNumbers.State),
self.txtFooter.Text)
self.myFaxDoc.switchFooter("Standard", bFooterPossible,
bool(self.chkFooterPageNumbers.State),
self.txtFooter.Text)
else:
self.myFaxDoc.switchFooter("First Page", bFooterPossible,
bool(self.chkFooterPageNumbers.State),
self.txtFooter.Text)
self.myFaxDoc.switchFooter("Standard", bFooterPossible,
bool(self.chkFooterPageNumbers.State),
self.txtFooter.Text)
#enable/disable roadmap item for footer page
BPaperItem = self.getRoadmapItemByID( \
FaxWizardDialogImpl.RM_FOOTER)
BPaperItem.Enabled = bFooterPossible
except Exception:
traceback.print_exc()
def chkFooterNextPagesItemChanged(self):
self.chkUseFooterItemChanged()
def chkFooterPageNumbersItemChanged(self):
self.chkUseFooterItemChanged()
def txtFooterTextChanged(self):
self.myFaxDoc.switchFooter("First Page", True,
bool(self.chkFooterPageNumbers.State),
self.txtFooter.Text)
def chkUseSalutationItemChanged(self):
self.myFaxDoc.switchUserField("Salutation",
self.lstSalutation.Text, bool(self.chkUseSalutation.State))
self.xDialogModel.lstSalutation.Enabled = \
bool(self.chkUseSalutation.State)
def lstSalutationItemChanged(self):
self.myFaxDoc.switchUserField("Salutation",
self.lstSalutation.Text, bool(self.chkUseSalutation.State))
def chkUseCommunicationItemChanged(self):
self.myFaxDoc.switchUserField("CommunicationType",
self.lstCommunicationType.Text,
bool(self.chkUseCommunicationType.State))
self.xDialogModel.lstCommunicationType.Enabled = \
bool(self.chkUseCommunicationType.State)
def lstCommunicationItemChanged(self):
self.myFaxDoc.switchUserField("CommunicationType",
self.lstCommunicationType.Text,
bool(self.chkUseCommunicationType.State))
def chkUseGreetingItemChanged(self):
self.myFaxDoc.switchUserField("Greeting",
self.lstGreeting.Text, bool(self.chkUseGreeting.State))
self.xDialogModel.lstGreeting.Enabled = \
bool(self.chkUseGreeting.State)
def lstGreetingItemChanged(self):
self.myFaxDoc.switchUserField("Greeting", self.lstGreeting.Text,
bool(self.chkUseGreeting.State))
def __setPossibleFooter(self, bState):
self.xDialogModel.chkUseFooter.Enabled = bState
if not bState:
self.chkUseFooter.State = 0
self.chkUseFooterItemChanged()
def optReceiverPlaceholderItemChanged(self):
OfficeDocument.attachEventCall(
self.myFaxDoc.xTextDocument, "OnNew", "StarBasic",
"macro:///Template.Correspondence.Placeholder()")
def optReceiverDatabaseItemChanged(self):
OfficeDocument.attachEventCall(
self.myFaxDoc.xTextDocument, "OnNew", "StarBasic",
"macro:///Template.Correspondence.Database()")
def __enableSenderReceiver(self):
BPaperItem = self.getRoadmapItemByID( \
FaxWizardDialogImpl.RM_SENDERRECEIVER)
BPaperItem.Enabled = True
def __disableSenderReceiver(self):
BPaperItem = self.getRoadmapItemByID( \
FaxWizardDialogImpl.RM_SENDERRECEIVER)
BPaperItem.Enabled = False
def validatePath(self):
if self.myPathSelection.usedPathPicker:
self.filenameChanged = True
self.myPathSelection.usedPathPicker = False