2293 lines
71 KiB
Plaintext
2293 lines
71 KiB
Plaintext
////////////////////////////////////////////////////////////////////////////////
|
|
// File: peplus.cpp
|
|
//
|
|
// Authors: Craig Chaplin
|
|
//
|
|
// Synopsis: This file contains the class implementations for CRPEngine and
|
|
// CRPEJob as well as any supporting classes and structures.
|
|
//
|
|
// History: 27/07/95 - CC - added GetNFormulas (4.0 only)
|
|
// - added GetNthFormula (4.0 only)
|
|
// 26/10/95 - CC - Internationalized (only MBCS so far)
|
|
// 09/05/96 - CC - Added 5.0 Print Engine calls
|
|
// 03/02/97 - CC - Added assertion check to GetSectionOptions
|
|
// 15/08/97 - CC - Modified CRPEParameterFieldInfo to reflect new
|
|
// 6.0 structure
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "peplus.h"
|
|
#include "crpe.h"
|
|
|
|
|
|
CRPEngine *CRPEngine::thePrintEngine = NULL;
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
// Supporting structures used by CRPEngine and CRPEJob classes
|
|
//////////////////////////////////////////////////////////////
|
|
CRPEReportOptions::CRPEReportOptions (short saveDataWithReport,
|
|
short saveSummariesWithReport,
|
|
short useIndexForSpeed,
|
|
short translateDOSStrings,
|
|
short translateDOSMemos,
|
|
short convertDateTimeType,
|
|
short convertNullFieldToDefault,
|
|
short morePrintEngineErrorMessages,
|
|
short caseInsensitiveSQLData,
|
|
short verifyOnEveryPrint,
|
|
short zoomMode,
|
|
short hasGroupTree,
|
|
short dontGenerateDataForHiddenObjects,
|
|
short performGroupingOnServer,
|
|
short doAsyncQuery
|
|
) :
|
|
m_StructSize(sizeof(CRPEReportOptions)),
|
|
m_saveDataWithReport(saveDataWithReport),
|
|
m_saveSummariesWithReport(saveSummariesWithReport),
|
|
m_useIndexForSpeed(useIndexForSpeed),
|
|
m_translateDOSStrings(translateDOSStrings),
|
|
m_translateDOSMemos(translateDOSMemos),
|
|
m_convertDateTimeType(convertDateTimeType),
|
|
m_convertNullFieldToDefault(convertNullFieldToDefault),
|
|
m_morePrintEngineErrorMessages(morePrintEngineErrorMessages),
|
|
m_caseInsensitiveSQLData(caseInsensitiveSQLData),
|
|
m_verifyOnEveryPrint(verifyOnEveryPrint),
|
|
m_zoomMode(zoomMode),
|
|
m_hasGroupTree(hasGroupTree),
|
|
m_dontGenerateDataForHiddenObjects(dontGenerateDataForHiddenObjects),
|
|
m_performGroupingOnServer(performGroupingOnServer),
|
|
m_doAsyncQuery(doAsyncQuery)
|
|
|
|
{}
|
|
|
|
|
|
CRPELogOnInfo::CRPELogOnInfo (const _TCHAR *serverName,
|
|
const _TCHAR *databaseName,
|
|
const _TCHAR *userID,
|
|
const _TCHAR *password
|
|
) :
|
|
m_StructSize(sizeof(CRPELogOnInfo))
|
|
{
|
|
lstrcpyn(m_serverName,serverName,sizeof(m_serverName) - 1);
|
|
lstrcpyn(m_databaseName,databaseName,sizeof(m_databaseName) - 1);
|
|
lstrcpyn(m_userID,userID,sizeof(m_userID) - 1);
|
|
lstrcpyn(m_password,password,sizeof(m_password) - 1);
|
|
}
|
|
|
|
|
|
CRPESessionInfo::CRPESessionInfo (const _TCHAR *userID,
|
|
const _TCHAR *password,
|
|
DWORD sessionHandle
|
|
) :
|
|
m_StructSize(sizeof(CRPESessionInfo)),
|
|
m_sessionHandle(sessionHandle)
|
|
{
|
|
lstrcpyn(m_userID,userID,sizeof(m_userID) - 1);
|
|
lstrcpyn(m_password,password,sizeof(m_password) - 1);
|
|
}
|
|
|
|
CRPEExportOptions::CRPEExportOptions (const _TCHAR *formatDLLName,
|
|
DWORD formatType,
|
|
void *formatOptions,
|
|
const _TCHAR *destinationDLLName,
|
|
DWORD destinationType,
|
|
void *destinationOptions
|
|
) :
|
|
m_StructSize(sizeof(CRPEExportOptions)),
|
|
m_formatType(formatType),
|
|
m_formatOptions(formatOptions),
|
|
m_destinationType(destinationType),
|
|
m_destinationOptions(destinationOptions)
|
|
{
|
|
lstrcpyn(m_formatDLLName,formatDLLName,sizeof(m_formatDLLName) - 1);
|
|
lstrcpyn(m_destinationDLLName,destinationDLLName,sizeof(m_destinationDLLName) - 1);
|
|
}
|
|
|
|
CRPEParameterFieldInfo::CRPEParameterFieldInfo (WORD ValueType,
|
|
WORD DefaultValueSet,
|
|
WORD CurrentValueSet,
|
|
const _TCHAR *name,
|
|
const _TCHAR *prompt,
|
|
const _TCHAR *DefaultValue,
|
|
const _TCHAR *CurrentValue,
|
|
WORD isLimited,
|
|
double MinSize,
|
|
double MaxSize,
|
|
const _TCHAR *EditMask,
|
|
WORD isHidden
|
|
) :
|
|
m_StructSize(sizeof(CRPEParameterFieldInfo)),
|
|
m_ValueType(ValueType),
|
|
m_DefaultValueSet(DefaultValueSet),
|
|
m_CurrentValueSet(CurrentValueSet),
|
|
m_isLimited(isLimited),
|
|
m_MinSize(MinSize),
|
|
m_MaxSize(MaxSize),
|
|
m_isHidden(isHidden)
|
|
|
|
{
|
|
lstrcpyn(m_Name,name,sizeof(m_Name) - 1);
|
|
lstrcpyn(m_Prompt,prompt,sizeof(m_Prompt) - 1);
|
|
lstrcpyn(m_DefaultValue,DefaultValue,sizeof(m_DefaultValue) - 1);
|
|
lstrcpyn(m_CurrentValue,CurrentValue,sizeof(m_CurrentValue) - 1);
|
|
lstrcpyn(m_EditMask, EditMask, sizeof(m_EditMask) - 1);
|
|
}
|
|
|
|
|
|
//////////////////
|
|
// CRPEngine Class
|
|
//////////////////
|
|
|
|
CRPEngine *CRPEngine::GetEngine(void)
|
|
{
|
|
return CRPEngine::thePrintEngine;
|
|
}
|
|
|
|
|
|
CRPEngine::Status CRPEngine::GetEngineStatus(void)
|
|
{
|
|
return(thePrintEngine != 0) ? thePrintEngine->m_engineStatus : engineMissing;
|
|
}
|
|
|
|
|
|
// constructors and destructor
|
|
|
|
|
|
CRPEngine::CRPEngine (BOOL open) : m_engineStatus(engineClosed),
|
|
m_engineError(0)
|
|
{
|
|
ASSERT (thePrintEngine == NULL); // only one object of CRPEngine is allowed
|
|
|
|
CRPEngine::thePrintEngine = this;
|
|
|
|
if (open)
|
|
Open();
|
|
}
|
|
|
|
|
|
CRPEngine::~CRPEngine()
|
|
{
|
|
ASSERT (thePrintEngine == this); // only one object of CRPEngine allowed
|
|
|
|
Close();
|
|
CRPEngine::thePrintEngine = NULL;
|
|
}
|
|
|
|
|
|
// operations
|
|
|
|
|
|
BOOL CRPEngine::Open(void)
|
|
{
|
|
m_engineError = 0;
|
|
|
|
if (m_engineStatus == engineOpen)
|
|
return TRUE;
|
|
|
|
if (PEOpenEngine()) {
|
|
m_engineStatus = engineOpen;
|
|
return TRUE;
|
|
}
|
|
else {
|
|
m_engineStatus = engineClosed;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
void CRPEngine::Close(void)
|
|
{
|
|
m_engineError = 0;
|
|
|
|
if (m_engineStatus == engineOpen) {
|
|
|
|
while (m_printJobs.GetSize())
|
|
((CRPEJob *)m_printJobs[0]) -> Close();
|
|
|
|
PECloseEngine();
|
|
m_engineStatus = engineClosed;
|
|
}
|
|
}
|
|
|
|
|
|
CRPEJob *CRPEngine::OpenJob(const _TCHAR *reportFileName)
|
|
{
|
|
ASSERT (m_engineStatus == engineOpen); // engine must be open
|
|
|
|
short jobHandle = 0;
|
|
CRPEJob *newJob = NULL;
|
|
|
|
m_engineError = 0;
|
|
|
|
if ((jobHandle = PEOpenPrintJob((_TCHAR *)reportFileName)) == 0)
|
|
return NULL;
|
|
|
|
if ((newJob = new CRPEJob(jobHandle)) == NULL) {
|
|
PEClosePrintJob(jobHandle);
|
|
m_engineError = PEP_ERR_NOTENOUGHMEMORY;
|
|
return NULL;
|
|
}
|
|
|
|
return newJob;
|
|
}
|
|
|
|
|
|
BOOL CRPEngine::LogOnServer(const _TCHAR *dllName,const CRPELogOnInfo *logOnInfo)
|
|
{
|
|
// ensure CRPELogOnInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPELogOnInfo) == sizeof(PELogOnInfo));
|
|
|
|
ASSERT (m_engineStatus == engineOpen); // engine must be open
|
|
|
|
m_engineError = 0;
|
|
|
|
return (PELogOnServer((_TCHAR *)dllName,(struct PELogOnInfo *) logOnInfo));
|
|
}
|
|
|
|
|
|
BOOL CRPEngine::LogOffServer(const _TCHAR *dllName,
|
|
const CRPELogOnInfo *logOnInfo)
|
|
{
|
|
// ensure CRPELogOnInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPELogOnInfo) == sizeof(PELogOnInfo));
|
|
|
|
ASSERT (m_engineStatus == engineOpen); // engine must be open
|
|
|
|
m_engineError = 0;
|
|
|
|
return (PELogOffServer((_TCHAR *)dllName,(struct PELogOnInfo *) logOnInfo));
|
|
}
|
|
|
|
|
|
BOOL CRPEngine::LogOnSQLServerWithPrivateInfo(const _TCHAR *dllName,
|
|
void *privateInfo)
|
|
{
|
|
return PELogOnSQLServerWithPrivateInfo((_TCHAR *)dllName,privateInfo);
|
|
}
|
|
|
|
|
|
short CRPEngine::PrintReport(const _TCHAR *reportFilePath,
|
|
BOOL toPrinter,
|
|
BOOL toWindow,
|
|
const _TCHAR *title,
|
|
int left,
|
|
int top,
|
|
int width,
|
|
int height,
|
|
DWORD style,
|
|
CWnd *parentWindow)
|
|
{
|
|
ASSERT (m_engineStatus == engineOpen); // engine must be open
|
|
|
|
m_engineError = 0;
|
|
|
|
return PEPrintReport((_TCHAR *)reportFilePath,
|
|
toPrinter,
|
|
toWindow,
|
|
(_TCHAR *)title,
|
|
left,
|
|
top,
|
|
width,
|
|
height,
|
|
style,
|
|
parentWindow != 0 ? parentWindow->m_hWnd : 0);
|
|
}
|
|
|
|
|
|
// attributes
|
|
|
|
|
|
BOOL CRPEngine::CanClose()
|
|
{
|
|
return (m_engineStatus != engineOpen) ? TRUE : PECanCloseEngine();
|
|
}
|
|
|
|
|
|
short CRPEngine::GetVersion(short versionRequested)
|
|
{
|
|
ASSERT (m_engineStatus == engineOpen); // engine must be open
|
|
|
|
m_engineError = 0;
|
|
|
|
return PEGetVersion(versionRequested);
|
|
}
|
|
|
|
|
|
short CRPEngine::GetErrorCode(void)
|
|
{
|
|
return (m_engineError) ? m_engineError : PEGetErrorCode(0);
|
|
}
|
|
|
|
|
|
CString CRPEngine::GetErrorText(void)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
CString errorText = "";
|
|
|
|
if (!m_engineError)
|
|
if (PEGetErrorText(0,&textHandle,&textLength))
|
|
GetHandleString(textHandle,textLength,errorText);
|
|
|
|
return errorText;
|
|
}
|
|
|
|
|
|
int CRPEngine::GetNPrintJobs()
|
|
{
|
|
return m_printJobs.GetSize();
|
|
}
|
|
|
|
|
|
// implementation
|
|
|
|
|
|
void CRPEngine::AddJob(CRPEJob *job)
|
|
{
|
|
m_printJobs.Add(job);
|
|
}
|
|
|
|
|
|
void CRPEngine::RemoveJob(CRPEJob *job)
|
|
{
|
|
int numJobs = m_printJobs.GetSize();
|
|
|
|
while (numJobs--)
|
|
if (m_printJobs[numJobs] == job) {
|
|
m_printJobs.RemoveAt(numJobs);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL CRPEngine::GetHandleString(HANDLE textHandle,
|
|
short textLength,
|
|
CString &string)
|
|
{
|
|
BOOL result = FALSE;
|
|
_TCHAR *buffer = string.GetBufferSetLength(textLength);
|
|
|
|
if (buffer) {
|
|
result = PEGetHandleString(textHandle,buffer,textLength);
|
|
string.ReleaseBuffer();
|
|
}
|
|
else
|
|
m_engineError = PEP_ERR_NOTENOUGHMEMORY;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// CRPEngine diagnostics
|
|
|
|
|
|
#ifdef _DEBUG
|
|
void CRPEngine::AssertValid() const
|
|
{
|
|
CObject::AssertValid();
|
|
}
|
|
|
|
|
|
void CRPEngine::Dump(CDumpContext& dc) const
|
|
{
|
|
CObject::Dump(dc);
|
|
}
|
|
|
|
#endif //_DEBUG
|
|
|
|
|
|
////////////////
|
|
// CRPEJob Class
|
|
////////////////
|
|
|
|
// constructors & destructor
|
|
|
|
CRPEJob::CRPEJob(short jobHandle) : m_jobHandle(jobHandle),
|
|
m_parentJob(NULL),
|
|
m_mdiOutput(FALSE)
|
|
{
|
|
// engine object must exist
|
|
ASSERT (CRPEngine::GetEngine() != NULL);
|
|
// engine must be open
|
|
ASSERT (CRPEngine::GetEngineStatus() == CRPEngine::engineOpen);
|
|
// job handle can't be 0
|
|
ASSERT (jobHandle != 0);
|
|
|
|
CRPEngine::GetEngine()->AddJob(this);
|
|
}
|
|
|
|
|
|
CRPEJob::CRPEJob(short jobHandle,
|
|
CRPEJob *parentJob
|
|
) :
|
|
m_jobHandle(jobHandle)
|
|
{
|
|
// engine object must exist
|
|
ASSERT (CRPEngine::GetEngine() != NULL);
|
|
// engine must be open
|
|
ASSERT (CRPEngine::GetEngineStatus() == CRPEngine::engineOpen);
|
|
// job handle can't be 0
|
|
ASSERT (jobHandle != 0);
|
|
// parent job can't be NULL
|
|
ASSERT (parentJob != NULL);
|
|
|
|
m_parentJob = parentJob;
|
|
m_parentJob->AddSubReportJob(this);
|
|
}
|
|
|
|
|
|
CRPEJob::~CRPEJob()
|
|
{
|
|
ASSERT (CRPEngine::GetEngine() != NULL); // engine object must exist
|
|
|
|
for (int x = 0; x < m_subReportJobs.GetSize(); x++)
|
|
{
|
|
((CRPEJob *)m_subReportJobs[x]) -> CloseSubreport();
|
|
}
|
|
|
|
if (m_parentJob)
|
|
m_parentJob->RemoveSubReportJob(this);
|
|
else
|
|
CRPEngine::GetEngine()->RemoveJob(this);
|
|
|
|
PEClosePrintJob(m_jobHandle);
|
|
}
|
|
|
|
|
|
// operations
|
|
|
|
BOOL CRPEJob::GetReportOptions (CRPEReportOptions *reportOptions)
|
|
{
|
|
return PEGetReportOptions(m_jobHandle,
|
|
(struct PEReportOptions *) reportOptions);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetReportOptions (CRPEReportOptions *reportOptions)
|
|
{
|
|
return PESetReportOptions(m_jobHandle,
|
|
(struct PEReportOptions *) reportOptions);
|
|
}
|
|
|
|
BOOL CRPEJob::GetReportSummaryInfo(CRPEReportSummaryInfo *summaryInfo)
|
|
{
|
|
ASSERT (sizeof(CRPEReportSummaryInfo) == sizeof(PEReportSummaryInfo));
|
|
|
|
return PEGetReportSummaryInfo(m_jobHandle,
|
|
(struct PEReportSummaryInfo *) summaryInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::SetReportSummaryInfo(CRPEReportSummaryInfo *summaryInfo)
|
|
{
|
|
ASSERT (sizeof(CRPEReportSummaryInfo) == sizeof(PEReportSummaryInfo));
|
|
|
|
return PESetReportSummaryInfo(m_jobHandle,
|
|
(struct PEReportSummaryInfo *) summaryInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::Start()
|
|
{
|
|
if (m_mdiOutput)
|
|
{
|
|
CRPEMDIChildWnd *child = new CRPEMDIChildWnd;
|
|
CRect rect(m_mdiLeft,m_mdiTop,m_mdiLeft + m_mdiWidth,m_mdiTop + m_mdiHeight);
|
|
|
|
child->Create(NULL,
|
|
m_mdiTitle,
|
|
WS_CHILD | WS_VISIBLE | WS_OVERLAPPEDWINDOW | m_mdiStyle,
|
|
rect);
|
|
|
|
child->GetClientRect(rect);
|
|
|
|
if (!PEOutputToWindow(m_jobHandle,
|
|
0,
|
|
(int)rect.left,
|
|
(int)rect.top,
|
|
(int)rect.Width (),
|
|
(int)rect.Height (),
|
|
WS_CHILD | WS_VISIBLE,
|
|
child->m_hWnd))
|
|
return FALSE;
|
|
|
|
if (!PEStartPrintJob(m_jobHandle,TRUE))
|
|
return FALSE;
|
|
|
|
return ((child->m_printWnd = GetWindowHandle()) != NULL);
|
|
}
|
|
|
|
return PEStartPrintJob(m_jobHandle,TRUE);
|
|
}
|
|
|
|
|
|
void CRPEJob::Close()
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
|
|
void CRPEJob::Cancel()
|
|
{
|
|
PECancelPrintJob(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ShowNextPage(void)
|
|
{
|
|
return PEShowNextPage(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ShowFirstPage(void)
|
|
{
|
|
return PEShowFirstPage(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ShowPreviousPage(void)
|
|
{
|
|
return PEShowPreviousPage(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ShowLastPage(void)
|
|
{
|
|
return PEShowLastPage(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ShowNthPage(short pageN)
|
|
{
|
|
return PEShowNthPage(m_jobHandle,pageN);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ShowPrintControls(BOOL showControls)
|
|
{
|
|
return PEShowPrintControls(m_jobHandle,showControls);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ZoomPreviewWindow(short level)
|
|
{
|
|
return PEZoomPreviewWindow(m_jobHandle,level);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::NextWindowMagnification(void)
|
|
{
|
|
return PENextPrintWindowMagnification(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::PrintWindow(void)
|
|
{
|
|
return PEPrintWindow(m_jobHandle,TRUE);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ExportPrintWindow(BOOL toMail)
|
|
{
|
|
return PEExportPrintWindow(m_jobHandle,toMail,TRUE);
|
|
}
|
|
|
|
|
|
void CRPEJob::CloseWindow(void)
|
|
{
|
|
PECloseWindow(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::TestNthTableConnectivity(short tableN)
|
|
{
|
|
return PETestNthTableConnectivity(m_jobHandle,tableN);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::DiscardSavedData (void)
|
|
{
|
|
return PEDiscardSavedData(m_jobHandle);
|
|
}
|
|
|
|
|
|
// report fomula text attributes
|
|
|
|
|
|
short CRPEJob::GetNFormulas()
|
|
{
|
|
return PEGetNFormulas(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthFormula(short formulaN,
|
|
CString &formulaName,
|
|
CString &formulaText)
|
|
{
|
|
HANDLE nameHandle;
|
|
short nameLength;
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
|
|
BOOL result = FALSE;
|
|
|
|
formulaName = "";
|
|
formulaText = "";
|
|
|
|
if (PEGetNthFormula(m_jobHandle,
|
|
formulaN,
|
|
&nameHandle,
|
|
&nameLength,
|
|
&textHandle,
|
|
&textLength))
|
|
if ((result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
formulaText)))
|
|
result = CRPEngine::GetEngine()->GetHandleString(nameHandle,
|
|
nameLength,
|
|
formulaName);
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetFormula(const _TCHAR *formulaName,
|
|
CString &formulaText)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
formulaText = "";
|
|
|
|
if (PEGetFormula(m_jobHandle,
|
|
(_TCHAR *)formulaName,
|
|
&textHandle,
|
|
&textLength))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
formulaText);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetFormula(const _TCHAR *formulaName,
|
|
const _TCHAR *formulaText)
|
|
{
|
|
return PESetFormula(m_jobHandle,(_TCHAR *)formulaName,(_TCHAR *)formulaText);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::CheckFormula(const _TCHAR *formulaName)
|
|
{
|
|
return PECheckFormula(m_jobHandle,(_TCHAR *)formulaName);
|
|
}
|
|
|
|
|
|
// record selection formula attributes
|
|
|
|
|
|
BOOL CRPEJob::GetSelectionFormula(CString &formulaText)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
formulaText = "";
|
|
|
|
if (PEGetSelectionFormula(m_jobHandle,
|
|
&textHandle,
|
|
&textLength))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
formulaText);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetSelectionFormula(const _TCHAR *formulaText)
|
|
{
|
|
return PESetSelectionFormula(m_jobHandle,(_TCHAR *)formulaText);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::CheckSelectionFormula ()
|
|
{
|
|
return PECheckSelectionFormula(m_jobHandle);
|
|
}
|
|
|
|
|
|
// group selection formula attributes
|
|
|
|
|
|
BOOL CRPEJob::GetGroupSelectionFormula(CString &formulaText)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
formulaText = "";
|
|
|
|
if (PEGetGroupSelectionFormula(m_jobHandle,
|
|
&textHandle,
|
|
&textLength))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
formulaText);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetGroupSelectionFormula(const _TCHAR *formulaText)
|
|
{
|
|
return PESetGroupSelectionFormula(m_jobHandle,(_TCHAR *)formulaText);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::CheckGroupSelectionFormula()
|
|
{
|
|
return PECheckGroupSelectionFormula(m_jobHandle);
|
|
}
|
|
|
|
//SQL Expressions
|
|
short CRPEJob::GetNSQLExpressions()
|
|
{
|
|
return PEGetNSQLExpressions(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthSQLExpression(short expressionN,
|
|
CString &expressionName,
|
|
CString &expressionText)
|
|
{
|
|
HANDLE nameHandle;
|
|
short nameLength;
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
|
|
BOOL result = FALSE;
|
|
|
|
expressionName = "";
|
|
expressionText = "";
|
|
|
|
if (PEGetNthSQLExpression(m_jobHandle,
|
|
expressionN,
|
|
&nameHandle,
|
|
&nameLength,
|
|
&textHandle,
|
|
&textLength))
|
|
|
|
if ((result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
expressionText)))
|
|
|
|
result = CRPEngine::GetEngine()->GetHandleString(nameHandle,
|
|
nameLength,
|
|
expressionName);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetSQLExpression(const _TCHAR *expressionName,
|
|
CString &expressionText)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
expressionText = "";
|
|
|
|
if (PEGetSQLExpression(m_jobHandle,
|
|
(_TCHAR *)expressionName,
|
|
&textHandle,
|
|
&textLength))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
expressionText);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetSQLExpression(const _TCHAR *expressionName,
|
|
const _TCHAR *expressionText)
|
|
{
|
|
return PESetSQLExpression(m_jobHandle,(_TCHAR *)expressionName,(_TCHAR *)expressionText);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::CheckSQLExpression(const _TCHAR *expressionName)
|
|
{
|
|
return PECheckSQLExpression(m_jobHandle,(_TCHAR *)expressionName);
|
|
}
|
|
|
|
// group condition attributes
|
|
|
|
|
|
short CRPEJob::GetNGroups ()
|
|
{
|
|
return PEGetNGroups(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetGroupCondition (short sectionCode,
|
|
CString &conditionField,
|
|
short *condition,
|
|
short *sortDirection)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
conditionField = "";
|
|
|
|
if (PEGetGroupCondition(m_jobHandle,
|
|
sectionCode,
|
|
&textHandle,
|
|
&textLength,
|
|
condition,
|
|
sortDirection))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
conditionField);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetGroupCondition(short sectionCode,
|
|
const _TCHAR *conditionField,
|
|
short condition,
|
|
short sortDirection)
|
|
{
|
|
return PESetGroupCondition(m_jobHandle,
|
|
sectionCode,
|
|
(_TCHAR *)conditionField,
|
|
condition,
|
|
sortDirection);
|
|
}
|
|
|
|
|
|
// record sort order field attributes
|
|
|
|
|
|
short CRPEJob::GetNSortFields(void)
|
|
{
|
|
return PEGetNSortFields(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthSortField(short sortFieldN,
|
|
CString &field,
|
|
short *direction)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
field = "";
|
|
|
|
if (PEGetNthSortField(m_jobHandle,
|
|
sortFieldN,
|
|
&textHandle,
|
|
&textLength,
|
|
direction))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
field);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetNthSortField(short sortFieldN,
|
|
const _TCHAR *field,
|
|
short direction)
|
|
{
|
|
return PESetNthSortField(m_jobHandle,sortFieldN,(_TCHAR *)field,direction);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::DeleteNthSortField(short sortFieldN)
|
|
{
|
|
return PEDeleteNthSortField(m_jobHandle,sortFieldN);
|
|
}
|
|
|
|
|
|
// group sort order field attributes
|
|
|
|
|
|
short CRPEJob::GetNGroupSortFields(void)
|
|
{
|
|
return PEGetNGroupSortFields(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthGroupSortField(short sortFieldN,
|
|
CString &field,
|
|
short *direction)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
field = "";
|
|
|
|
if (PEGetNthGroupSortField(m_jobHandle,
|
|
sortFieldN,
|
|
&textHandle,
|
|
&textLength,
|
|
direction))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
field);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetNthGroupSortField(short sortFieldN,
|
|
const _TCHAR *field,
|
|
short direction)
|
|
{
|
|
return PESetNthGroupSortField(m_jobHandle,
|
|
sortFieldN,
|
|
(_TCHAR *)field,
|
|
direction);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::DeleteNthGroupSortField(short sortFieldN)
|
|
{
|
|
return PEDeleteNthGroupSortField(m_jobHandle,sortFieldN);
|
|
}
|
|
|
|
|
|
// database table attributes
|
|
|
|
|
|
short CRPEJob::GetNTables(void)
|
|
{
|
|
return PEGetNTables(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthTableType(short tableN,
|
|
CRPETableType *tableType)
|
|
{
|
|
return PEGetNthTableType(m_jobHandle,
|
|
tableN,
|
|
(struct PETableType *) tableType);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthTableSessionInfo(short tableN,
|
|
CRPESessionInfo *sessionInfo)
|
|
{
|
|
return PEGetNthTableSessionInfo(m_jobHandle,
|
|
tableN,
|
|
(struct PESessionInfo *) sessionInfo);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetNthTableSessionInfo(short tableN,
|
|
const CRPESessionInfo *sessionInfo,
|
|
BOOL propagate)
|
|
{
|
|
// ensure CRPESessionInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPESessionInfo) == sizeof(PESessionInfo));
|
|
|
|
return PESetNthTableSessionInfo(m_jobHandle,
|
|
tableN,
|
|
(struct PESessionInfo *) sessionInfo,
|
|
propagate);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthTableLocation(short tableN,
|
|
CRPETableLocation *tableLocation)
|
|
{
|
|
return PEGetNthTableLocation(m_jobHandle,
|
|
tableN,
|
|
(struct PETableLocation *) tableLocation);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetNthTableLocation(short tableN,
|
|
const CRPETableLocation *tableLocation)
|
|
{
|
|
// ensure CRPETableLocation object is size CRPE expects
|
|
ASSERT (sizeof(CRPETableLocation) == sizeof(PETableLocation));
|
|
|
|
return PESetNthTableLocation(m_jobHandle,
|
|
tableN,
|
|
(struct PETableLocation *) tableLocation);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthTableLogonInfo(short tableN,
|
|
CRPELogOnInfo *logonInfo)
|
|
{
|
|
return PEGetNthTableLogOnInfo(m_jobHandle,
|
|
tableN,
|
|
(struct PELogOnInfo *) logonInfo);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetNthTableLogonInfo(short tableN,
|
|
const CRPELogOnInfo *logonInfo,
|
|
BOOL propagate)
|
|
{
|
|
// ensure CRPELogOnInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPELogOnInfo) == sizeof(PELogOnInfo));
|
|
|
|
return PESetNthTableLogOnInfo(m_jobHandle,
|
|
tableN,
|
|
(struct PELogOnInfo *) logonInfo,
|
|
propagate);
|
|
}
|
|
|
|
|
|
// SQL query attributes
|
|
|
|
|
|
BOOL CRPEJob::GetSQLQuery(CString &query)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
query = "";
|
|
|
|
if (PEGetSQLQuery(m_jobHandle,
|
|
&textHandle,
|
|
&textLength))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
query);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetSQLQuery(const _TCHAR *query)
|
|
{
|
|
return PESetSQLQuery(m_jobHandle,(_TCHAR *)query);
|
|
}
|
|
|
|
BOOL CRPEJob::VerifyDatabase()
|
|
{
|
|
return PEVerifyDatabase(m_jobHandle);
|
|
}
|
|
|
|
BOOL CRPEJob::CheckNthTableDifferences(short tableN,
|
|
CRPETableDifferenceInfo *tableDifferenceInfo)
|
|
{
|
|
return PECheckNthTableDifferences (m_jobHandle,
|
|
tableN,
|
|
(struct PETableDifferenceInfo *)tableDifferenceInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::GetNthTablePrivateInfo (short tableN,
|
|
CRPETablePrivateInfo *privateInfo)
|
|
{
|
|
return PEGetNthTablePrivateInfo (m_jobHandle,
|
|
tableN,
|
|
(struct PETablePrivateInfo *)privateInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::SetNthTablePrivateInfo (short tableN,
|
|
CRPETablePrivateInfo *privateInfo)
|
|
{
|
|
return PEGetNthTablePrivateInfo (m_jobHandle,
|
|
tableN,
|
|
(struct PETablePrivateInfo *)privateInfo);
|
|
}
|
|
|
|
|
|
// report section attributes
|
|
|
|
|
|
BOOL CRPEJob::GetNDetailCopies(short *nCopies)
|
|
{
|
|
return PEGetNDetailCopies(m_jobHandle,nCopies);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetNDetailCopies(short nCopies)
|
|
{
|
|
return PESetNDetailCopies(m_jobHandle, nCopies);
|
|
}
|
|
|
|
BOOL CRPEJob::GetGroupOptions(short groupN,
|
|
CRPEGroupOptions *groupOptions)
|
|
{
|
|
ASSERT (sizeof(CRPEGroupOptions) == sizeof(PEGroupOptions));
|
|
|
|
return PEGetGroupOptions(m_jobHandle,
|
|
groupN,
|
|
(struct PEGroupOptions *) groupOptions);
|
|
}
|
|
|
|
BOOL CRPEJob::SetGroupOptions(short groupN,
|
|
CRPEGroupOptions *groupOptions)
|
|
{
|
|
ASSERT (sizeof(CRPEGroupOptions) == sizeof(PEGroupOptions));
|
|
|
|
return PESetGroupOptions(m_jobHandle,
|
|
groupN,
|
|
(struct PEGroupOptions *) groupOptions);
|
|
}
|
|
|
|
short CRPEJob::GetNSections ()
|
|
{
|
|
return PEGetNSections(m_jobHandle);
|
|
}
|
|
|
|
|
|
short CRPEJob::GetSectionCode (short sectionN)
|
|
{
|
|
return PEGetSectionCode(m_jobHandle,sectionN);
|
|
}
|
|
|
|
BOOL CRPEJob::GetSectionHeight(short sectionCode,
|
|
short *height)
|
|
{
|
|
return PEGetSectionHeight(m_jobHandle,
|
|
sectionCode,
|
|
height);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetSectionHeight(short sectionCode,
|
|
short height)
|
|
{
|
|
return PESetSectionHeight(m_jobHandle,
|
|
sectionCode,
|
|
height);
|
|
}
|
|
|
|
BOOL CRPEJob::SetFont(short sectionCode,
|
|
short scopeCode,
|
|
const _TCHAR *faceName,
|
|
short fontFamily,
|
|
short fontPitch,
|
|
short charSet,
|
|
short pointSize,
|
|
short isItalic,
|
|
short isUnderlined,
|
|
short isStruckOut,
|
|
short weight)
|
|
{
|
|
return PESetFont(m_jobHandle,
|
|
sectionCode,
|
|
scopeCode,
|
|
(_TCHAR *)faceName,
|
|
fontFamily,
|
|
fontPitch,
|
|
charSet,
|
|
pointSize,
|
|
isItalic,
|
|
isUnderlined,
|
|
isStruckOut,
|
|
weight);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetSectionFormat (short sectionCode,
|
|
CRPESectionOptions *options)
|
|
{
|
|
// ensure CRPESectionOptions is size CRPE expects
|
|
ASSERT (sizeof(CRPESectionOptions) == sizeof(PESectionOptions));
|
|
|
|
return PEGetSectionFormat(m_jobHandle,
|
|
sectionCode,
|
|
(struct PESectionOptions *)options);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetSectionFormat (short sectionCode,
|
|
const CRPESectionOptions *options)
|
|
{
|
|
// ensure CRPESectionOptions is size CRPE expects
|
|
ASSERT (sizeof(CRPESectionOptions) == sizeof(PESectionOptions));
|
|
|
|
return PESetSectionFormat (m_jobHandle,
|
|
sectionCode,
|
|
(struct PESectionOptions *)options);
|
|
}
|
|
|
|
BOOL CRPEJob::SetAreaFormat (short areaCode,
|
|
CRPESectionOptions *options)
|
|
{
|
|
return PESetAreaFormat (m_jobHandle,
|
|
areaCode,
|
|
(struct PESectionOptions *)options);
|
|
|
|
}
|
|
|
|
BOOL CRPEJob::GetAreaFormat (short areaCode,
|
|
CRPESectionOptions *options)
|
|
{
|
|
return PEGetAreaFormat (m_jobHandle,
|
|
areaCode,
|
|
(struct PESectionOptions *)options);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetAreaFormatFormula(short areaCode,
|
|
short formulaName, // an area PEP_FFN_ constant
|
|
CString &formulaText)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
formulaText = "";
|
|
|
|
if (PEGetAreaFormatFormula(m_jobHandle,
|
|
areaCode,
|
|
formulaName,
|
|
&textHandle,
|
|
&textLength))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
formulaText);
|
|
|
|
return result;
|
|
}
|
|
|
|
BOOL CRPEJob::SetAreaFormatFormula(short areaCode,
|
|
short formulaName, // an area PEP_FFN_ constant
|
|
CString formulaText)
|
|
{
|
|
return PESetAreaFormatFormula(m_jobHandle,
|
|
areaCode,
|
|
formulaName,
|
|
formulaText);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetSectionFormatFormula(short areaCode,
|
|
short sectionCode,
|
|
short formulaName, // an area PEP_FFN_ constant
|
|
CString &formulaText)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
formulaText = "";
|
|
|
|
if (PEGetSectionFormatFormula(m_jobHandle,
|
|
sectionCode,
|
|
formulaName,
|
|
&textHandle,
|
|
&textLength))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
formulaText);
|
|
|
|
return result;
|
|
}
|
|
|
|
BOOL CRPEJob::SetSectionFormatFormula(short sectionCode,
|
|
short formulaName, // an area PEP_FFN_ constant
|
|
CString formulaText)
|
|
{
|
|
return PESetSectionFormatFormula(m_jobHandle,
|
|
sectionCode,
|
|
formulaName,
|
|
formulaText);
|
|
}
|
|
|
|
|
|
// //////////////////////////////////////////////////////////////////////
|
|
// Begin Graphing Attributes
|
|
|
|
BOOL CRPEJob::GetGraphTypeInfo (short sectionCode,
|
|
short graphN,
|
|
CRPEGraphTypeInfo *graphTypeInfo)
|
|
{
|
|
// ensure CRPEGraphTypeInfo is size CRPE expects
|
|
ASSERT (sizeof(CRPEGraphTypeInfo) == sizeof(PEGraphTypeInfo));
|
|
|
|
return PEGetGraphTypeInfo(m_jobHandle,
|
|
sectionCode,
|
|
graphN,
|
|
(struct PEGraphTypeInfo *)graphTypeInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::SetGraphTypeInfo (short sectionCode,
|
|
short graphN,
|
|
CRPEGraphTypeInfo *graphTypeInfo)
|
|
{
|
|
// ensure CRPEGraphTypeInfo is size CRPE expects
|
|
ASSERT (sizeof(CRPEGraphTypeInfo) == sizeof(PEGraphTypeInfo));
|
|
|
|
return PESetGraphTypeInfo(m_jobHandle,
|
|
sectionCode,
|
|
graphN,
|
|
(struct PEGraphTypeInfo *)graphTypeInfo);
|
|
}
|
|
|
|
// graph text
|
|
BOOL CRPEJob::GetGraphTextInfo (short sectionN,
|
|
short graphN,
|
|
WORD titleType, //PE_GTT_*
|
|
HANDLE FAR * title,
|
|
short FAR * titleLength)
|
|
{
|
|
return PEGetGraphTextInfo(m_jobHandle,
|
|
sectionN,
|
|
graphN,
|
|
titleType,
|
|
title,
|
|
titleLength);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetGraphTextInfo (short sectionN,
|
|
short graphN,
|
|
WORD titleType,
|
|
LPCSTR title)
|
|
{
|
|
return PESetGraphTextInfo(m_jobHandle,
|
|
sectionN,
|
|
graphN,
|
|
titleType,
|
|
title);
|
|
}
|
|
|
|
|
|
//graph font
|
|
BOOL CRPEJob::GetGraphFontInfo (short sectionN,
|
|
short graphN,
|
|
WORD titleFontType,
|
|
CRPEFontColorInfo *fontColourInfo)
|
|
{
|
|
// ensure CRPEGraphTypeInfo is size CRPE expects
|
|
ASSERT (sizeof(CRPEFontColorInfo) == sizeof(PEFontColorInfo));
|
|
|
|
return PEGetGraphFontInfo(m_jobHandle,
|
|
sectionN,
|
|
graphN,
|
|
titleFontType,
|
|
(struct PEFontColorInfo *)fontColourInfo);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetGraphFontInfo (short sectionN,
|
|
short graphN,
|
|
WORD titleFontType, //PE_GTF_
|
|
CRPEFontColorInfo *fontColourInfo)
|
|
{
|
|
// ensure CRPEGraphTypeInfo is size CRPE expects
|
|
ASSERT (sizeof(CRPEFontColorInfo) == sizeof(PEFontColorInfo));
|
|
|
|
return PESetGraphFontInfo(m_jobHandle,
|
|
sectionN,
|
|
graphN,
|
|
titleFontType,
|
|
(struct PEFontColorInfo *)fontColourInfo);
|
|
}
|
|
|
|
// graph axis
|
|
BOOL CRPEJob::GetGraphAxisInfo (short sectionN,
|
|
short graphN,
|
|
CRPEGraphAxisInfo *graphAxisInfo)
|
|
{
|
|
// ensure CRPEGraphTypeInfo is size CRPE expects
|
|
ASSERT (sizeof(CRPEGraphAxisInfo) == sizeof(PEGraphAxisInfo));
|
|
|
|
return PEGetGraphAxisInfo(m_jobHandle,
|
|
sectionN,
|
|
graphN,
|
|
(struct PEGraphAxisInfo *)graphAxisInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::SetGraphAxisInfo (short sectionN,
|
|
short graphN,
|
|
CRPEGraphAxisInfo *graphAxisInfo)
|
|
{
|
|
// ensure CRPEGraphTypeInfo is size CRPE expects
|
|
ASSERT (sizeof(CRPEGraphAxisInfo) == sizeof(PEGraphAxisInfo));
|
|
|
|
return PESetGraphAxisInfo(m_jobHandle,
|
|
sectionN,
|
|
graphN,
|
|
(struct PEGraphAxisInfo *)graphAxisInfo);
|
|
}
|
|
|
|
// graph options
|
|
BOOL CRPEJob:: GetGraphOptionInfo (short sectionN,
|
|
short graphN,
|
|
CRPEGraphOptionInfo *graphOptionInfo)
|
|
{
|
|
// ensure CRPEGraphTypeInfo is size CRPE expects
|
|
ASSERT (sizeof(CRPEGraphAxisInfo) == sizeof(PEGraphAxisInfo));
|
|
|
|
return PEGetGraphOptionInfo(m_jobHandle,
|
|
sectionN,
|
|
graphN,
|
|
(struct PEGraphOptionInfo *)graphOptionInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::SetGraphOptionInfo (short sectionN,
|
|
short graphN,
|
|
CRPEGraphOptionInfo *graphOptionInfo)
|
|
{
|
|
// ensure CRPEGraphTypeInfo is size CRPE expects
|
|
ASSERT (sizeof(CRPEGraphAxisInfo) == sizeof(PEGraphAxisInfo));
|
|
|
|
return PESetGraphOptionInfo(m_jobHandle,
|
|
sectionN,
|
|
graphN,
|
|
(struct PEGraphOptionInfo *)graphOptionInfo);
|
|
}
|
|
|
|
// END Graphing
|
|
// //////////////////////////////////////////////////////////////////////
|
|
|
|
// Conversion Routines for parameter info
|
|
BOOL CRPEJob::ConvertPFInfoToVInfo(void FAR * value,
|
|
short valueType,
|
|
CRPEValueInfo *valueInfo)
|
|
{
|
|
return PEConvertPFInfoToVInfo(value, valueType, (struct PEValueInfo *)valueInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::ConvertVInfoToPFInfo(CRPEValueInfo *valueInfo,
|
|
WORD *valueType,
|
|
void *value)
|
|
{
|
|
return PEConvertVInfoToPFInfo((struct PEValueInfo *)valueInfo, valueType, value);
|
|
}
|
|
|
|
// report attributes
|
|
|
|
|
|
BOOL CRPEJob::GetReportTitle (CString &title)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
BOOL result = FALSE;
|
|
|
|
title = "";
|
|
|
|
if (PEGetReportTitle(m_jobHandle,
|
|
&textHandle,
|
|
&textLength))
|
|
result = CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
title);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetReportTitle(const _TCHAR *title)
|
|
{
|
|
return PESetReportTitle(m_jobHandle,(_TCHAR *)title);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetPrintDate (short *year,
|
|
short *month,
|
|
short *day)
|
|
{
|
|
return PEGetPrintDate(m_jobHandle,year,month,day);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetPrintDate(short year,
|
|
short month,
|
|
short day)
|
|
{
|
|
return PESetPrintDate(m_jobHandle,year,month,day);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::HasSavedData (BOOL *hasSavedData)
|
|
{
|
|
return PEHasSavedData(m_jobHandle,hasSavedData);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetWindowOptions (CRPEWindowOptions *options)
|
|
{
|
|
return PEGetWindowOptions (m_jobHandle,(struct PEWindowOptions *)options);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetWindowOptions(const CRPEWindowOptions *options)
|
|
{
|
|
// ensure CRPEWindowOptions is size CRPE expects
|
|
ASSERT (sizeof(CRPEWindowOptions) == sizeof(PEWindowOptions));
|
|
|
|
return PESetWindowOptions(m_jobHandle,
|
|
(struct PEWindowOptions *) options);
|
|
}
|
|
|
|
BOOL CRPEJob::GetFieldMappingType (WORD mappingType) //use PE_FM_ constant
|
|
{
|
|
return PEGetFieldMappingType(m_jobHandle, &mappingType);
|
|
}
|
|
|
|
BOOL CRPEJob::SetFieldMappingType (WORD mappingType) //use PE_FM_ constant
|
|
{
|
|
return PESetFieldMappingType(m_jobHandle, mappingType);
|
|
}
|
|
|
|
BOOL CRPEJob::SetTrackCursorInfo(CRPETrackCursorInfo *cursorInfo)
|
|
{
|
|
return PESetTrackCursorInfo(m_jobHandle,
|
|
(struct PETrackCursorInfo *) cursorInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::GetTrackCursorInfo(CRPETrackCursorInfo *cursorInfo)
|
|
{
|
|
return PEGetTrackCursorInfo(m_jobHandle,
|
|
(struct PETrackCursorInfo *) cursorInfo);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::EnableEvent (const CRPEEnableEventInfo *enableEventInfo)
|
|
{
|
|
return PEEnableEvent (m_jobHandle,(struct PEEnableEventInfo *)enableEventInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::GetEnableEventInfo (CRPEEnableEventInfo *enableEventInfo)
|
|
{
|
|
return PEGetEnableEventInfo (m_jobHandle,(struct PEEnableEventInfo *)enableEventInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::SetEventCallback ( BOOL ( CALLBACK * callbackProc )(short eventID, void *param, void *userData), void *userData)
|
|
{
|
|
|
|
return PESetEventCallback ( m_jobHandle, callbackProc, (void *) userData);
|
|
}
|
|
|
|
short CRPEJob::GetNPages ()
|
|
{
|
|
return PEGetNPages(m_jobHandle);
|
|
}
|
|
|
|
|
|
// report printer attributes
|
|
|
|
|
|
BOOL CRPEJob::GetSelectedPrinter (CString &driverName,
|
|
CString &printerName,
|
|
CString &portName,
|
|
DEVMODE **mode)
|
|
{
|
|
HANDLE driverHandle, printerHandle, portHandle;
|
|
short driverLength, printerLength, portLength;
|
|
BOOL result = FALSE;
|
|
|
|
driverName = "";
|
|
printerName = "";
|
|
portName = "";
|
|
|
|
if (PEGetSelectedPrinter(m_jobHandle,
|
|
&driverHandle,
|
|
&driverLength,
|
|
&printerHandle,
|
|
&printerLength,
|
|
&portHandle,
|
|
&portLength,
|
|
mode))
|
|
if (CRPEngine::GetEngine()->GetHandleString(driverHandle,
|
|
driverLength,
|
|
driverName))
|
|
if (CRPEngine::GetEngine()->GetHandleString(printerHandle,
|
|
printerLength,
|
|
printerName))
|
|
result = CRPEngine::GetEngine()->GetHandleString(portHandle,
|
|
portLength,
|
|
portName);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SelectPrinter(const _TCHAR *driverName,
|
|
const _TCHAR *printerName,
|
|
const _TCHAR *portName,
|
|
const DEVMODE *mode)
|
|
{
|
|
return PESelectPrinter(m_jobHandle,
|
|
(_TCHAR *)driverName,
|
|
(_TCHAR *)printerName,
|
|
(_TCHAR *)portName,
|
|
(DEVMODE *)mode);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetPrintOptions (CRPEPrintOptions *options)
|
|
{
|
|
return PEGetPrintOptions (m_jobHandle,(struct PEPrintOptions *)options);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetPrintOptions(const CRPEPrintOptions *options)
|
|
{
|
|
// ensure CRPEPrintOptions is size CRPE expects
|
|
ASSERT (sizeof(CRPEPrintOptions) == sizeof(PEPrintOptions));
|
|
|
|
return PESetPrintOptions(m_jobHandle,
|
|
(struct PEPrintOptions *) options);
|
|
}
|
|
|
|
|
|
// output destination options
|
|
|
|
|
|
BOOL CRPEJob::OutputToPrinter(short nCopies)
|
|
{
|
|
m_mdiOutput = FALSE;
|
|
|
|
return PEOutputToPrinter(m_jobHandle,nCopies);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::OutputToWindow(const _TCHAR *title,
|
|
int left,
|
|
int top,
|
|
int width,
|
|
int height,
|
|
int style,
|
|
CWnd *parentWindow)
|
|
{
|
|
m_mdiOutput = FALSE;
|
|
|
|
return PEOutputToWindow(m_jobHandle,
|
|
(_TCHAR *)title,
|
|
left,
|
|
top,
|
|
width,
|
|
height,
|
|
style,
|
|
parentWindow != 0 ? parentWindow->m_hWnd : 0);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::OutputToWindow(const char *title,
|
|
int left,
|
|
int top,
|
|
int width,
|
|
int height,
|
|
int style,
|
|
CMDIFrameWnd *parentWindow)
|
|
{
|
|
ASSERT (parentWindow != 0);
|
|
|
|
m_mdiOutput = TRUE;
|
|
m_mdiTitle = title;
|
|
m_mdiLeft = left;
|
|
m_mdiTop = top;
|
|
m_mdiWidth = width;
|
|
m_mdiHeight = height;
|
|
m_mdiStyle = style;
|
|
m_mdiFrameWnd = parentWindow;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
HWND CRPEJob::GetWindowHandle(void)
|
|
{
|
|
return PEGetWindowHandle(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::PrintControlsShowing(BOOL *controlsShowing)
|
|
{
|
|
return PEPrintControlsShowing(m_jobHandle,controlsShowing);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetExportOptions(CRPEExportOptions *options)
|
|
{
|
|
return PEGetExportOptions(m_jobHandle,
|
|
(struct PEExportOptions *) options);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::ExportTo(const CRPEExportOptions *options)
|
|
{
|
|
// ensure CRPEExportOptions is size CRPE expects
|
|
ASSERT (sizeof(CRPEExportOptions) == sizeof(PEExportOptions));
|
|
|
|
m_mdiOutput = FALSE;
|
|
|
|
return PEExportTo(m_jobHandle,
|
|
(struct PEExportOptions *) options);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetMargins(short *left,
|
|
short *right,
|
|
short *top,
|
|
short *bottom)
|
|
{
|
|
return PEGetMargins(m_jobHandle,
|
|
left,
|
|
right,
|
|
top,
|
|
bottom);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetMargins(short left,
|
|
short right,
|
|
short top,
|
|
short bottom)
|
|
{
|
|
return PESetMargins(m_jobHandle,
|
|
left,
|
|
right,
|
|
top,
|
|
bottom);
|
|
}
|
|
|
|
|
|
// job status attributes
|
|
short CRPEJob::GetJobStatus(CRPEJobInfo *jobStatus)
|
|
{
|
|
return PEGetJobStatus(m_jobHandle,(struct PEJobInfo *)jobStatus);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::IsJobFinished(void)
|
|
{
|
|
return PEIsPrintJobFinished(m_jobHandle);
|
|
}
|
|
|
|
|
|
short CRPEJob::GetErrorCode(void)
|
|
{
|
|
return PEGetErrorCode(m_jobHandle);
|
|
}
|
|
|
|
|
|
CString CRPEJob::GetErrorText(void)
|
|
{
|
|
HANDLE textHandle;
|
|
short textLength;
|
|
CString errorText = "";
|
|
|
|
if (PEGetErrorText(m_jobHandle,&textHandle,&textLength))
|
|
CRPEngine::GetEngine()->GetHandleString(textHandle,
|
|
textLength,
|
|
errorText);
|
|
|
|
return errorText;
|
|
}
|
|
|
|
|
|
// dialog control attributes
|
|
BOOL CRPEJob::SetDialogParentWindow(CWnd *parentWindow)
|
|
{
|
|
return PESetDialogParentWindow(m_jobHandle,
|
|
parentWindow != 0 ? parentWindow->m_hWnd : 0);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::EnableProgressDialog(BOOL enable)
|
|
{
|
|
return PEEnableProgressDialog(m_jobHandle, enable);
|
|
}
|
|
|
|
|
|
// Controlling Paremeter Field Prompting Dialog
|
|
// Set boolean to indicate whether CRPE is allowed to prompt for parameter values
|
|
// during printing.
|
|
|
|
BOOL CRPEJob::GetAllowPromptDialog(void)
|
|
{
|
|
return PEGetAllowPromptDialog(m_jobHandle);
|
|
}
|
|
|
|
BOOL CRPEJob::SetAllowPromptDialog(BOOL showPromptDialog)
|
|
{
|
|
return PESetAllowPromptDialog(m_jobHandle, showPromptDialog);
|
|
}
|
|
|
|
/********************************************************************************/
|
|
// NOTE : Stored Procedures
|
|
//
|
|
// The previous Stored Procedure Functions GetNParams, GetNthParam,
|
|
// GetNthParamInfo and SetNthParam have been made obsolete. Older
|
|
// applications that used these Functions will still work as before, but for new
|
|
// development please use the new Parameter Functions below,
|
|
//
|
|
// The Stored Procedure Parameters have now been unified with the Parameter
|
|
// Fields.
|
|
//
|
|
// The replacements for these calls are as follows :
|
|
// GetNParams = GetNParameterFields
|
|
// GetNthParam = GetNthParameterField
|
|
// GetNthParamInfo = GetNthParameterValueInfo
|
|
// SetNthParam = SetNthParameterField
|
|
//
|
|
// NOTE : To tell if a Parameter Field is a Stored Procedure, use the
|
|
// GetNthParameterType or GetNthParameterField Functions
|
|
//
|
|
// If you wish to SET a parameter to NULL then set the CurrentValue to CRWNULL.
|
|
// The CRWNULL is of Type String and is independant of the datatype of the
|
|
// parameter.
|
|
//
|
|
/********************************************************************************/
|
|
|
|
// parameter field attributes
|
|
short CRPEJob::GetNParameterFields(void)
|
|
{
|
|
return PEGetNParameterFields(m_jobHandle);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthParameterField(short parameterN,
|
|
CRPEParameterFieldInfo *parameterInfo)
|
|
{
|
|
// ensure CRPEParameterFieldInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEParameterFieldInfo) == sizeof(PEParameterFieldInfo));
|
|
|
|
return PEGetNthParameterField(m_jobHandle,
|
|
parameterN,
|
|
(struct PEParameterFieldInfo *) parameterInfo);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetNthParameterField(short parameterN,
|
|
const CRPEParameterFieldInfo *parameterInfo)
|
|
{
|
|
// ensure CRPEParameterFieldInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEParameterFieldInfo) == sizeof(PEParameterFieldInfo));
|
|
|
|
return PESetNthParameterField(m_jobHandle,
|
|
parameterN,
|
|
(struct PEParameterFieldInfo *) parameterInfo);
|
|
}
|
|
|
|
// Default values for Parameter fields.
|
|
// ////////////////////////////////////
|
|
short CRPEJob::GetNParameterDefaultValues (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName)
|
|
{
|
|
return PEGetNParameterDefaultValues (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName);
|
|
}
|
|
|
|
BOOL CRPEJob::GetNthParameterDefaultValue (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
short index,
|
|
CRPEValueInfo *valueInfo)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PEGetNthParameterDefaultValue(m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
index,
|
|
(struct PEValueInfo *) valueInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::SetNthParameterDefaultValue (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
short index,
|
|
CRPEValueInfo *valueInfo)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PESetNthParameterDefaultValue(m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
index,
|
|
(struct PEValueInfo *) valueInfo);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::AddParameterDefaultValue(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEValueInfo *valueInfo)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PEAddParameterDefaultValue (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEValueInfo *) valueInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::DeleteNthParameterDefaultValue(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
short index)
|
|
{
|
|
return PEDeleteNthParameterDefaultValue(m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
index);
|
|
}
|
|
|
|
// Min/Max values for Parameter fields.
|
|
// ////////////////////////////////////
|
|
BOOL CRPEJob::GetParameterMinMaxValue(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEValueInfo *valueMin, // Set to NULL to retrieve MAX only; must be non-NULL if valueMax is NULL.
|
|
CRPEValueInfo *valueMax // Set to NULL to retrieve MIN only; must be non-NULL if valueMin is NULL.
|
|
)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PEGetParameterMinMaxValue (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEValueInfo *) valueMin,
|
|
(struct PEValueInfo *) valueMax);
|
|
}
|
|
|
|
BOOL CRPEJob::SetParameterMinMaxValue(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEValueInfo *valueMin, // Set to NULL to set MAX only; must be non-NULL if valueMax is NULL.
|
|
CRPEValueInfo *valueMax // Set to NULL to set MIN only; must be non-NULL if valueMin is NULL.
|
|
// If both valueInfo and valueMax are non-NULL then
|
|
// valueMin->valueType MUST BE THE SAME AS valueMax->valueType.
|
|
// If different, PE_ERR_INCONSISTANTTYPES is returned.
|
|
)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PESetParameterMinMaxValue (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEValueInfo *) valueMin,
|
|
(struct PEValueInfo *) valueMax);
|
|
}
|
|
|
|
BOOL CRPEJob::GetParameterValueInfo(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEParameterValueInfo *valueInfo)
|
|
{
|
|
// ensure CRPEParameterValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEParameterValueInfo) == sizeof(PEParameterValueInfo));
|
|
|
|
return PEGetParameterValueInfo(m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEParameterValueInfo *) valueInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::SetParameterValueInfo(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEParameterValueInfo *valueInfo)
|
|
{
|
|
// ensure CRPEParameterValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEParameterValueInfo) == sizeof(PEParameterValueInfo));
|
|
|
|
return PESetParameterValueInfo(m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEParameterValueInfo *) valueInfo);
|
|
}
|
|
|
|
unsigned short CRPEJob::GetNParameterCurrentValues(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName)
|
|
{
|
|
|
|
return PEGetNParameterCurrentValues(m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName);
|
|
}
|
|
|
|
BOOL CRPEJob::GetNthParameterCurrentValue(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
short index,
|
|
CRPEValueInfo *currentValue)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PEGetNthParameterCurrentValue(m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
index,
|
|
(struct PEValueInfo *) currentValue);
|
|
}
|
|
|
|
BOOL CRPEJob::AddParameterCurrentValue(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEValueInfo *currentValue)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PEAddParameterCurrentValue (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEValueInfo *) currentValue);
|
|
}
|
|
|
|
unsigned short CRPEJob::GetNParameterCurrentRanges(const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName)
|
|
{
|
|
|
|
return PEGetNParameterCurrentRanges(m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetNthParameterCurrentRange (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
short index,
|
|
CRPEValueInfo *rangeStart, // Set to NULL to set MAX only; must be non-NULL if valueMax is NULL.
|
|
CRPEValueInfo *rangeEnd, // Set to NULL to set MIN only; must be non-NULL if valueMin is NULL.
|
|
// If both valueInfo and valueMax are non-NULL then
|
|
// valueMin->valueType MUST BE THE SAME AS valueMax->valueType.
|
|
// If different, PE_ERR_INCONSISTANTTYPES is returned.
|
|
short *rangeInfo)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PEGetNthParameterCurrentRange (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
index,
|
|
(struct PEValueInfo *) rangeStart,
|
|
(struct PEValueInfo *) rangeEnd,
|
|
(short *) rangeInfo);
|
|
}
|
|
|
|
BOOL CRPEJob::AddParameterCurrentRange (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEValueInfo *rangeStart, // Set to NULL to set MAX only; must be non-NULL if valueMax is NULL.
|
|
CRPEValueInfo *rangeEnd, // Set to NULL to set MIN only; must be non-NULL if valueMin is NULL.
|
|
// If both valueInfo and valueMax are non-NULL then
|
|
// valueMin->valueType MUST BE THE SAME AS valueMax->valueType.
|
|
// If different, PE_ERR_INCONSISTANTTYPES is returned.
|
|
short rangeInfo)
|
|
{
|
|
// ensure CRPEValueInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPEValueInfo) == sizeof(PEValueInfo));
|
|
|
|
return PEAddParameterCurrentRange (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEValueInfo *) rangeStart,
|
|
(struct PEValueInfo *) rangeEnd,
|
|
rangeInfo);
|
|
}
|
|
|
|
|
|
short CRPEJob::GetNthParameterType (short index) // returns PEP_PO_* or -1 if index is invalid.
|
|
{
|
|
return PEGetNthParameterType (m_jobHandle, index);
|
|
}
|
|
|
|
BOOL CRPEJob::ClearParameterCurrentValuesAndRanges (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName)
|
|
{
|
|
return PEClearParameterCurrentValuesAndRanges (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName);
|
|
}
|
|
|
|
BOOL CRPEJob::GetNthParameterValueDescription (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
short index,
|
|
HANDLE * valueDesc,
|
|
short *valueDescLength)
|
|
{
|
|
return PEGetNthParameterValueDescription (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
index,
|
|
valueDesc,
|
|
valueDescLength);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::SetNthParameterValueDescription (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
short index,
|
|
char FAR * valueDesc)
|
|
{
|
|
return PESetNthParameterValueDescription (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
index,
|
|
valueDesc);
|
|
}
|
|
|
|
// Pick list options in Parameter fields.
|
|
BOOL CRPEJob::GetParameterPickListOption (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEParameterPickListOption *pickListOption)
|
|
{
|
|
return PEGetParameterPickListOption (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEParameterPickListOption *)pickListOption);
|
|
}
|
|
|
|
BOOL CRPEJob::SetParameterPickListOption (const _TCHAR *parameterFieldName,
|
|
const _TCHAR *reportName,
|
|
CRPEParameterPickListOption *pickListOption)
|
|
{
|
|
return PESetParameterPickListOption (m_jobHandle,
|
|
(_TCHAR *)parameterFieldName,
|
|
(_TCHAR *)reportName,
|
|
(struct PEParameterPickListOption *)pickListOption);
|
|
}
|
|
|
|
// END Parameter Fields
|
|
// /////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// subreport attributes
|
|
short CRPEJob::GetNSubreportsInSection(short sectionCode)
|
|
{
|
|
return PEGetNSubreportsInSection(m_jobHandle,
|
|
sectionCode);
|
|
}
|
|
|
|
|
|
DWORD CRPEJob::GetNthSubreportInSection(short sectionCode,
|
|
short subreportN)
|
|
{
|
|
return PEGetNthSubreportInSection(m_jobHandle,
|
|
sectionCode,
|
|
subreportN);
|
|
}
|
|
|
|
|
|
BOOL CRPEJob::GetSubreportInfo(DWORD subreportHandle,
|
|
CRPESubreportInfo *subreportInfo)
|
|
{
|
|
// ensure CRPESubreportInfo object is size CRPE expects
|
|
ASSERT (sizeof(CRPESubreportInfo) == sizeof(PESubreportInfo));
|
|
|
|
return PEGetSubreportInfo(m_jobHandle,
|
|
subreportHandle,
|
|
(struct PESubreportInfo *) subreportInfo);
|
|
}
|
|
|
|
|
|
CRPEJob *CRPEJob::OpenSubreportJob (const _TCHAR *subreportName)
|
|
{
|
|
// engine must be open
|
|
ASSERT (CRPEngine::GetEngineStatus() == CRPEngine::engineOpen);
|
|
|
|
short jobHandle = 0;
|
|
CRPEJob *newJob = NULL;
|
|
|
|
if ((jobHandle = PEOpenSubreport(m_jobHandle,(_TCHAR *)subreportName)) == 0)
|
|
return NULL;
|
|
|
|
if ((newJob = new CRPEJob(jobHandle,this)) == NULL) {
|
|
PECloseSubreport(jobHandle);
|
|
return NULL;
|
|
}
|
|
|
|
return newJob;
|
|
}
|
|
|
|
BOOL CRPEJob::CloseSubreport ( void )
|
|
{
|
|
return PECloseSubreport ( m_jobHandle );
|
|
}
|
|
|
|
|
|
// misc. attributes
|
|
short CRPEJob::GetJobHandle(void)
|
|
{
|
|
return m_jobHandle;
|
|
}
|
|
|
|
|
|
// implementation
|
|
|
|
|
|
void CRPEJob::AddSubReportJob(CRPEJob *job)
|
|
{
|
|
m_subReportJobs.Add(job);
|
|
}
|
|
|
|
|
|
void CRPEJob::RemoveSubReportJob(CRPEJob *job)
|
|
{
|
|
int numJobs = m_subReportJobs.GetSize();
|
|
|
|
while (numJobs--)
|
|
if (m_subReportJobs[numJobs] == job) {
|
|
m_subReportJobs.RemoveAt(numJobs);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef _DEBUG
|
|
void CRPEJob::AssertValid() const
|
|
{
|
|
CObject::AssertValid();
|
|
}
|
|
|
|
|
|
void CRPEJob::Dump(CDumpContext& dc) const
|
|
{
|
|
CObject::Dump(dc);
|
|
}
|
|
|
|
#endif //_DEBUG
|
|
|
|
|
|
////////////////////////
|
|
// CRPEMDIChildWnd Class
|
|
////////////////////////
|
|
|
|
IMPLEMENT_DYNCREATE(CRPEMDIChildWnd, CMDIChildWnd)
|
|
|
|
CRPEMDIChildWnd::CRPEMDIChildWnd() : m_printWnd(0)
|
|
{
|
|
}
|
|
|
|
CRPEMDIChildWnd::~CRPEMDIChildWnd()
|
|
{
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CRPEMDIChildWnd, CMDIChildWnd)
|
|
//{{AFX_MSG_MAP(CRPEMDIChildWnd)
|
|
ON_WM_SIZE()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CRPEMDIChildWnd message handlers
|
|
|
|
void CRPEMDIChildWnd::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
CMDIChildWnd::OnSize(nType, cx, cy);
|
|
|
|
CRect r;
|
|
|
|
GetClientRect (r);
|
|
|
|
::MoveWindow (m_printWnd,
|
|
r.left, r.top,
|
|
r.Width (), r.Height (),
|
|
TRUE);
|
|
}
|