commit 5dd543ab3889f350e4eb36ae9af59ccb61514a55 Author: wklyj <157651241@qq.com> Date: Mon Apr 15 15:50:01 2024 +0800 红色软件上传 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4aa938f --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +################################################################################ +# 此 .gitignore 文件已由 Microsoft(R) Visual Studio 自动创建。 +################################################################################ + +/LaiPuLaser/LaiPuLaser.VC.VC.opendb +/LaipuDrawing/LaipuDrawing.VC.VC.opendb +*.suo +/LaipuDrawing/LaipuDrawing.VC.db +/LaiPuLaser/ipch/LAIPULASER-bc8889c5/LAIPU-c4d6e947.ipch +/LaiPuLaser/LaiPuLaser.VC.db +/LaipuDrawing/Debug +/LaipuDrawing/hlp/LaiPuLaser.chm diff --git a/LaipuDrawing/3DBar.cpp b/LaipuDrawing/3DBar.cpp new file mode 100644 index 0000000..bbf627f --- /dev/null +++ b/LaipuDrawing/3DBar.cpp @@ -0,0 +1,211 @@ +// 3DBar.cpp: implementation of the C3DBar class. +// +////////////////////////////////////////////////////////////////////// + +#include "stdafx.h" +#include "3DBar.h" + +#ifdef _DEBUG +#undef THIS_FILE +static char THIS_FILE[]=__FILE__; +#define new DEBUG_NEW +#endif + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +C3DBar::C3DBar() +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + m_crChannel = RGB(255, 100, 0); + UpdateColours(); + CreatePens(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +C3DBar::~C3DBar() +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void C3DBar::UpdateColours() +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + // Calculates the lighter and darker colors, as well as the shadow colors. + m_crColorLight = LightenColor(m_crChannel, 51); + m_crColorLighter = LightenColor(m_crColorLight, 51); + m_crColorLightest = LightenColor(m_crColorLighter, 51); + m_crColorDark = DarkenColor(m_crChannel, 51); + m_crColorDarker = DarkenColor(m_crColorDark, 51); + m_crDkShadow = ::GetSysColor(COLOR_3DDKSHADOW); + m_crLiteShadow = ::GetSysColor(COLOR_3DSHADOW); + + // Get a color halfway between COLOR_3DDKSHADOW and COLOR_3DSHADOW + BYTE byRed3DDkShadow = GetRValue(m_crDkShadow); + BYTE byRed3DLiteShadow = GetRValue(m_crLiteShadow); + BYTE byGreen3DDkShadow = GetGValue(m_crDkShadow); + BYTE byGreen3DLiteShadow = GetGValue(m_crLiteShadow); + BYTE byBlue3DDkShadow = GetBValue(m_crDkShadow); + BYTE byBlue3DLiteShadow = GetBValue(m_crLiteShadow); + + m_crShadow = RGB(byRed3DLiteShadow + ((byRed3DDkShadow - byRed3DLiteShadow) >> 1), + byGreen3DLiteShadow + ((byGreen3DDkShadow - byGreen3DLiteShadow) >> 1), + byBlue3DLiteShadow + ((byBlue3DDkShadow - byBlue3DLiteShadow) >> 1)); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void C3DBar::DrawHorizontal(CDC *pDC, CRect &BarRect) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + if (!BarRect.Width()) return; + + CBrush brLightest(m_crColorLightest); + pDC->FillRect(BarRect, &brLightest); + + int nLeft = BarRect.left; + int nTop = BarRect.top; + int nBottom = BarRect.bottom; + int nRight = BarRect.right; + + CPen *pOldPen = pDC->SelectObject(&m_penColorLight); + { + pDC->MoveTo(nLeft + 2, nBottom - 4); + pDC->LineTo(nRight - 2, nBottom - 4); + pDC->MoveTo(nLeft + 2, nTop + 2); + pDC->LineTo(nRight - 2, nTop + 2); + pDC->SetPixel(nLeft + 1, nBottom - 3, m_crColorLight); + pDC->SetPixel(nLeft + 1, nTop + 1, m_crColorLight); + } + + pDC->SelectObject(&m_penColorLighter); + { + pDC->MoveTo(nLeft + 2, nBottom - 5); + pDC->LineTo(nRight - 3, nBottom - 5); + pDC->LineTo(nRight - 3, nTop + 3); + pDC->LineTo(nLeft + 1, nTop + 3); + pDC->SetPixel(nLeft + 1, nBottom - 4, m_crColorLighter); + pDC->SetPixel(nLeft + 1, nTop + 2, m_crColorLighter); + } + + pDC->SelectObject(&m_penColor); + { + pDC->MoveTo(nLeft, nBottom - 1); + pDC->LineTo(nLeft, nTop); + pDC->LineTo(nLeft + 2, nTop); + pDC->SetPixel(nLeft + 1, nBottom - 2, m_crChannel); + pDC->MoveTo(nLeft + 2, nBottom - 3); + pDC->LineTo(nRight - 2, nBottom - 3); + pDC->MoveTo(nLeft + 2, nTop + 1); + pDC->LineTo(nRight - 1, nTop + 1); + } + + pDC->SelectObject(&m_penColorDark); + { + pDC->MoveTo(nLeft + 2, nBottom - 2); + pDC->LineTo(nRight - 2, nBottom - 2); + pDC->LineTo(nRight - 2, nTop + 1); + pDC->MoveTo(nLeft + 2, nTop); + pDC->LineTo(nRight, nTop); + pDC->SetPixel(nLeft + 1, nBottom - 1, m_crColorDark); + } + + pDC->SelectObject(&m_penColorDarker); + { + pDC->MoveTo(nLeft + 2, nBottom - 1); + pDC->LineTo(nRight - 1, nBottom - 1); + pDC->LineTo(nRight - 1, nTop); + } + + pDC->SelectObject(&m_penShadow); + { + pDC->MoveTo(nRight, nTop); + pDC->LineTo(nRight, nBottom); + } + + pDC->SelectObject(&m_penLiteShadow); + { + pDC->MoveTo(nRight + 1, nTop); + pDC->LineTo(nRight + 1, nBottom); + } + + + pDC->SelectObject(pOldPen); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void C3DBar::DeletePens() +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + if (m_penColorLight.m_hObject) m_penColorLight.DeleteObject(); + if (m_penColorLighter.m_hObject) m_penColorLighter.DeleteObject(); + if (m_penColor.m_hObject) m_penColor.DeleteObject(); + if (m_penColorDark.m_hObject) m_penColorDark.DeleteObject(); + if (m_penColorDarker.m_hObject) m_penColorDarker.DeleteObject(); + if (m_penDkShadow.m_hObject) m_penDkShadow.DeleteObject(); + if (m_penShadow.m_hObject) m_penShadow.DeleteObject(); + if (m_penLiteShadow.m_hObject) m_penLiteShadow.DeleteObject(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void C3DBar::CreatePens() +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + DeletePens(); + m_penColorLight.CreatePen(PS_SOLID, 1, m_crColorLight); + m_penColorLighter.CreatePen(PS_SOLID, 1, m_crColorLighter); + m_penColor.CreatePen(PS_SOLID, 1, m_crChannel); + m_penColorDark.CreatePen(PS_SOLID, 1, m_crColorDark); + m_penColorDarker.CreatePen(PS_SOLID, 1, m_crColorDarker); + m_penDkShadow.CreatePen(PS_SOLID, 1, m_crDkShadow); + m_penShadow.CreatePen(PS_SOLID, 1, m_crShadow); + m_penLiteShadow.CreatePen(PS_SOLID, 1, m_crLiteShadow); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +COLORREF C3DBar::LightenColor(const COLORREF crColor, BYTE byIncreaseVal) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + BYTE byRed = GetRValue(crColor); + BYTE byGreen = GetGValue(crColor); + BYTE byBlue = GetBValue(crColor); + + if ((byRed + byIncreaseVal) <= 255) + byRed = BYTE(byRed + byIncreaseVal); + if ((byGreen + byIncreaseVal) <= 255) + byGreen = BYTE(byGreen + byIncreaseVal); + if ((byBlue + byIncreaseVal) <= 255) + byBlue = BYTE(byBlue + byIncreaseVal); + + return RGB(byRed, byGreen, byBlue); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +COLORREF C3DBar::DarkenColor(const COLORREF crColor, BYTE byReduceVal) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + BYTE byRed = GetRValue(crColor); + BYTE byGreen = GetGValue(crColor); + BYTE byBlue = GetBValue(crColor); + + if (byRed >= byReduceVal) + byRed = BYTE(byRed - byReduceVal); + if (byGreen >= byReduceVal) + byGreen = BYTE(byGreen - byReduceVal); + if (byBlue >= byReduceVal) + byBlue = BYTE(byBlue - byReduceVal); + + return RGB(byRed, byGreen, byBlue); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void C3DBar::SetBarColour(COLORREF cr) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + m_crChannel = cr; + UpdateColours(); + CreatePens(); +} diff --git a/LaipuDrawing/3DBar.h b/LaipuDrawing/3DBar.h new file mode 100644 index 0000000..e366049 --- /dev/null +++ b/LaipuDrawing/3DBar.h @@ -0,0 +1,49 @@ +// 3DBar.h: interface for the C3DBar class. +// +////////////////////////////////////////////////////////////////////// + +#if !defined(AFX_3DBAR_H__E77033B8_CCDE_11D3_8041_00805FC1DE10__INCLUDED_) +#define AFX_3DBAR_H__E77033B8_CCDE_11D3_8041_00805FC1DE10__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "stdafx.h" + +class C3DBar +{ +public: + void SetBarColour(COLORREF cr); + void UpdateColours(); + void CreatePens(); + void DrawHorizontal(CDC* pDC, CRect& BarRect); + + C3DBar(); + virtual ~C3DBar(); + +protected: + void DeletePens(); + COLORREF DarkenColor(const COLORREF crColor, BYTE byReduceVal); + COLORREF LightenColor(const COLORREF crColor, BYTE byIncreaseVal); + COLORREF m_crChannel; + COLORREF m_crColorLight; + COLORREF m_crColorLighter; + COLORREF m_crColorLightest; + COLORREF m_crColorDark; + COLORREF m_crColorDarker; + COLORREF m_crDkShadow; + COLORREF m_crShadow; + COLORREF m_crLiteShadow; + + CPen m_penColor; + CPen m_penColorLight; + CPen m_penColorLighter; + CPen m_penColorDark; + CPen m_penColorDarker; + CPen m_penDkShadow; + CPen m_penShadow; + CPen m_penLiteShadow; +}; + +#endif // !defined(AFX_3DBAR_H__E77033B8_CCDE_11D3_8041_00805FC1DE10__INCLUDED_) diff --git a/LaipuDrawing/AllThreadMgr.cpp b/LaipuDrawing/AllThreadMgr.cpp new file mode 100644 index 0000000..3605750 --- /dev/null +++ b/LaipuDrawing/AllThreadMgr.cpp @@ -0,0 +1,325 @@ +#include "StdAfx.h" +#include "AllThreadMgr.h" +#include "CStringFuc.h" +#include "FileMgr.h" +#include "WorkTime.h" +#include "LogMgr.h" + +CAllThreadMgr gAllThreadMgr; +bool gbStopAllThread= false;//ֹͣ߳ +CAllThreadMgr::CAllThreadMgr(void) +{ + InitThreadInfoVec(); +} +CAllThreadMgr::~CAllThreadMgr(void) +{ +} +//ʼ߳ +void CAllThreadMgr::InitThreadInfoVec() +{ + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_AutoWorkFlowCtrlThread; + ThreadInfo.m_ThreadName = "̿߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_LaserSleepThread; + ThreadInfo.m_ThreadName = "߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_GetDataPtThread, + ThreadInfo.m_ThreadName = "ʱ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_ExecuteStepThread; + ThreadInfo.m_ThreadName = "ִ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_FastReadInfoThread; + ThreadInfo.m_ThreadName = "״̬ȡ߳(fast)"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_SlowReadInfoThread; + ThreadInfo.m_ThreadName = "״̬ȡ߳(slow)"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_PlcReadInfoThread; + ThreadInfo.m_ThreadName = "PLC ͨ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_SwitchLaserLddThread; + ThreadInfo.m_ThreadName = "ldd ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + #ifdef __LASER_DEVICE_BEAMTECH__ + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_BeamtechSetParToLaserThread; + ThreadInfo.m_ThreadName = "߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + #endif + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_TimingProgressThread; + ThreadInfo.m_ThreadName = "߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_RecordTimeThread; + ThreadInfo.m_ThreadName = "¼ʱ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_WaitTransferLoadEndThread; + ThreadInfo.m_ThreadName = "ȴload ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_CheckTransferLoadThread; + ThreadInfo.m_ThreadName = "ǷҪload ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_DlgDeviceStateInfoTimer; + ThreadInfo.m_ThreadName = "״̬Ϣtimer1"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_DlgDeviceStateInfoTimer2; + ThreadInfo.m_ThreadName = "״̬Ϣtimer2"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_ReadLaserPower; + ThreadInfo.m_ThreadName = "ʼ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_LaserDisMeterReadThread; + ThreadInfo.m_ThreadName = "ͨtimer"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_ReadLaserInfoThread; + ThreadInfo.m_ThreadName = "̼Ϣȡ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_ReadRedLaserInfoThread; + ThreadInfo.m_ThreadName = "Ϣȡ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_AutoTransferFlowThread; + ThreadInfo.m_ThreadName = "ԶƬ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_ReadTransferArmInfoThread; + ThreadInfo.m_ThreadName = "TransferArm ͨ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_UpdateSecsDataThread; + ThreadInfo.m_ThreadName = "SecsVariable ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_CtrlHostJobThread; + ThreadInfo.m_ThreadName = "CtrlHostJob ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } + { + CThreadInfo ThreadInfo; + ThreadInfo.m_ThreadType = _EThreadType_CyclicRunThread; + ThreadInfo.m_ThreadName = "CyclicRun ߳"; + m_ThreadInfoVec.push_back(ThreadInfo); + } +} +void CAllThreadMgr::InsertThreadInfoList(CListCtrl &List,bool bInsert) +{ + if(bInsert) + List.DeleteAllItems(); + + int size = m_ThreadInfoVec.size(); + for(int i=0;i=0 && idx < size) + { + if(m_ThreadInfoVec[idx].m_bRunning) + { + c = RGB_GREEN; + } + } + return c; +} +//Ƿе߳ +bool CAllThreadMgr::HasThreadRunning() +{ + int size = m_ThreadInfoVec.size(); + for(int i=0;iWriteDebugLog(s); + } + } +} +//̵ַ߳ +void CAllThreadMgr::BindingThreadAdr(EThreadType ThreadType,CWinThread*p) +{ + int size = m_ThreadInfoVec.size(); + for(int i=0;i m_ThreadInfoVec;//߳ + +}; + +extern CAllThreadMgr gAllThreadMgr; +extern bool gbStopAllThread;//ֹͣ߳ \ No newline at end of file diff --git a/LaipuDrawing/ApplicationPriority.cpp b/LaipuDrawing/ApplicationPriority.cpp new file mode 100644 index 0000000..38964da --- /dev/null +++ b/LaipuDrawing/ApplicationPriority.cpp @@ -0,0 +1,76 @@ +#include "StdAfx.h" +#include "ApplicationPriority.h" +#include "PropertieMgr.h" +#include "Propertie.h" +#include "LogMgr.h" +#include "AuthorityMgr.h" + +CAppPriorityMgr *gAppPriorityMgr = new CAppPriorityMgr; + +CAppPriorityMgr::CAppPriorityMgr(void) +{ + m_bGetHighestPriority = false;//Ƿڴʱȡȼ +} +CAppPriorityMgr::~CAppPriorityMgr(void) +{ +} +CMFCPropertyGridProperty *CAppPriorityMgr::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = _T("AppPriority");//洢· + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T("ȼ"); + GroupName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_bGetHighestPriority");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bGetHighestPriority); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ȼ"); + Description = _T("Ƿ񽫳ȼϵͳ߼úҪ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bGetHighestPriority, Description); + pGroup->AddSubItem(p); + + gDevicePropertieMgr.Insert(p, pPropertie); + } +//-------------------------------------------------------------------------------// + return pGroup; +} + +void CAppPriorityMgr::OnAppInitialize() +{ + if(m_bGetHighestPriority) + { + //ȡȨ + GetHighestPriority(); + } +} +//ȡȨ +void CAppPriorityMgr::GetHighestPriority() +{ + //ǰȼ + if(SetPriorityClass( GetCurrentProcess(), REALTIME_PRIORITY_CLASS )) + { + gLogMgr->WriteDebugLog("Func---->CAppPriorityMgr : GetHighestPriority : OK"); + } + else + { + gLogMgr->WriteDebugLog("Err---->CAppPriorityMgr : GetHighestPriority : Err"); + } +} \ No newline at end of file diff --git a/LaipuDrawing/ApplicationPriority.h b/LaipuDrawing/ApplicationPriority.h new file mode 100644 index 0000000..af3bb49 --- /dev/null +++ b/LaipuDrawing/ApplicationPriority.h @@ -0,0 +1,20 @@ +#pragma once +#include "module.h" +#include "EnumPropertieType.h" + +//ȼ +class CAppPriorityMgr :public CModule +{ +public: + CAppPriorityMgr(void); + ~CAppPriorityMgr(void); + virtual void OnAppInitialize(); + virtual MODULE GetModuleType(){return _APP_PRIORITY_PROP;}; + virtual CMFCPropertyGridProperty *CreatGridProperty(); +private: + void GetHighestPriority(); +private: + bool m_bGetHighestPriority;//Ƿڴʱȡȼ +}; + +extern CAppPriorityMgr *gAppPriorityMgr; \ No newline at end of file diff --git a/LaipuDrawing/ArrayMgr.cpp b/LaipuDrawing/ArrayMgr.cpp new file mode 100644 index 0000000..5ec15b5 --- /dev/null +++ b/LaipuDrawing/ArrayMgr.cpp @@ -0,0 +1,154 @@ +#include "StdAfx.h" +#include "ArrayMgr.h" +#include "GlobalFunction.h" +#include "CommandArray.h" +#include "CommandMgr.h" + +CArrayMgr::CArrayMgr(void) +{ +} +CArrayMgr::~CArrayMgr(void) +{ +} +void CArrayMgr::Creat(SArrayPar &ArrayPar) +{ + //ʼ + m_ObjContainer.Clear(); + if(ArrayPar.m_bRectArray) + { + RectCreat(ArrayPar); + } + else if(ArrayPar.m_bCircleArray) + { + CircleCreat(ArrayPar); + } + else + { + FillCreat(ArrayPar); + } + //ָ + CreatCmd(); +} +//зʽ +void CArrayMgr::RectCreat(SArrayPar &ArrayPar) +{ + //ָÿο¡һobj m_ObjContainer + for(int i=0;iSaveBaseObj(layer.GetObjContainer()); + //ָ-------end + pCmd->Excute(); + } +} diff --git a/LaipuDrawing/ArrayMgr.h b/LaipuDrawing/ArrayMgr.h new file mode 100644 index 0000000..2640d01 --- /dev/null +++ b/LaipuDrawing/ArrayMgr.h @@ -0,0 +1,54 @@ +#pragma once +#include "ObjContainer.h" +//ò +struct SArrayPar{ +public: + SArrayPar() + { + m_bRectArray = true;//ǷΪ + m_bCircleArray = false; + m_bFillArray = false; + m_ArrayCntH = 10;// + m_ArrayCntV = 1;// + m_ArrayOffsetH = 20;// + m_ArrayOffsetV = 1;// + m_ArrayCnt = 36;//Բе + m_Radius = 10;//а뾶 + m_StartAngle = 90;//пʼǶ + m_GapAngle = 10;//мǶ(360 Ƚ) + m_FillOffset = -0.1; + m_FillCnt = 1000; + } +public: + bool m_bRectArray;//ǷΪ + bool m_bCircleArray; + bool m_bFillArray; + + int m_ArrayCntH;// + int m_ArrayCntV;// + double m_ArrayOffsetH;// + double m_ArrayOffsetV;// + + int m_ArrayCnt;//Բе + double m_Radius;//а뾶 + double m_StartAngle;//пʼǶ(360 Ƚ) + double m_GapAngle;//мǶ(360 Ƚ) + + double m_FillOffset; + int m_FillCnt; +}; +class CArrayMgr +{ +public: + CArrayMgr(void); + ~CArrayMgr(void); + void Creat(SArrayPar &par); +private: + void RectCreat(SArrayPar &ArrayPar); + void CircleCreat(SArrayPar &ArrayPar); + void FillCreat(SArrayPar &ArrayPar); + void CreatCmd(); +private: + CObjContainer m_ObjContainer; +}; + diff --git a/LaipuDrawing/AuthorityMgr.cpp b/LaipuDrawing/AuthorityMgr.cpp new file mode 100644 index 0000000..94fcee8 --- /dev/null +++ b/LaipuDrawing/AuthorityMgr.cpp @@ -0,0 +1,581 @@ +#include "StdAfx.h" +#include "AuthorityMgr.h" +#include "MsgBox.h" +#include "FileMgr.h" +#include "LogMgr.h" +#include "PropertieMgr.h" +#include "Propertie.h" +#include "CStringFuc.h" +#include "WorkTime.h" +#include "ProgramLaserTuiHuo.h" + +#define LAIPU_NAME "laipu" +#define LAIPU_PASSWORD "laipu123" +#define FILE_PATH _T("\\Parameter\\Authority\\Authority.par") +#define AUTHORITY_PARA_FILE _T("\\CommPar\\Authority.bin") +#define NEW_LOGIN_FILE_PATH _T("\\LoginRecord\\") + +bool CompareUser(CAccount Account1,CAccount Account2) +{ + return Account1.m_Authority>Account2.m_Authority; +} + + +CAuthorityMgr *gAuthorityMgr = new CAuthorityMgr; +CAuthorityMgr::CAuthorityMgr(void) +{ + m_AutoFactory = false;//ԶԱȨ + m_CurAuthority = _Authority_NoLogin;//ǰȨ + m_CurUserName = ACCOUNT_NoLogin; + m_bLoginDlgOpen = false;//Ƿڴ򿪵¼Ի +} +CAuthorityMgr::~CAuthorityMgr(void) +{ +} +CMFCPropertyGridProperty *CAuthorityMgr::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = _T("AuthorityMgr");//洢· + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T("Ȩ"); + GroupName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_AutoFactory");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_AutoFactory); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Ȩ"); + Description = _T("ʱԶóȨ,"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_AutoFactory, Description); + pGroup->AddSubItem(p); + + gDevicePropertieMgr.Insert(p, pPropertie); + } +//-------------------------------------------------------------------------------// + return pGroup; +} +void CAuthorityMgr::OnAppInitialize() +{ + SaveOrLoad(false);//ȡļ + if(m_AutoFactory) + m_CurAuthority = _Authority_Factory; + //ȡȨ޲ļ + ReadAuthorityParaFile(); +} +//鵱ǰȨ +bool CAuthorityMgr::CheckAuthority(eAuthorityType authority,bool bShowMsgbox) +{ + if((int)m_CurAuthority >= (int)authority) + { + return true; + } + else + { + if(bShowMsgbox) + { + CMsgBox MsgBox; + CString str = "Ҫ["+GetAccountName(authority) + "]Ȩ!"; + MsgBox.Show(str); + } + return false; + } +} +//Ƿ¼ +bool CAuthorityMgr::IsLogin() +{ + return m_CurAuthority != _Authority_NoLogin; +} +//ûȨޱδ¼ +void CAuthorityMgr::Lock() +{ + //¼ + { + CUserCtrlPar UserCtrlPar; + UserCtrlPar.m_UserName = m_CurUserName; + UserCtrlPar.m_UserCtrlType = _UserCtrlType_logout; + UserCtrlPar.m_AuthorityType = m_CurAuthority; + SaveUserCtrlHistory(UserCtrlPar); + } + SetAuthority(_Authority_NoLogin); + m_CurUserName = ACCOUNT_NoLogin; +} +//¼ +bool CAuthorityMgr::Login(CString name,CString PassWord) +{ + //ȡ˺Ϣ + SaveOrLoad(false); + //ȡȨ޲ļ + ReadAuthorityParaFile(); + + bool ret = false; + eAuthorityType authority = GetCurAuthority(); + if(name == LAIPU_NAME && PassWord == LAIPU_PASSWORD) + { + ret = true; + authority = _Authority_Factory; + } + else + { + vector::iterator iter = m_UserVec.begin(); + vector::iterator iter_end = m_UserVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).m_Name == name) + { + if((*iter).m_PassWord == PassWord) + { + ret = true; + authority = (*iter).m_Authority; + break; + } + else + { + CMsgBox MsgBox; + MsgBox.Show("˺Ųƥ"); + break; + } + } + } + if(iter==iter_end) + { + CMsgBox MsgBox; + MsgBox.Show("˺Ż!"); + } + } + if(ret) + { + SetAuthority(authority); + m_CurUserName = name; + + CString log = "CAuthorityMgr::Login::"; + log += GetAccountName(authority); + log += "->"+name; + gLogMgr->WriteDebugLog(log); + + //¼ + { + CUserCtrlPar UserCtrlPar; + UserCtrlPar.m_UserName = name; + UserCtrlPar.m_UserCtrlType = _UserCtrlType_login; + UserCtrlPar.m_AuthorityType = authority; + SaveUserCtrlHistory(UserCtrlPar); + } + } + return ret; +} +CString CAuthorityMgr::GetAccountName(eAuthorityType authority) +{ + CString s; + switch(authority) + { + case _Authority_NoLogin: + s = ACCOUNT_NoLogin; + break; + case _Authority_Operator: + s = ACCOUNT_Operator; + break; + case _Authority_OperatorAdmin: + s = ACCOUNT_OperatorAdmin; + break; + case _Authority_Engineer: + s = ACCOUNT_Engineer; + break; + case _Authority_Technics: + s = ACCOUNT_Technics; + break; + case _Authority_Factory: + s = ACCOUNT_Factory; + break; + default: + break; + } + return s; +} +//ǰ˻ +CString CAuthorityMgr::GetCurAccountName() +{ + return GetAccountName(GetCurAuthority()); +} +//߶ȡ˻Ϣ +void CAuthorityMgr::SaveOrLoad(bool bSave) +{ + CFileMgr FileMgr; + char filepath[1024]; + FileMgr.GetFullFilePath(filepath,FILE_PATH);//ȡ· + + if(bSave) + { + CFile file(filepath,CFile::modeReadWrite|CFile::modeCreate); + CArchive ar(&file,CArchive::store); + SaveOrLoadExt(ar); + } + else + { + CFile file; + if(file.Open(filepath,CFile::modeRead)) + { + CArchive ar(&file,CArchive::load); + SaveOrLoadExt(ar); + } + else + { + gLogMgr->WriteDebugLog("Authority File Read Error"); + } + } +} +void CAuthorityMgr::SaveOrLoadExt(CArchive &ar) +{ + int size = 0; + if(ar.IsStoring()) + { + size = m_UserVec.size();//Account + ar<>size; + for(int i=0;i::iterator iter = m_UserVec.begin(); + vector::iterator iter_end = m_UserVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).m_Name == Account.m_Name) + { + CMsgBox MsgBox; + CString str(_T("û:")); + str += Account.m_Name + "Ѵ!"; + MsgBox.Show(str); + return; + } + } + m_UserVec.push_back(Account); + // + SortUserVec(); + SaveOrLoad(true); + + //¼ + { + CUserCtrlPar UserCtrlPar; + UserCtrlPar.m_UserName = Account.m_Name; + UserCtrlPar.m_UserCtrlType = _UserCtrlType_AddUser; + UserCtrlPar.m_AuthorityType = Account.m_Authority; + SaveUserCtrlHistory(UserCtrlPar); + } + + CMsgBox MsgBox; + MsgBox.Show("ɹ!"); +} +//ɾָû +void CAuthorityMgr::DelUser(int idx) +{ + //Engineer ɾû + if(gAuthorityMgr->CheckAuthority(_Authority_Engineer,true)==false) + { + return; + } + vector::iterator iter = m_UserVec.begin(); + vector::iterator iter_end = m_UserVec.end(); + for(int i=0;iter!=iter_end;iter++,i++) + { + if(i==idx) + { + CAccount Account = (*iter); + CMsgBox MsgBox; + if((*iter).m_Authority>m_CurAuthority) + { + MsgBox.Show(_T("ɾ߼û!")); + return; + } + + CString str(_T("ɾ")); + str += (*iter).m_Name + "?"; + if(MsgBox.ConfirmOkCancel(str)) + { + m_UserVec.erase(iter); + SortUserVec(); + SaveOrLoad(true); + + //¼ + { + CUserCtrlPar UserCtrlPar; + UserCtrlPar.m_UserName = Account.m_Name; + UserCtrlPar.m_UserCtrlType = _UserCtrlType_DelUser; + UserCtrlPar.m_AuthorityType = Account.m_Authority; + SaveUserCtrlHistory(UserCtrlPar); + } + } + return; + } + } +} +void CAuthorityMgr::InsertToList(CListCtrl &List) +{ + int size = m_UserVec.size(); + for(int i=0;iWriteDebugLog("Func--->ReadAuthorityParaFile"); + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,AUTHORITY_PARA_FILE);//ļ· + vector> StrVec; + FileMgr.ReadFileToStrVec(FilePath,StrVec); + + m_AuthorityParVec.clear(); + int size = StrVec.size(); + for(int k=0;kWriteDebugLog("Func--->SaveAuthorityParaFile"); + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,AUTHORITY_PARA_FILE);//ļ· + + m_AuthorityParVec = m_TmpAuthorityParVec; + + ofstream FileStream; + FileStream.open(FilePath); + int size = m_AuthorityParVec.size(); + for(int k=0;kGetLaipuLaserDataDir(NEW_LOGIN_FILE_PATH); + DataPath += DirPath; + + DataPath += WorkTime.GetCurYear(); + DataPath += "\\"+WorkTime.GetCurMonth(); + //DataPath += "\\"+WorkTime.GetCurDay(); + DataPath += "\\"; + CString DataName; + DataName += "LaipuDrawing_"; + DataName += CurDateTime; + + //Ŀ¼ + FileMgr.CreatDir(DataPath); + + FileMgr.WriteDataToExcel(DataPath,DataName,CsvData,true); + +} +#endif \ No newline at end of file diff --git a/LaipuDrawing/AuthorityMgr.h b/LaipuDrawing/AuthorityMgr.h new file mode 100644 index 0000000..0184f91 --- /dev/null +++ b/LaipuDrawing/AuthorityMgr.h @@ -0,0 +1,141 @@ +#pragma once +#include "GlobalDefine.h" +#include "module.h" + +#define ACCOUNT_NoLogin "No Login" +#define ACCOUNT_Operator "Operator" +#define ACCOUNT_OperatorAdmin "OperatorAdmin" +#define ACCOUNT_Engineer "Engineer" +#define ACCOUNT_Technics "Technics" +#define ACCOUNT_Factory "Factory" + +enum eAuthorityType +{ + _Authority_NoLogin = 0,//δ¼ + _Authority_Operator,//Ա + _Authority_OperatorAdmin,//߹Ա + _Authority_Engineer,//豸ʦ + _Authority_Technics,//չʦ + _Authority_Factory,// +}; + + + +//˺ +class CAccount +{ +public: + CAccount() + { + m_Authority = _Authority_NoLogin; + } + void Serialize(CArchive& ar) + { + if(ar.IsStoring()) + { + ar<<(int)m_Authority; + ar<>tmp; + m_Authority = (eAuthorityType)tmp; + ar>>m_Name; + ar>>m_PassWord; + } + } +public: + eAuthorityType m_Authority;//Ȩ + CString m_Name;//û + CString m_PassWord;// +}; + +class CAuthorityPar +{ +public: + CAuthorityPar(void) + { + m_bOperator = false;//Ա + m_bOperatorAdmin = false;//߹Ա + m_bEngineer = false;//豸ʦ + m_bTechnics = false;//չʦ + }; +public: + CString m_AuthorityName;// + CString m_ShowName;//ʾ + bool m_bOperator;//Ա + bool m_bOperatorAdmin;//߹Ա + bool m_bEngineer;//豸ʦ + bool m_bTechnics;//չʦ +}; + +enum eUserCtrlType +{ + _UserCtrlType_AddUser = 0,//˺ + _UserCtrlType_DelUser,//ɾ˺ + _UserCtrlType_login,//¼ + _UserCtrlType_logout,//˳¼ +}; +class CUserCtrlPar +{ +public: + CUserCtrlPar(void) + { + + }; +public: + eUserCtrlType m_UserCtrlType;// + CString m_UserName;//û + eAuthorityType m_AuthorityType;//Ȩ +}; + +//Ȩ޹ +class CAuthorityMgr:public CModule +{ +public: + CAuthorityMgr(void); + ~CAuthorityMgr(void); + virtual void OnAppInitialize(); + virtual MODULE GetModuleType(){return _AUTHORITY_PROP;}; + virtual CMFCPropertyGridProperty *CreatGridProperty(); + + void SetAuthority(eAuthorityType authority){m_CurAuthority = authority;};//õǰȨ + bool CheckAuthority(eAuthorityType authority,bool bShowMsgbox = false);//鵱ǰȨ + bool CheckAuthorityByName(CString AuthorityName,bool bShowMsgbox); + eAuthorityType GetCurAuthority(){return m_CurAuthority;}; + void AddAccount(CAccount Account); + bool Login(CString name,CString PassWord); + CString GetAccountName(eAuthorityType authority); + void SaveOrLoad(bool bSave); + void InsertToList(CListCtrl &List); + void DelUser(int idx); + CString GetCurAccountName(); + CString GetCurUserName(){return m_CurUserName;}; + bool IsAutoFactory(){return m_AutoFactory;}; + void Lock(); + bool IsLogin(); + void InitAuthorityParList(CListCtrl &List); + void InitAuthorityTypeComb(CComboBox &Combo); + void UpdateAuthorityPar(CListCtrl &List,int AuthorityType); + void UpdateAuthorityParList(CListCtrl &List,int AuthorityType); + void SaveAuthorityParaFile(); + void SetbLoginDlgOpen(bool b){m_bLoginDlgOpen = b;}; + bool IsbLoginDlgOpen(){return m_bLoginDlgOpen;}; +private: + void SaveOrLoadExt(CArchive &ar); + void SortUserVec(); + void ReadAuthorityParaFile(); + void SaveUserCtrlHistory(CUserCtrlPar UserCtrlPar); +private: + eAuthorityType m_CurAuthority;//ǰȨ + CString m_CurUserName;//ǰû + vector m_UserVec;//еû + bool m_AutoFactory;//ԶԱȨ + bool m_bLoginDlgOpen;//Ƿڴ򿪵¼Ի + vector m_AuthorityParVec; + vector m_TmpAuthorityParVec;//ǰIJ +}; + +extern CAuthorityMgr *gAuthorityMgr; \ No newline at end of file diff --git a/LaipuDrawing/BitOperation.h b/LaipuDrawing/BitOperation.h new file mode 100644 index 0000000..4e6845d --- /dev/null +++ b/LaipuDrawing/BitOperation.h @@ -0,0 +1,51 @@ +#pragma once +//λ㺯 + +//PortVal PortIdx λΪ1 +inline long SetBitOn(long Val,int Idx) +{ + Val= Val |(1<>Idx)&1) + return TRUE; + else + return FALSE; +} +inline BOOL IsBitOn(int Val,int Idx) +{ + if((Val>>Idx)&1) + return TRUE; + else + return FALSE; +} +inline long SetBitByBool(BYTE Val,int Idx,bool b) +{ + if(b) + return SetBitOn(Val,Idx); + return SetBitOff(Val,Idx); +} \ No newline at end of file diff --git a/LaipuDrawing/CStringFuc.h b/LaipuDrawing/CStringFuc.h new file mode 100644 index 0000000..7a70133 --- /dev/null +++ b/LaipuDrawing/CStringFuc.h @@ -0,0 +1,141 @@ +#pragma once +#include "GlobalDefine.h" +#include "BitOperation.h" +#define TRUE_STR _T("TRUE") +#define FALSE_STR _T("FALSE") +//MFC CString صһЩ + +//ȥС治Ҫ0 +inline void DeleteZero(CString &s) +{ + int nIndex; + nIndex=s.Find('.'); + if (nIndex>=0) + { + s.TrimRight('0'); + if (s.GetLength()==nIndex+1) + { + s=s.Left(nIndex); + if (s.IsEmpty()) + s='0'; + } + } +} + +//double תΪCString (DigitsCnt Сλ,== 6) +inline CString Db2CString(double n,int DigitsCnt = -1) +{ + CString s; + if(DigitsCnt==0) + s.Format("%ld",(int)n); + if(DigitsCnt==1) + s.Format("%.1f",n); + if(DigitsCnt==2) + s.Format("%.2f",n); + if(DigitsCnt==3) + s.Format("%.3f",n); + if(DigitsCnt==4) + s.Format("%.4f",n); + if(DigitsCnt==5) + s.Format("%.5f",n); + if(DigitsCnt==6) + s.Format("%.6f",n); + if(DigitsCnt<0) + { + s.Format("%lf",n); + //ɾĩβ0 + DeleteZero(s); + } + return s; +} +//int תΪCString +inline CString Int2CString(int n) +{ + CString s; + s.Format("%ld",n); + return s; +} +inline CString ByteToString(BYTE bit) +{ + CString str; + for(int i=7;i>=0;i--) + { + if(IsBitOn(bit,i)) + str += "1"; + else + str += "0"; + } + return str; +} +//ȡbool ͵str +inline CString GetBoolValStr(bool b) +{ + if(b) + return TRUE_STR; + else + return FALSE_STR; +} +//str вSubStr ,ҵtrue +inline bool FindSubStr(CString &str,CString &SubStr) +{ + return (str.Find(SubStr) != -1); +} +//ɾӴʣұߵIJ +inline CString DelSubStr(CString str,CString &SubStr) +{ + int pos = str.Find(SubStr); + if(pos != -1) + { + str = str.Right(str.GetLength()-(pos+SubStr.GetLength())); + } + return str; +} +inline int CStringToInt(CString &str) +{ + return _tstoi(LPCTSTR(str)); +} +inline double CStringToDouble(CString &str) +{ + return _tstof(LPCTSTR(str)); +} +inline bool CStringToBool(CString &str) +{ + if(str == TRUE_STR) + return true; + return false; +} +inline CString Bool2Str(bool b) +{ + if(b) + return "TRUE"; + else + return "FALSE"; +} +inline CString Bool2CString(bool b) +{ + if(b) + return "1"; + else + return "0"; +} +inline bool Str2Bool(CString &str) +{ + if(str == _T("TRUE")) + return true; + else + return false; +} +inline CString Int2Str_LeftZero(int n) +{ + CString s; + if(n<10) + s.Format("0%ld",n);//߲0 + else + s.Format("%ld",n); + return s; +} +//жString ǷΪ +inline bool IsStringDigit(CString s) +{ + return (s.SpanIncluding("0123456789") == s); +} \ No newline at end of file diff --git a/LaipuDrawing/CatchMgr.cpp b/LaipuDrawing/CatchMgr.cpp new file mode 100644 index 0000000..aa634e8 --- /dev/null +++ b/LaipuDrawing/CatchMgr.cpp @@ -0,0 +1,301 @@ +#include "StdAfx.h" +#include "CatchMgr.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "DrawSimpleShape.h" +#include "ObjComponentMgr.h" +#include "MouseToolmgr.h" + +CCatchMgr gCatchMgr;//׽ +CCatchMgr::CCatchMgr() +{ + ResetCatchNode(); +} +CCatchMgr::~CCatchMgr(void) +{ +} +#if 1//׽ +void CCatchMgr::DrawCatchPoint(CCatchPoint CatchPt,CDC* pDC) +{ + if(m_CatchPointVec.empty()) + { + ResetCatchPoint(pDC); + } + else + { + //֮ǰ + if(!CatchPt.Equal(m_CatchNode)) + { + ResetCatchPoint(pDC); + } + if(!CatchPt.Equal(m_CatchNode)) + { + DrawCatchPointExt(CatchPt,pDC); + //浱ǰIJ + m_CatchNode = CatchPt; + } + } +} +void CCatchMgr::DrawCatchPointExt(CCatchPoint pt,CDC* pDC) +{ + DbRect NodeRect(pt,gDraw->GetCatchNodeSize()); + switch(pt.GetType()) + { + case _CATCH_NODE: + DrawRect(pDC,gDraw->GetCatchNodePen(),NodeRect); + break; + case _CATCH_INTERSECT: + case _CATCH_ORTHO: + case _CATCH_CUT_TRACK: + XorDrawCrossX(pDC,gDraw->GetCatchNodePen(),NodeRect); + break; + default: + break; + } +} +void CCatchMgr::ResetCatchNode() +{ + m_CatchNode.x = -10000.123456; + m_CatchNode.y = -10000.123456; +} +void CCatchMgr::ResetCatchPoint(CDC* pDC) +{ + if(HasCatchPoint()) + { + //֮ǰ + DrawCatchPointExt(m_CatchNode,pDC); + } + // + ResetCatchNode(); +} +bool CCatchMgr::HasCatchPoint() +{ + if(m_CatchNode.x == -10000.123456) + { + return false; + } + return true; +} +bool CCatchMgr::GetCatchPoint(CPoint &pt) +{ + if(HasCatchPoint()) + { + pt = gDraw->Dbxy2CPoint(m_CatchNode); + return true; + } + return false; +} +//ȡIJ +CCatchPoint CCatchMgr::GetNearestCatchPt(Dbxy pt) +{ + CCatchPoint CatchPt; + double MinDis; + vector::iterator iter = m_CatchPointVec.begin(); + vector::iterator iter_end = m_CatchPointVec.end(); + for(;iter!=iter_end;iter++) + { + double dis = CalDistance(pt,(*iter)); + if(iter == m_CatchPointVec.begin()) + { + MinDis = dis; + CatchPt = (*iter); + } + else if(disGetCurCatchRect(pt); + + //ռrect Χе߶ + GetLineInRect(rect,bCatchTemp); + //rect Χڵnode ڵ + CatchNode(rect); + //rect Χ߶εĽ + CatchIntersectPointOfLines(rect); + //rect ߶εĽ + CatchIntersectPointWithMouse(rect); + // + CatchOrthoPoint(DownPt,pt,rect); + //׽ԪиĽ㣬ָmark + CatchCutTrack(rect); + //ѡĵΪ + CCatchPoint CatchPt; + if(!m_CatchPointVec.empty()) + { + CatchPt = GetNearestCatchPt(pt); + } + //Ʋ + DrawCatchPoint(CatchPt,pDC); +} +//ռrect Χе߶ +void CCatchMgr::GetLineInRect(DbRect &rect,bool bCatchTemp) +{ + gLayer.GetLineInRect(rect,m_DataPtLineVec,bCatchTemp); +} +//ռrect ΧڵĽڵ +void CCatchMgr::CatchNode(DbRect rect) +{ + if(gDraw->IsCatchObjNode()== false) + return; + //ȼ + if(!m_CatchPointVec.empty()) + return; + //߶εĶ˵Ƿھڼ + vector::iterator iter = m_DataPtLineVec.begin(); + vector::iterator iter_end = m_DataPtLineVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).m_pt1.IsNode()) + { + Dbxy pt = (*iter).m_pt1.GetPt(); + if(IsPointInRect(pt,rect)) + { + CCatchPoint CatchPoint(pt.x,pt.y,_CATCH_NODE); + m_CatchPointVec.push_back(CatchPoint); + } + } + if((*iter).m_pt2.IsNode()) + { + Dbxy pt = (*iter).m_pt2.GetPt(); + if(IsPointInRect(pt,rect)) + { + CCatchPoint CatchPoint(pt.x,pt.y,_CATCH_NODE); + m_CatchPointVec.push_back(CatchPoint); + } + } + } +} +//ռrect Χڵ߶ν +void CCatchMgr::CatchIntersectPointOfLines(DbRect rect) +{ + if(gDraw->IsCatchCrossPoint()== false) + return; + //ȼ + if(!m_CatchPointVec.empty()) + return; + int size = m_DataPtLineVec.size(); + for(int i=0;iIsCatchObjLine()== false) + return; + //ȼ + if(!m_CatchPointVec.empty()) + return; + vector::iterator iter = m_DataPtLineVec.begin(); + vector::iterator iter_end = m_DataPtLineVec.end(); + for(;iter!=iter_end;iter++) + { + Dbxy LinePt1 = (*iter).m_pt1.GetPt(); + Dbxy LinePt2 = (*iter).m_pt2.GetPt(); + if(IsPointInRect(LinePt1,rect)||IsPointInRect(LinePt2,rect))//Ҫ׽˵IJ + { + break; + } + Dbxy pt = IntersectionOfRectAndLine(LinePt1,LinePt2,rect); + CCatchPoint CatchPoint(pt.x,pt.y,_CATCH_INTERSECT); + m_CatchPointVec.push_back(CatchPoint); + } +} +// +void CCatchMgr::CatchOrthoPoint(Dbxy DownPt,Dbxy MousePt,DbRect rect) +{ + if(gDraw->IsCatchOrthoPoint()== false) + return; + //ȼ + if(!m_CatchPointVec.empty()) + return; + + DbSize size = rect.GetSize(); + if(abs(MousePt.x-DownPt.x)<=size.w/2) + { + CCatchPoint CatchPoint(DownPt.x,MousePt.y,_CATCH_ORTHO); + m_CatchPointVec.push_back(CatchPoint); + } + else if(abs(MousePt.y-DownPt.y)<=size.h/2) + { + CCatchPoint CatchPoint(MousePt.x,DownPt.y,_CATCH_ORTHO); + m_CatchPointVec.push_back(CatchPoint); + } +} +//׽ԪиĽ㣬ָmark +void CCatchMgr::CatchCutTrack(DbRect rect) +{ + if(gDraw->IsCatchCutTrack()== false) + return; + //ȼ + if(!m_CatchPointVec.empty()) + return; + //ֻڲʱŲ׽ + MOUSE_TOOL tool = gMouseToolMgr.GetToolType(); + if(tool == _TOOL_MEASURE) + { + vector&vec = gObjComponentMgr->GetComponentVec(); + + Dbxy pt = rect.GetCenterPt(); + + double MinDis = 0;//ľ + + int MinIdx = -1; + int size = vec.size(); + for(int i=0;i m_DataPtLineVec;//rect Χе߶ + vector m_CatchPointVec;//귶ΧڵIJ + CCatchPoint m_CatchNode;//֮ǰץȡĵ +}; + +extern CCatchMgr gCatchMgr; \ No newline at end of file diff --git a/LaipuDrawing/ChildFrm.cpp b/LaipuDrawing/ChildFrm.cpp new file mode 100644 index 0000000..5337fd9 --- /dev/null +++ b/LaipuDrawing/ChildFrm.cpp @@ -0,0 +1,66 @@ + +// ChildFrm.cpp : CChildFrame ʵ +// + +#include "stdafx.h" +#include "LaiPuLaser.h" + +#include "ChildFrm.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +// CChildFrame + +IMPLEMENT_DYNCREATE(CChildFrame, CMDIChildWndEx) + +BEGIN_MESSAGE_MAP(CChildFrame, CMDIChildWndEx) + ON_WM_SYSCOMMAND() +END_MESSAGE_MAP() + +// CChildFrame / + +CChildFrame::CChildFrame() +{ + // TODO: ڴӳԱʼ +} + +CChildFrame::~CChildFrame() +{ +} + + +BOOL CChildFrame::PreCreateWindow(CREATESTRUCT& cs) +{ + // TODO: ڴ˴ͨ޸ CREATESTRUCT cs ޸Ĵʽ + + if( !CMDIChildWndEx::PreCreateWindow(cs) ) + return FALSE; + cs.style |= WS_MAXIMIZE; + return TRUE; +} + +// CChildFrame + +#ifdef _DEBUG +void CChildFrame::AssertValid() const +{ + CMDIChildWndEx::AssertValid(); +} + +void CChildFrame::Dump(CDumpContext& dc) const +{ + CMDIChildWndEx::Dump(dc); +} +#endif //_DEBUG + +// CChildFrame Ϣ +void CChildFrame::OnSysCommand(UINT nID, LPARAM lParam) +{ + if(nID == SC_CLOSE) + return; + CMDIChildWndEx::OnSysCommand(nID, lParam); +} \ No newline at end of file diff --git a/LaipuDrawing/ChildFrm.h b/LaipuDrawing/ChildFrm.h new file mode 100644 index 0000000..c193cd3 --- /dev/null +++ b/LaipuDrawing/ChildFrm.h @@ -0,0 +1,34 @@ + +// ChildFrm.h : CChildFrame Ľӿ +// + +#pragma once + +class CChildFrame : public CMDIChildWndEx +{ + DECLARE_DYNCREATE(CChildFrame) +public: + CChildFrame(); + +// +public: + +// +public: + +// д + virtual BOOL PreCreateWindow(CREATESTRUCT& cs); + +// ʵ +public: + virtual ~CChildFrame(); +#ifdef _DEBUG + virtual void AssertValid() const; + virtual void Dump(CDumpContext& dc) const; +#endif + +// ɵϢӳ亯 +protected: + afx_msg void OnSysCommand( UINT nID, LPARAM lParam ); + DECLARE_MESSAGE_MAP() +}; diff --git a/LaipuDrawing/ClassDiagram1.cd b/LaipuDrawing/ClassDiagram1.cd new file mode 100644 index 0000000..0519ecb --- /dev/null +++ b/LaipuDrawing/ClassDiagram1.cd @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/LaipuDrawing/ClassDiagram2.cd b/LaipuDrawing/ClassDiagram2.cd new file mode 100644 index 0000000..0519ecb --- /dev/null +++ b/LaipuDrawing/ClassDiagram2.cd @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/LaipuDrawing/CommPortClass.h b/LaipuDrawing/CommPortClass.h new file mode 100644 index 0000000..55c726d --- /dev/null +++ b/LaipuDrawing/CommPortClass.h @@ -0,0 +1,689 @@ +/* +Comm Base Library(WIN98/NT/2000) ver 1.1 +Compile by BC++ 5; C++ Builder 4, 5, 6, X; VC++ 5, 6; VC.net; GCC; +copyright(c) 2004.5 - 2005.8 llbird wushaojian@21cn.com +*/ +#ifndef _CN_COMM_H_ +#define _CN_COMM_H_ + +#pragma warning(disable: 4530) +#pragma warning(disable: 4786) +#pragma warning(disable: 4800) +//α뾯 +#pragma warning(disable : 4244) +#pragma warning(disable : 4305) +#pragma warning(disable : 4996) +#pragma warning(disable : 4101) +#pragma warning(disable : 4477) + + +#include +#include +#include + +//Ĵ: ṩͨõĴڲ +/* +崮ڶ +cnComm com; + +1.ʹʱҪڳʼʱ򿪴ڣò +com.Open(); + +2.ַ +com.Write(m_send);//m_sendΪ͵ַ + +3.մϢҪõԻ(Զȡ) +ΪڵĽ¼һûϢON_COM_RECEIVE +afx_msg LRESULT OnCommRecv(WPARAM wParam, LPARAM lParam); + +ON_MESSAGE(ON_COM_RECEIVE,OnCommRecv) + +ԻʼʱϢ +com.SetWnd((*this)); +Ϣ +LRESULT CSerialPortClassDlg::OnCommRecv(WPARAM wParam, LPARAM lParam) +{ +//ȡϵַ +char str[100]; +com.ReadString(str, 100); +} +*/ +//͵ڵϢ WPARAM ˿ں +#define ON_COM_RECEIVE WM_USER + 618 +#define ON_COM_CTS WM_USER + 619 //LPARAM 1 valid +#define ON_COM_DSR WM_USER + 621 //LPARAM 1 valid +#define ON_COM_RING WM_USER + 623 +#define ON_COM_RLSD WM_USER + 624 +#define ON_COM_BREAK WM_USER + 625 +#define ON_COM_TXEMPTY WM_USER + 626 +#define ON_COM_ERROR WM_USER + 627 //LPARAM save Error ID +#define DEFAULT_COM_MASK_EVENT EV_RXCHAR | EV_ERR | EV_CTS | EV_DSR | EV_BREAK | EV_TXEMPTY | EV_RING | EV_RLSD + +class cnComm +{ + public: + //------------------------------Construction----------------------------------- + //1ΪǷڴ򿪴ʱ̣߳ 2ΪIOʽ ʽ0/ 첽صʽĬϣ + cnComm(bool fAutoBeginThread = true, DWORD dwIOMode = FILE_FLAG_OVERLAPPED): _dwIOMode(dwIOMode), _fAutoBeginThread(fAutoBeginThread) + { + Init(); + } + + virtual ~cnComm() + { + Close(); + UnInit(); + } + + //----------------------------------Attributes---------------------------------- + //жϴǷ + inline bool IsOpen() + { + return _hCommHandle != INVALID_HANDLE_VALUE; + } + //жϴǷ + operator bool() + { + return _hCommHandle != INVALID_HANDLE_VALUE; + } + //ôھ + inline HANDLE GetHandle() + { + return _hCommHandle; + } + //ôھ + operator HANDLE() + { + return _hCommHandle; + } + //ôڲ DCB + DCB *GetState() + { + return IsOpen() && ::GetCommState(_hCommHandle, &_DCB) == TRUE ? + &_DCB: NULL; + } + //ôڲ DCB + bool SetState(DCB *pdcb = NULL) + { + return IsOpen() ? ::SetCommState(_hCommHandle, pdcb == NULL ? &_DCB:pdcb) == TRUE: false; + } + //ôڲʣֹͣλ ַ֧ "9600, 8, n, 1" + bool SetState(char *szSetStr) + { + if (IsOpen()) + { + if (::GetCommState(_hCommHandle, &_DCB) != TRUE) + return false; + if (::BuildCommDCB(szSetStr, &_DCB) != TRUE) + return false; + return ::SetCommState(_hCommHandle, &_DCB) == TRUE; + } + return false; + } + //ôڲʣֹͣλ + bool SetState(DWORD dwBaudRate, DWORD dwByteSize = 8, DWORD dwParity = NOPARITY, DWORD dwStopBits = ONESTOPBIT) + { + if (IsOpen()) + { + if (::GetCommState(_hCommHandle, &_DCB) != TRUE) + return false; + _DCB.BaudRate = dwBaudRate; + _DCB.ByteSize = (unsigned char)dwByteSize; + _DCB.Parity = (unsigned char)dwParity; + _DCB.StopBits = (unsigned char)dwStopBits; + return ::SetCommState(_hCommHandle, &_DCB) == TRUE; + } + return false; + } + //óʱṹ + LPCOMMTIMEOUTS GetTimeouts(void) + { + return IsOpen() && ::GetCommTimeouts(_hCommHandle, &_CO) == TRUE ? &_CO: NULL; + } + //óʱ + bool SetTimeouts(LPCOMMTIMEOUTS lpCO) + { + return IsOpen() ? ::SetCommTimeouts(_hCommHandle, lpCO) == TRUE:false; + } + //ôڵI/OС + bool SetBufferSize(DWORD dwInputSize, DWORD dwOutputSize) + { + return IsOpen() ? ::SetupComm(_hCommHandle, dwInputSize, dwOutputSize)== TRUE: false; + } + //ϢĴھ + inline void SetWnd(HWND hWnd) + { + assert(::IsWindow(hWnd)); + _hNotifyWnd = hWnd; + } + //趨֪ͨ, ַСֵ + inline void SetNotifyNum(DWORD dwNum) + { + _dwNotifyNum = dwNum; + } + //߳Ƿ + inline bool IsThreadRunning() + { + return _hThreadHandle != NULL; + } + //߳̾ + inline HANDLE GetThread() + { + return _hThreadHandle; + } + //Ҫӵ¼ ǰЧ + void SetMaskEvent(DWORD dwEvent = DEFAULT_COM_MASK_EVENT) + { + _dwMaskEvent = dwEvent; + } + //öַ + int GetInputSize() + { + COMSTAT Stat; + DWORD dwError; + + return ::ClearCommError(_hCommHandle, &dwError, &Stat) == TRUE ? Stat.cbInQue : (DWORD) - 1L; + } + + //----------------------------------Operations---------------------------------- + //򿪴 ȱʡ 9600, 8, n, 1 + bool Open(DWORD dwPort) + { + return Open(dwPort, 9600); + } + //򿪴 ȱʡ baud_rate, 8, n, 1 + bool Open(DWORD dwPort, DWORD dwBaudRate) + { + if (dwPort < 1 || dwPort > 1024) + return false; + BindCommPort(dwPort); + + if (!OpenCommPort()) + return false; + + if (!SetupPort()) + return false; + + return SetState(dwBaudRate); + } + //򿪴, ʹ"9600, 8, n, 1"ַô + bool Open(DWORD dwPort, char *szSetStr) + { + if (dwPort < 1 || dwPort > 1024) + return false; + + BindCommPort(dwPort); + + if (!OpenCommPort()) + return false; + + if (!SetupPort()) + return false; + + return SetState(szSetStr); + } + //ȡ dwBufferLengthַ Buffer ʵʶַ ɶ + DWORD Read(LPVOID Buffer, DWORD dwBufferLength, DWORD dwWaitTime = 10) + { + if (!IsOpen()) + return 0; + + COMSTAT Stat; + DWORD dwError; + + if (::ClearCommError(_hCommHandle, &dwError, &Stat) && dwError > 0) + { + ::PurgeComm(_hCommHandle,PURGE_RXABORT | PURGE_RXCLEAR); + return 0; + } + if (!Stat.cbInQue) + // + return 0; + + unsigned long uReadLength = 0; + + dwBufferLength = dwBufferLength > Stat.cbInQue ? Stat.cbInQue :dwBufferLength; + + if (!::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength,&_ReadOverlapped)) + { + if (::GetLastError() == ERROR_IO_PENDING) + { + WaitForSingleObject(_ReadOverlapped.hEvent, dwWaitTime); + // 첽I/O + if (!::GetOverlappedResult(_hCommHandle, &_ReadOverlapped,&uReadLength, false)) + { + if (::GetLastError() != ERROR_IO_INCOMPLETE) + uReadLength = 0; + } + } + else + uReadLength = 0; + } + + return uReadLength; + } + //ȡ dwBufferLength - 1 ַ szBuffer ANSI C ģʽַָ ʺһַͨѶ + + char *ReadString(char *szBuffer, DWORD dwBufferLength, DWORD dwWaitTime =20) + { + unsigned long uReadLength = Read(szBuffer, dwBufferLength - 1,dwWaitTime); + szBuffer[uReadLength] = '\0'; + return szBuffer; + } + //д д "abcd" or "\x0\x1\x2" + DWORD Write(LPVOID Buffer, DWORD dwBufferLength) + { + if (!IsOpen()) + return 0; + + DWORD dwError; + + if (::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0) + ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR); + + unsigned long uWriteLength = 0; + + if (!::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength,&_WriteOverlapped)) + if (::GetLastError() != ERROR_IO_PENDING) + uWriteLength = 0; + + return uWriteLength; + } + //д дANSI C ģʽַָ + DWORD Write(const char *szBuffer) + { + assert(szBuffer); + + return Write((void*)szBuffer, strlen(szBuffer)); + } + // ͬӦ + DWORD ReadSync(LPVOID Buffer, DWORD dwBufferLength) + { + if (!IsOpen()) + return 0; + + DWORD dwError; + if (::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0) + { + ::PurgeComm(_hCommHandle,PURGE_RXABORT | PURGE_RXCLEAR); + return 0; + } + + DWORD uReadLength = 0; + ::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, NULL); + return uReadLength; + } + //д ͬӦ + DWORD WriteSync(LPVOID Buffer, DWORD dwBufferLength) + { + if (!IsOpen()) + return 0; + + DWORD dwError; + if (::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0) + ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR); + + unsigned long uWriteLength = 0; + ::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength, NULL); + return uWriteLength; + } + //д szBuffer ʽַ + DWORD Write(char *szBuffer, DWORD dwBufferLength, char *szFormat, ...) + { + if (!IsOpen()) + return 0; + + va_list va; + va_start(va, szFormat); + _vsnprintf(szBuffer, dwBufferLength, szFormat, va); + va_end(va); + + return Write(szBuffer); + } + //д szBuffer ʽַ 黺 С + DWORD Write(char *szBuffer, char *szFormat, ...) + { + if (!IsOpen()) + return 0; + + va_list va; + va_start(va, szFormat); + vsprintf(szBuffer, szFormat, va); + va_end(va); + + return Write(szBuffer); + } + //رմ ͬʱҲرչ߳ + virtual void Close() + { + if (IsOpen()) + { + PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR); + + EndThread(); + ::CloseHandle(_hCommHandle); + + _hCommHandle = INVALID_HANDLE_VALUE; + } + } + //DTR ƽ + bool SetDTR(bool OnOrOff) + { + return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETDTR :CLRDTR): false; + } + //RTS ƽ + bool SetRTS(bool OnOrOff) + { + return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETRTS :CLRRTS): false; + } + // + bool SetBreak(bool OnOrOff) + { + return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETBREAK: CLRBREAK): false; + } + //߳̿ ߳ + bool BeginThread() + { + if (!IsThreadRunning()) + { + _fRunFlag = true; + _hThreadHandle = NULL; + + DWORD id; + + _hThreadHandle = ::CreateThread(NULL, 0, CommThreadProc, this, 0,&id); + + return (_hThreadHandle != NULL); + } + return false; + } + //ͣ߳ + inline bool SuspendThread() + { + return IsThreadRunning() ? ::SuspendThread(_hThreadHandle) !=0xFFFFFFFF: false; + } + //ָ߳ + inline bool ResumeThread() + { + return IsThreadRunning() ? ::ResumeThread(_hThreadHandle) !=0xFFFFFFFF: false; + } + //ֹ߳ + bool EndThread(DWORD dwWaitTime = 100) + { + if (IsThreadRunning()) + { + _fRunFlag = false; + ::SetCommMask(_hCommHandle, 0); + ::SetEvent(_WaitOverlapped.hEvent); + if (::WaitForSingleObject(_hThreadHandle, dwWaitTime) !=WAIT_OBJECT_0) + if (!::TerminateThread(_hThreadHandle, 0)) + return false; + + ::CloseHandle(_hThreadHandle); + ::ResetEvent(_WaitOverlapped.hEvent); + + _hThreadHandle = NULL; + + return true; + } + return false; + } + + protected: + volatile DWORD _dwPort; //ں + volatile HANDLE _hCommHandle; //ھ + char _szCommStr[20]; //COM1Ƶַ + + DCB _DCB; //ʣֹͣλ + COMMTIMEOUTS _CO; //ʱṹ + + DWORD _dwIOMode; // 0 ͬ Ĭ FILE_FLAG_OVERLAPPEDصI/O첽 + OVERLAPPED _ReadOverlapped, _WriteOverlapped; // صI/O + + volatile HANDLE _hThreadHandle; //߳ + volatile HWND _hNotifyWnd; // ֪ͨ + volatile DWORD _dwNotifyNum; //ֽܶ(>=_dwNotifyNum)֪ͨϢ + volatile DWORD _dwMaskEvent; //ӵ¼ + volatile bool _fRunFlag; //߳ѭ־ + bool _fAutoBeginThread; //Open() Զ BeginThread(); + OVERLAPPED _WaitOverlapped; //WaitCommEvent use + + //ʼ + void Init() + { + memset(_szCommStr, 0, 20); + memset(&_DCB, 0, sizeof(_DCB)); + _DCB.DCBlength = sizeof(_DCB); + _hCommHandle = INVALID_HANDLE_VALUE; + + memset(&_ReadOverlapped, 0, sizeof(_ReadOverlapped)); + memset(&_WriteOverlapped, 0, sizeof(_WriteOverlapped)); + + _ReadOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL); + assert(_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE); + + _WriteOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL); + assert(_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE); + + _hNotifyWnd = NULL; + _dwNotifyNum = 0; + _dwMaskEvent = DEFAULT_COM_MASK_EVENT; + _hThreadHandle = NULL; + + memset(&_WaitOverlapped, 0, sizeof(_WaitOverlapped)); + _WaitOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL); + assert(_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE); + } + // + void UnInit() + { + if (_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE) + CloseHandle(_ReadOverlapped.hEvent); + + if (_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE) + CloseHandle(_WriteOverlapped.hEvent); + + if (_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE) + CloseHandle(_WaitOverlapped.hEvent); + } + //󶨴 + void BindCommPort(DWORD dwPort) + { + assert(dwPort >= 1 && dwPort <= 1024); + + char p[5]; + + _dwPort = dwPort; + strcpy(_szCommStr, "\\\\.\\COM"); + ltoa(_dwPort, p, 10); + strcat(_szCommStr, p); + } + //򿪴 + virtual bool OpenCommPort() + { + if (IsOpen()) + Close(); + + _hCommHandle = ::CreateFile(_szCommStr, GENERIC_READ | GENERIC_WRITE, 0, NULL, +OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | _dwIOMode,NULL); + + if (_fAutoBeginThread) + { + if (IsOpen() && BeginThread()) + return true; + else + { + Close(); //߳ʧ + return false; + } + } + return IsOpen(); + } + //ô + virtual bool SetupPort() + { + if (!IsOpen()) + return false; + + if (!::SetupComm(_hCommHandle, 4096, 4096)) + return false; + + if (!::GetCommTimeouts(_hCommHandle, &_CO)) + return false; + _CO.ReadIntervalTimeout = 0; + _CO.ReadTotalTimeoutMultiplier = 1; + _CO.ReadTotalTimeoutConstant = 1000; + _CO.WriteTotalTimeoutMultiplier = 1; + _CO.WriteTotalTimeoutConstant = 1000; + if (!::SetCommTimeouts(_hCommHandle, &_CO)) + return false; + + if (!::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_RXABORT |PURGE_TXCLEAR | PURGE_RXCLEAR)) + return false; + return true; + } + + //---------------------------------------threads callback----------------------------------- + //߳յϢԶ, 細ھЧ, ͳϢ, ڱţ Ϊ麯ڻչ + virtual void OnReceive() //EV_RXCHAR + { + if (::IsWindow(_hNotifyWnd)) + ::PostMessage(_hNotifyWnd, ON_COM_RECEIVE, WPARAM(_dwPort), LPARAM (0)); + } + + virtual void OnDSR() + { + if (::IsWindow(_hNotifyWnd)) + { + DWORD Status; + if (GetCommModemStatus(_hCommHandle, &Status)) + ::PostMessage(_hNotifyWnd, ON_COM_DSR, WPARAM(_dwPort),LPARAM((Status &MS_DSR_ON) ? 1 : 0)); + } + } + + virtual void OnCTS() + { + if (::IsWindow(_hNotifyWnd)) + { + DWORD Status; + if (GetCommModemStatus(_hCommHandle, &Status)) + ::PostMessage(_hNotifyWnd, ON_COM_CTS, WPARAM(_dwPort), LPARAM( (Status &MS_CTS_ON) ? 1 : 0)); + } + } + + virtual void OnBreak() + { + if (::IsWindow(_hNotifyWnd)) + { + ::PostMessage(_hNotifyWnd, ON_COM_BREAK, WPARAM(_dwPort), LPARAM(0)); + } + } + + virtual void OnTXEmpty() + { + if (::IsWindow(_hNotifyWnd)) + ::PostMessage(_hNotifyWnd, ON_COM_TXEMPTY, WPARAM(_dwPort), LPARAM (0)); + } + + virtual void OnError() + { + DWORD dwError; + ::ClearCommError(_hCommHandle, &dwError, NULL); + if (::IsWindow(_hNotifyWnd)) + ::PostMessage(_hNotifyWnd, ON_COM_ERROR, WPARAM(_dwPort), LPARAM (dwError)); + } + + virtual void OnRing() + { + if (::IsWindow(_hNotifyWnd)) + ::PostMessage(_hNotifyWnd, ON_COM_RING, WPARAM(_dwPort), LPARAM(0)); + } + + virtual void OnRLSD() + { + if (::IsWindow(_hNotifyWnd)) + ::PostMessage(_hNotifyWnd, ON_COM_RLSD, WPARAM(_dwPort), LPARAM(0)); + } + + virtual DWORD ThreadFunc() + { + if (!::SetCommMask(_hCommHandle, _dwMaskEvent)) + { + char szBuffer[256]; + _snprintf(szBuffer, 255, +"%s(%d) : COM%d Call WINAPI SetCommMask(%x, %x) Fail, thread work invalid! GetLastError() = %d;", __FILE__, __LINE__, _dwPort, _hCommHandle, _dwMaskEvent, GetLastError()); + MessageBox(NULL, szBuffer, "Class cnComm", MB_OK); + return 1; + } + + COMSTAT Stat; + DWORD dwError; + + for (DWORD dwLength, dwMask = 0; _fRunFlag && IsOpen(); dwMask = 0) + { + if (!::WaitCommEvent(_hCommHandle, &dwMask, &_WaitOverlapped)) + { + if (::GetLastError() == ERROR_IO_PENDING) + // asynchronous + ::GetOverlappedResult(_hCommHandle, &_WaitOverlapped,&dwLength, TRUE); + else + continue; + } + + if (dwMask == 0) + continue; + + switch (dwMask) + { + case EV_RXCHAR: + ::ClearCommError(_hCommHandle, &dwError, &Stat); + if (Stat.cbInQue >= _dwNotifyNum) + OnReceive(); + break; + + case EV_TXEMPTY: + OnTXEmpty(); + break; + + case EV_CTS: + OnCTS(); + break; + + case EV_DSR: + OnDSR(); + break; + + case EV_RING: + OnRing(); + break; + + case EV_RLSD: + OnRLSD(); + break; + + case EV_BREAK: + OnBreak(); + break; + + case EV_ERR: + OnError(); + break; + } //case + } //for + return 0; + } + + private: + //the function protected + + cnComm(const cnComm &); + cnComm &operator = (const cnComm &); + + //base function for thread + static DWORD WINAPI CommThreadProc(LPVOID lpPara) + { + return ((cnComm*)lpPara)->ThreadFunc(); + } + }; +#endif //_CN_COMM_H_ + diff --git a/LaipuDrawing/CommandAddNode.cpp b/LaipuDrawing/CommandAddNode.cpp new file mode 100644 index 0000000..ace1126 --- /dev/null +++ b/LaipuDrawing/CommandAddNode.cpp @@ -0,0 +1,49 @@ +#include "StdAfx.h" +#include "CommandAddNode.h" + + +CCommandAddNode::CCommandAddNode(void) +{ +} + + +CCommandAddNode::~CCommandAddNode(void) +{ +} +void CCommandAddNode::ExcuteExt() +{ + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->InsertNode(m_idx,m_pt); + } + } +} +void CCommandAddNode::UndoExt() +{ + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->DelNodePtByIdx(m_idx); + } + } +} +CString CCommandAddNode::GetStr() +{ + CString str = "_add_node ӽڵ-----"; + return str; +} +void CCommandAddNode::SetPar(int idx,Dbxy pt) +{ + m_idx = idx; + m_pt = pt; +} + diff --git a/LaipuDrawing/CommandAddNode.h b/LaipuDrawing/CommandAddNode.h new file mode 100644 index 0000000..f49e457 --- /dev/null +++ b/LaipuDrawing/CommandAddNode.h @@ -0,0 +1,17 @@ +#pragma once +#include "commandbase.h" +//ӽڵ +class CCommandAddNode :public CCommandBase +{ +public: + CCommandAddNode(void); + ~CCommandAddNode(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); + void SetPar(int idx,Dbxy pt); +private: + int m_idx;//ڵֵ + Dbxy m_pt;//ڵ +}; + diff --git a/LaipuDrawing/CommandArray.cpp b/LaipuDrawing/CommandArray.cpp new file mode 100644 index 0000000..1399c66 --- /dev/null +++ b/LaipuDrawing/CommandArray.cpp @@ -0,0 +1,47 @@ +#include "StdAfx.h" +#include "CommandArray.h" +#include "Layer.h" +#include "GlobalFunction.h" + + +CCommandArray::CCommandArray(void) +{ +} +CCommandArray::~CCommandArray(void) +{ +} +void CCommandArray::ExcuteExt() +{ + CLayer &layer = gLayer; + //ɾл׼obj + layer.DelObj(m_BaseObjContainer); + //ٵж + layer.AddObject(m_ObjContainer); +} +void CCommandArray::UndoExt() +{ + CLayer &layer = gLayer; + //ɾж + layer.DelObj(m_ObjContainer); + //׼ + layer.AddObject(m_BaseObjContainer); +} +CString CCommandArray::GetStr() +{ + CString str = "_array -----"; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + if(vec.size()>1) + { + CString str1; + str1.Format("%ld",vec.size()); + str +="[] : <"+str1+">"; + } + return str; +}; +//׼obj +void CCommandArray::SaveBaseObj(CObjContainer &ObjContainer) +{ + ObjContainer.AllObjAddToContainer(m_BaseObjContainer,true); +} \ No newline at end of file diff --git a/LaipuDrawing/CommandArray.h b/LaipuDrawing/CommandArray.h new file mode 100644 index 0000000..9587a42 --- /dev/null +++ b/LaipuDrawing/CommandArray.h @@ -0,0 +1,16 @@ +#pragma once +#include "commandbase.h" +class CCommandArray : + public CCommandBase +{ +public: + CCommandArray(void); + ~CCommandArray(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); + void SaveBaseObj(CObjContainer &ObjContainer); +private: + CObjContainer m_BaseObjContainer;//׼ +}; + diff --git a/LaipuDrawing/CommandBase.cpp b/LaipuDrawing/CommandBase.cpp new file mode 100644 index 0000000..9d6d1c9 --- /dev/null +++ b/LaipuDrawing/CommandBase.cpp @@ -0,0 +1,36 @@ +#include "StdAfx.h" +#include "CommandBase.h" +#include "EasyOperationMgr.h" + +CCommandBase::CCommandBase(void) +{ +} +CCommandBase::~CCommandBase(void) +{ +} +//Ӳ +void CCommandBase::AddOpObj(Sptr p) +{ + m_ObjContainer.AddObject(p); +} +void CCommandBase::AddOpObj(CObjBase *p) +{ + //浽ָ + Sptr sPtr(p); + AddOpObj(sPtr); +} +//Ƿв +bool CCommandBase::HasOpObj() +{ + return !m_ObjContainer.Empty(); +} +void CCommandBase::Excute() +{ + ExcuteExt(); + gEasyOperationMgr->Refresh(); +} +void CCommandBase::Undo() +{ + UndoExt(); + gEasyOperationMgr->Refresh(); +} \ No newline at end of file diff --git a/LaipuDrawing/CommandBase.h b/LaipuDrawing/CommandBase.h new file mode 100644 index 0000000..5990c5d --- /dev/null +++ b/LaipuDrawing/CommandBase.h @@ -0,0 +1,25 @@ +#pragma once +#include "GlobalDefine.h" +#include "SmartPtr.h" +#include "ObjContainer.h" +#include "ObjBase.h" + +class CCommandBase +{ +public: + CCommandBase(void); + virtual ~CCommandBase(void); + virtual CString GetStr() = 0; + virtual void ExcuteExt(){}; + virtual void UndoExt(){}; + void Excute(); + void Undo(); + void AddOpObj(CObjBase *p); + void AddOpObj(Sptr); + bool HasOpObj(); + void SetOperatePar(SObjOperatePar par){m_Par = par;}; +protected: + CObjContainer m_ObjContainer;//obj + SObjOperatePar m_Par;// +}; + diff --git a/LaipuDrawing/CommandBreakNode.cpp b/LaipuDrawing/CommandBreakNode.cpp new file mode 100644 index 0000000..1e8c2bf --- /dev/null +++ b/LaipuDrawing/CommandBreakNode.cpp @@ -0,0 +1,67 @@ +#include "StdAfx.h" +#include "CommandBreakNode.h" +#include "Layer.h" +#include "GlobalFunction.h" + + +CCommandBreakNode::CCommandBreakNode(void) +{ +} +CCommandBreakNode::~CCommandBreakNode(void) +{ +} +//һǴ֮ǰobj +void CCommandBreakNode::ExcuteExt() +{ + CLayer &layer = gLayer; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->SetSelected(true); + if((*iter).IsNull()==false) + { + if(iter == vec.begin()) + { + layer.DelObj((*iter)); + } + else + { + layer.AddObject((*iter)); + } + } + } + } +} +void CCommandBreakNode::UndoExt() +{ + CLayer &layer = gLayer; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->SetSelected(true); + if(iter == vec.begin()) + { + layer.AddObject((*iter)); + } + else + { + layer.DelObj((*iter)); + } + + } + } +} +CString CCommandBreakNode::GetStr() +{ + CString str = "_break Ͻڵ-----"; + return str; +} + diff --git a/LaipuDrawing/CommandBreakNode.h b/LaipuDrawing/CommandBreakNode.h new file mode 100644 index 0000000..1bcf795 --- /dev/null +++ b/LaipuDrawing/CommandBreakNode.h @@ -0,0 +1,12 @@ +#pragma once +#include "commandbase.h" +class CCommandBreakNode :public CCommandBase +{ +public: + CCommandBreakNode(void); + ~CCommandBreakNode(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandCopy.cpp b/LaipuDrawing/CommandCopy.cpp new file mode 100644 index 0000000..610d46b --- /dev/null +++ b/LaipuDrawing/CommandCopy.cpp @@ -0,0 +1,37 @@ +#include "StdAfx.h" +#include "CommandCopy.h" +#include "Layer.h" +#include "GlobalFunction.h" + + +CCommandCopy::CCommandCopy(void) +{ +} +CCommandCopy::~CCommandCopy(void) +{ +} +void CCommandCopy::ExcuteExt() +{ + CLayer &layer = gLayer; + layer.AddObject(m_ObjContainer); +} +void CCommandCopy::UndoExt() +{ + CLayer &layer = gLayer; + layer.DelObj(m_ObjContainer); +} +CString CCommandCopy::GetStr() +{ + CString str = "_copy -----"; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + if(vec.size()>1) + { + CString str1; + str1.Format("%ld",vec.size()); + str +="[] : <"+str1+">"; + } + return str; +}; + diff --git a/LaipuDrawing/CommandCopy.h b/LaipuDrawing/CommandCopy.h new file mode 100644 index 0000000..8efab66 --- /dev/null +++ b/LaipuDrawing/CommandCopy.h @@ -0,0 +1,13 @@ +#pragma once +#include "commandbase.h" +class CCommandCopy : + public CCommandBase +{ +public: + CCommandCopy(void); + ~CCommandCopy(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandCreat.cpp b/LaipuDrawing/CommandCreat.cpp new file mode 100644 index 0000000..94d86a4 --- /dev/null +++ b/LaipuDrawing/CommandCreat.cpp @@ -0,0 +1,47 @@ +#include "StdAfx.h" +#include "CommandCreat.h" +#include "Layer.h" +#include "GlobalFunction.h" + + +CCommandCreat::CCommandCreat(void) +{ +} +CCommandCreat::~CCommandCreat(void) +{ +} +CString CCommandCreat::GetStr() +{ + CString str = "_creat -----"; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + str += ((*iter)->GetStr()+" "); + break; + } + } + if(vec.size()>1) + { + CString str1; + str1.Format("%ld",vec.size()); + str +="[] : <"+str1+">"; + } + return str; +}; +void CCommandCreat::ExcuteExt() +{ + CLayer &layer = gLayer; + layer.AddObject(m_ObjContainer); +} +void CCommandCreat::UndoExt() +{ + CLayer &layer = gLayer; + layer.DelObj(m_ObjContainer); + +} + + diff --git a/LaipuDrawing/CommandCreat.h b/LaipuDrawing/CommandCreat.h new file mode 100644 index 0000000..3a8021b --- /dev/null +++ b/LaipuDrawing/CommandCreat.h @@ -0,0 +1,12 @@ +#pragma once +#include "CommandBase.h" +class CCommandCreat :public CCommandBase +{ +public: + CCommandCreat(void); + ~CCommandCreat(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandCut.cpp b/LaipuDrawing/CommandCut.cpp new file mode 100644 index 0000000..9454da0 --- /dev/null +++ b/LaipuDrawing/CommandCut.cpp @@ -0,0 +1,68 @@ +#include "StdAfx.h" +#include "CommandCut.h" +#include "Layer.h" +#include "GlobalFunction.h" + + +CCommandCut::CCommandCut(void) +{ +} +CCommandCut::~CCommandCut(void) +{ +} +//m_ObjContainer ĵһΪеobj +//кobj Ϊ0~2 +void CCommandCut::ExcuteExt() +{ + CLayer &layer = gLayer; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->SetSelected(false); + if((*iter).IsNull()==false) + { + if(iter == vec.begin()) + { + layer.DelObj((*iter)); + } + else + { + layer.AddObject((*iter)); + } + + } + } + } +} +void CCommandCut::UndoExt() +{ + CLayer &layer = gLayer; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + if(iter == vec.begin()) + { + layer.AddObject((*iter)); + } + else + { + layer.DelObj((*iter)); + } + + } + } +} +CString CCommandCut::GetStr() +{ + CString str = "_cut ޼-----"; + return str; +} + diff --git a/LaipuDrawing/CommandCut.h b/LaipuDrawing/CommandCut.h new file mode 100644 index 0000000..a101c5b --- /dev/null +++ b/LaipuDrawing/CommandCut.h @@ -0,0 +1,12 @@ +#pragma once +#include "commandbase.h" +class CCommandCut :public CCommandBase +{ +public: + CCommandCut(void); + ~CCommandCut(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandDelNode.cpp b/LaipuDrawing/CommandDelNode.cpp new file mode 100644 index 0000000..67ffe24 --- /dev/null +++ b/LaipuDrawing/CommandDelNode.cpp @@ -0,0 +1,47 @@ +#include "StdAfx.h" +#include "CommandDelNode.h" + + +CCommandDelNode::CCommandDelNode(void) +{ +} +CCommandDelNode::~CCommandDelNode(void) +{ +} +void CCommandDelNode::ExcuteExt() +{ + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->DelNodePtByIdx(m_idx); + } + } +} +void CCommandDelNode::UndoExt() +{ + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->InsertNode(m_idx,m_pt); + } + } +} +CString CCommandDelNode::GetStr() +{ + CString str = "_del_node ɾڵ-----"; + return str; +} +void CCommandDelNode::SetPar(int idx,Dbxy pt) +{ + m_idx = idx; + m_pt = pt; +} + diff --git a/LaipuDrawing/CommandDelNode.h b/LaipuDrawing/CommandDelNode.h new file mode 100644 index 0000000..c5d441b --- /dev/null +++ b/LaipuDrawing/CommandDelNode.h @@ -0,0 +1,16 @@ +#pragma once +#include "commandbase.h" +class CCommandDelNode :public CCommandBase +{ +public: + CCommandDelNode(void); + ~CCommandDelNode(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); + void SetPar(int idx,Dbxy pt); +private: + int m_idx; + Dbxy m_pt; +}; + diff --git a/LaipuDrawing/CommandDelete.cpp b/LaipuDrawing/CommandDelete.cpp new file mode 100644 index 0000000..ceb5149 --- /dev/null +++ b/LaipuDrawing/CommandDelete.cpp @@ -0,0 +1,38 @@ +#include "StdAfx.h" +#include "CommandDelete.h" +#include "Layer.h" +#include "GlobalFunction.h" + + +CCommandDelete::CCommandDelete(void) +{ +} + +CCommandDelete::~CCommandDelete(void) +{ +} + +void CCommandDelete::ExcuteExt() +{ + CLayer &layer = gLayer; + layer.DelObj(m_ObjContainer); + +} +void CCommandDelete::UndoExt() +{ + CLayer &layer = gLayer; + layer.AddObject(m_ObjContainer); +} +CString CCommandDelete::GetStr() +{ + CString str = "_erase ɾ-----"; + vector> &vec = m_ObjContainer.GetObjVec(); + if(vec.empty()==false) + { + CString str1; + str1.Format("%ld",vec.size()); + str +="[] : <"+str1+">"; + } + return str; +} + diff --git a/LaipuDrawing/CommandDelete.h b/LaipuDrawing/CommandDelete.h new file mode 100644 index 0000000..305646c --- /dev/null +++ b/LaipuDrawing/CommandDelete.h @@ -0,0 +1,12 @@ +#pragma once +#include "CommandBase.h" +class CCommandDelete :public CCommandBase +{ +public: + CCommandDelete(void); + ~CCommandDelete(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandJion.cpp b/LaipuDrawing/CommandJion.cpp new file mode 100644 index 0000000..9a79999 --- /dev/null +++ b/LaipuDrawing/CommandJion.cpp @@ -0,0 +1,68 @@ +#include "StdAfx.h" +#include "CommandJion.h" +#include "Layer.h" +#include "GlobalFunction.h" + + +CCommandJion::CCommandJion(void) +{ +} +CCommandJion::~CCommandJion(void) +{ +} +//һǺϲobj +void CCommandJion::ExcuteExt() +{ + CLayer &layer = gLayer; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->SetSelected(true); + if((*iter).IsNull()==false) + { + if(iter == vec.end()-1) + { + layer.AddObject((*iter)); + } + else + { + layer.DelObj((*iter)); + } + + } + } + } +} +void CCommandJion::UndoExt() +{ + CLayer &layer = gLayer; + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->SetSelected(true); + if(iter == vec.end()-1) + { + layer.DelObj((*iter)); + } + else + { + layer.AddObject((*iter)); + } + + } + } +} +CString CCommandJion::GetStr() +{ + CString str = "_jion ϲ-----"; + return str; +} + diff --git a/LaipuDrawing/CommandJion.h b/LaipuDrawing/CommandJion.h new file mode 100644 index 0000000..1c45de5 --- /dev/null +++ b/LaipuDrawing/CommandJion.h @@ -0,0 +1,13 @@ +#pragma once +#include "commandbase.h" +//ϲ +class CCommandJion :public CCommandBase +{ +public: + CCommandJion(void); + ~CCommandJion(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandMgr.cpp b/LaipuDrawing/CommandMgr.cpp new file mode 100644 index 0000000..4b628b5 --- /dev/null +++ b/LaipuDrawing/CommandMgr.cpp @@ -0,0 +1,121 @@ +#include "StdAfx.h" +#include "CommandMgr.h" +#include "LogMgr.h" +#include "GlobalFunction.h" + + +#define MAX_UNDO_CNT 100// + +CCommandMgr gCommandMgr; +CCommandMgr::CCommandMgr(void) +{ +} +CCommandMgr::~CCommandMgr(void) +{ + m_UndoQueue.clear(); + m_RedoQueue.clear(); +} +//p ָضIJ +void CCommandMgr::AddUndoCommand(CCommandBase *p) +{ + vector> Vec; + AddUndoCommand(p,Vec); +} +void CCommandMgr::AddUndoCommand(CCommandBase *p,vector> &pMarkObjectVec) +{ + if(p->HasOpObj()==false) + { + //ָ + if(pMarkObjectVec.empty()==false) + { + vector>::iterator iter = pMarkObjectVec.begin(); + vector>::iterator iter_end = pMarkObjectVec.end(); + for(;iter!=iter_end;iter++) + { + p->AddOpObj((*iter)); + } + } + else//ûָͼ뵱ǰѡobj + { + gLayer.GetObjContainer().AddObjToCmd(p,true); + } + } + if(p->HasOpObj()==false)//ûвʱҪָ + { + delete p; + return; + } + gCommandMgr.AddUndoCommandExt(p); +} +//ָ +void CCommandMgr::AddUndoCommandExt(CCommandBase *p) +{ + //------------------------------------־start + CLog log; + log.AddCmdLog(); + log.str = p->GetStr(); + gLogMgr->WriteLog(log); + //------------------------------------־end + //浽ָ + Sptr sPtr(p); + + m_UndoQueue.push_back(sPtr); + if(m_UndoQueue.size()>MAX_UNDO_CNT) + { + m_UndoQueue.pop_front(); + } + //֮ǰredo ȫ + m_RedoQueue.clear(); +} +bool CCommandMgr::HasUndoCmd() +{ + return !m_UndoQueue.empty(); +} +bool CCommandMgr::HasRedoCmd() +{ + return !m_RedoQueue.empty(); +} +void CCommandMgr::Undo() +{ + if(!m_UndoQueue.empty()) + { + Sptr p = m_UndoQueue[m_UndoQueue.size()-1]; + p->Undo(); + m_RedoQueue.push_back(p); + m_UndoQueue.pop_back(); + //------------------------------------־start + CLog log; + log.AddCmdLog(); + { + CString str = p->GetStr(); + log.str = "_undo "+str; + } + gLogMgr->WriteLog(log); + //------------------------------------־end + } +} +void CCommandMgr::Redo() +{ + if(!m_RedoQueue.empty()) + { + Sptr p = m_RedoQueue[m_RedoQueue.size()-1]; + p->Excute(); + m_UndoQueue.push_back(p); + m_RedoQueue.pop_back(); + //------------------------------------־start + CLog log; + log.AddCmdLog(); + { + CString str = p->GetStr(); + log.str = "_redo "+str; + } + gLogMgr->WriteLog(log); + //------------------------------------־end + } +} +//ûسָ״̬ +void CCommandMgr::Reset() +{ + m_UndoQueue.clear(); + m_RedoQueue.clear(); +} \ No newline at end of file diff --git a/LaipuDrawing/CommandMgr.h b/LaipuDrawing/CommandMgr.h new file mode 100644 index 0000000..fabfd37 --- /dev/null +++ b/LaipuDrawing/CommandMgr.h @@ -0,0 +1,25 @@ +#pragma once + +#include "CommandBase.h" +#include "GlobalDefine.h" + +//ָ +class CCommandMgr +{ +public: + CCommandMgr(void); + ~CCommandMgr(void); + void AddUndoCommand(CCommandBase *p); + void AddUndoCommand(CCommandBase *p,vector> &pMarkObjectVec); + void AddUndoCommandExt(CCommandBase *p); + bool HasUndoCmd(); + bool HasRedoCmd(); + void Undo(); + void Redo(); + void Reset(); +private: + deque> m_UndoQueue; + deque> m_RedoQueue; +}; + +extern CCommandMgr gCommandMgr; \ No newline at end of file diff --git a/LaipuDrawing/CommandMirror.cpp b/LaipuDrawing/CommandMirror.cpp new file mode 100644 index 0000000..3448562 --- /dev/null +++ b/LaipuDrawing/CommandMirror.cpp @@ -0,0 +1,19 @@ +#include "StdAfx.h" +#include "CommandMirror.h" + + +CCommandMirror::CCommandMirror(void) +{ +} +CCommandMirror::~CCommandMirror(void) +{ +} +void CCommandMirror::ExcuteExt() +{ + m_ObjContainer.OperateObj(m_Par,false); +} +void CCommandMirror::UndoExt() +{ + m_ObjContainer.OperateObj(m_Par,false); +} + diff --git a/LaipuDrawing/CommandMirror.h b/LaipuDrawing/CommandMirror.h new file mode 100644 index 0000000..4068314 --- /dev/null +++ b/LaipuDrawing/CommandMirror.h @@ -0,0 +1,12 @@ +#pragma once +#include "CommandBase.h" +class CCommandMirror :public CCommandBase +{ +public: + CCommandMirror(void); + ~CCommandMirror(void); + virtual CString GetStr(){return "";}; + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandModifiCircle.cpp b/LaipuDrawing/CommandModifiCircle.cpp new file mode 100644 index 0000000..29c160b --- /dev/null +++ b/LaipuDrawing/CommandModifiCircle.cpp @@ -0,0 +1,48 @@ +#include "StdAfx.h" +#include "CommandModifiCircle.h" +#include "ObjCircle.h" + +CCommandModifiCircle::CCommandModifiCircle(void) +{ +} +CCommandModifiCircle::~CCommandModifiCircle(void) +{ +} +//b Ϊtrue ʱþɲ +void CCommandModifiCircle::SetPar(double Radius,int EdgeCnt,bool b) +{ + if(b) + { + m_OldRadius = Radius;//뾶 + m_OldEdgeCnt = EdgeCnt;// + } + else + { + m_Radius = Radius;//뾶 + m_EdgeCnt = EdgeCnt;// + } +} +void CCommandModifiCircle::ExcuteExt() +{ + ReCreatObj(true); +} +void CCommandModifiCircle::UndoExt() +{ + ReCreatObj(false); +} +void CCommandModifiCircle::ReCreatObj(bool bExcute) +{ + CObjBase *pBase = m_ObjContainer.GetCurOpObj(); + if(pBase) + { + CObjCircle *p = dynamic_cast(pBase); + if(bExcute) + { + p->ReCreat(m_Radius,m_EdgeCnt); + } + else + { + p->ReCreat(m_OldRadius,m_OldEdgeCnt); + } + } +} \ No newline at end of file diff --git a/LaipuDrawing/CommandModifiCircle.h b/LaipuDrawing/CommandModifiCircle.h new file mode 100644 index 0000000..5790a87 --- /dev/null +++ b/LaipuDrawing/CommandModifiCircle.h @@ -0,0 +1,24 @@ +#pragma once +#include "commandbase.h" + +//޸Բ +class CCommandModifiCircle : + public CCommandBase +{ +public: + CCommandModifiCircle(void); + ~CCommandModifiCircle(void); + virtual CString GetStr(){return "޸circle";}; + virtual void ExcuteExt(); + virtual void UndoExt(); + void SetPar(double Radius,int EdgeCnt,bool b); +private: + void ReCreatObj(bool bExcute); +private: + double m_OldRadius;//뾶 + int m_OldEdgeCnt;// + + double m_Radius;//뾶 + int m_EdgeCnt;// +}; + diff --git a/LaipuDrawing/CommandModifiFill.cpp b/LaipuDrawing/CommandModifiFill.cpp new file mode 100644 index 0000000..e887211 --- /dev/null +++ b/LaipuDrawing/CommandModifiFill.cpp @@ -0,0 +1,31 @@ +#include "StdAfx.h" +#include "CommandModifiFill.h" + +CCommandModifiFill::CCommandModifiFill(void) +{ +} + + +CCommandModifiFill::~CCommandModifiFill(void) +{ +} +//b Ϊtrue ʱþɲ +void CCommandModifiFill::SetPar(SFillPar par,bool b) +{ + if(b) + { + m_OldPar = par; + } + else + { + m_NewPar = par; + } +} +void CCommandModifiFill::ExcuteExt() +{ + m_ObjContainer.FillObj(m_NewPar,false); +} +void CCommandModifiFill::UndoExt() +{ + m_ObjContainer.FillObj(m_OldPar,false); +} \ No newline at end of file diff --git a/LaipuDrawing/CommandModifiFill.h b/LaipuDrawing/CommandModifiFill.h new file mode 100644 index 0000000..e1db87c --- /dev/null +++ b/LaipuDrawing/CommandModifiFill.h @@ -0,0 +1,20 @@ +#pragma once +#include "commandbase.h" +#include "SFillPar.h" + +// +class CCommandModifiFill :public CCommandBase +{ +public: + CCommandModifiFill(void); + ~CCommandModifiFill(void); + virtual CString GetStr(){return "޸fill";}; + virtual void ExcuteExt(); + virtual void UndoExt(); + void SetPar(SFillPar par,bool b); +private: + // + SFillPar m_OldPar; + SFillPar m_NewPar; +}; + diff --git a/LaipuDrawing/CommandModifiFont.cpp b/LaipuDrawing/CommandModifiFont.cpp new file mode 100644 index 0000000..b4dc9a4 --- /dev/null +++ b/LaipuDrawing/CommandModifiFont.cpp @@ -0,0 +1,49 @@ +#include "StdAfx.h" +#include "CommandModifiFont.h" +#include "ObjTxt.h" + +CCommandModifiFont::CCommandModifiFont(void) +{ +} + + +CCommandModifiFont::~CCommandModifiFont(void) +{ +} +//b Ϊtrue ʱþɲ +void CCommandModifiFont::SetStringPar(SFontPar &par,bool b) +{ + if(b) + { + m_OldFontPar = par; + } + else + { + m_NewFontPar = par; + } +} +void CCommandModifiFont::ExcuteExt() +{ + ReCreatObj(true); +} +void CCommandModifiFont::UndoExt() +{ + ReCreatObj(false); +} +void CCommandModifiFont::ReCreatObj(bool bExcute) +{ + CObjBase *pBase = m_ObjContainer.GetCurOpObj(); + if(pBase) + { + CObjTxt *p = dynamic_cast(pBase); + if(bExcute) + { + p->SetFontPar(m_NewFontPar); + } + else + { + p->SetFontPar(m_OldFontPar); + } + p->Creat(); + } +} \ No newline at end of file diff --git a/LaipuDrawing/CommandModifiFont.h b/LaipuDrawing/CommandModifiFont.h new file mode 100644 index 0000000..9dd1e64 --- /dev/null +++ b/LaipuDrawing/CommandModifiFont.h @@ -0,0 +1,21 @@ +#pragma once +#include "commandbase.h" +#include "SFontPar.h" + +class CCommandModifiFont :public CCommandBase +{ +public: + CCommandModifiFont(void); + ~CCommandModifiFont(void); + virtual CString GetStr(){return "޸font";}; + virtual void ExcuteExt(); + virtual void UndoExt(); + void SetStringPar(SFontPar &par,bool b); +private: + void ReCreatObj(bool bExcute); +private: + // + SFontPar m_OldFontPar; + SFontPar m_NewFontPar; +}; + diff --git a/LaipuDrawing/CommandModifiString.cpp b/LaipuDrawing/CommandModifiString.cpp new file mode 100644 index 0000000..715d48e --- /dev/null +++ b/LaipuDrawing/CommandModifiString.cpp @@ -0,0 +1,55 @@ +#include "StdAfx.h" +#include "CommandModifiString.h" +#include "ObjTxt.h" + +CCommandModifiString::CCommandModifiString() +{ +} +CCommandModifiString::~CCommandModifiString(void) +{ +} +//b Ϊtrue ʱþɲ +void CCommandModifiString::SetStringPar(SStringPar &par,bool b) +{ + if(b) + { + m_OldStringPar.Copy(par); + } + else + { + m_NewStringPar.Copy(par); + } +} +void CCommandModifiString::ExcuteExt() +{ + ReCreatObj(true); +} +void CCommandModifiString::UndoExt() +{ + ReCreatObj(false); +} +void CCommandModifiString::ReCreatObj(bool bExcute) +{ + CObjBase *pBase = m_ObjContainer.GetCurOpObj(); + if(pBase) + { + CObjString *p = dynamic_cast(pBase); + if(bExcute) + { + //ɱı + p->SetValStr(m_NewStringPar.m_ValString); + // + p->SetFontTypeName(m_NewStringPar.m_FontTypeName); + p->SetFontName(m_NewStringPar.m_FontName); + } + else + { + //ɱı + p->SetValStr(m_OldStringPar.m_ValString); + // + p->SetFontTypeName(m_OldStringPar.m_FontTypeName); + p->SetFontName(m_OldStringPar.m_FontName); + } + p->Creat(); + } +} \ No newline at end of file diff --git a/LaipuDrawing/CommandModifiString.h b/LaipuDrawing/CommandModifiString.h new file mode 100644 index 0000000..1025653 --- /dev/null +++ b/LaipuDrawing/CommandModifiString.h @@ -0,0 +1,21 @@ +#pragma once +#include "commandbase.h" +#include "SStringPar.h" + +//޸ĺϳɶ +class CCommandModifiString :public CCommandBase +{ +public: + CCommandModifiString(); + ~CCommandModifiString(void); + virtual CString GetStr(){return "޸string";}; + virtual void ExcuteExt(); + virtual void UndoExt(); + void SetStringPar(SStringPar &par,bool b); +private: + void ReCreatObj(bool bExcute); +private: + SStringPar m_OldStringPar; + SStringPar m_NewStringPar; +}; + diff --git a/LaipuDrawing/CommandMove.cpp b/LaipuDrawing/CommandMove.cpp new file mode 100644 index 0000000..72794f2 --- /dev/null +++ b/LaipuDrawing/CommandMove.cpp @@ -0,0 +1,32 @@ +#include "StdAfx.h" +#include "CommandMove.h" + +CCommandMove::CCommandMove(void) +{ +} +CCommandMove::~CCommandMove(void) +{ +} +CString CCommandMove::GetStr() +{ + CString str1 = "CommandMove--------[Dis x ] : <"; + CString str2; + str2.Format("%lf",m_Par.MoveX); + CString str3 = "> [Dis y ] : <"; + CString str4; + str4.Format("%lf",m_Par.MoveY); + CString str5 = ">"; + return str1+str2+str3+str4+str5; +} +void CCommandMove::ExcuteExt() +{ + m_ObjContainer.OperateObj(m_Par,false); +} +void CCommandMove::UndoExt() +{ + //ƶ + SObjOperatePar par = m_Par; + par.MoveX = par.MoveX*(-1); + par.MoveY = par.MoveY*(-1); + m_ObjContainer.OperateObj(par,false); +} diff --git a/LaipuDrawing/CommandMove.h b/LaipuDrawing/CommandMove.h new file mode 100644 index 0000000..2e39972 --- /dev/null +++ b/LaipuDrawing/CommandMove.h @@ -0,0 +1,13 @@ +#pragma once +#include "CommandBase.h" + +class CCommandMove :public CCommandBase +{ +public: + CCommandMove(void); + ~CCommandMove(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandMoveNode.cpp b/LaipuDrawing/CommandMoveNode.cpp new file mode 100644 index 0000000..12c585a --- /dev/null +++ b/LaipuDrawing/CommandMoveNode.cpp @@ -0,0 +1,44 @@ +#include "StdAfx.h" +#include "CommandMoveNode.h" + + +CCommandMoveNode::CCommandMoveNode(void) +{ +} +CCommandMoveNode::~CCommandMoveNode(void) +{ +} +CString CCommandMoveNode::GetStr() +{ + CString str = "_moveNode ƶڵ"; + return str; +} +void CCommandMoveNode::SetPar(int idx,Dbxy OldPt,Dbxy NewPt) +{ + m_NodeIdx = idx;//node ڵֵ + m_OldPt = OldPt;//ɵ + m_NewPt = NewPt;//µ +} +void CCommandMoveNode::ExcuteExt() +{ + SetNode(true); +} +void CCommandMoveNode::UndoExt() +{ + SetNode(false); +} +void CCommandMoveNode::SetNode(bool bExcute) +{ + CObjBase *pBase = m_ObjContainer.GetCurOpObj(); + if(pBase) + { + if(bExcute) + { + pBase->SetNodePtByIdx(m_NodeIdx,m_NewPt); + } + else + { + pBase->SetNodePtByIdx(m_NodeIdx,m_OldPt); + } + } +} \ No newline at end of file diff --git a/LaipuDrawing/CommandMoveNode.h b/LaipuDrawing/CommandMoveNode.h new file mode 100644 index 0000000..83a0a6f --- /dev/null +++ b/LaipuDrawing/CommandMoveNode.h @@ -0,0 +1,19 @@ +#pragma once +#include "commandbase.h" +class CCommandMoveNode :public CCommandBase +{ +public: + CCommandMoveNode(void); + ~CCommandMoveNode(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); + void SetPar(int idx,Dbxy OldPt,Dbxy NewPt); +private: + void SetNode(bool bExcute); +private: + int m_NodeIdx;//node ڵֵ + Dbxy m_OldPt;//ɵ + Dbxy m_NewPt;//µ +}; + diff --git a/LaipuDrawing/CommandReverse.cpp b/LaipuDrawing/CommandReverse.cpp new file mode 100644 index 0000000..1c2e212 --- /dev/null +++ b/LaipuDrawing/CommandReverse.cpp @@ -0,0 +1,45 @@ +#include "StdAfx.h" +#include "CommandReverse.h" +#include "Layer.h" +#include "GlobalFunction.h" + + +CCommandReverse::CCommandReverse(void) +{ +} +CCommandReverse::~CCommandReverse(void) +{ +} +void CCommandReverse::ExcuteExt() +{ + Operater(); +} +void CCommandReverse::UndoExt() +{ + Operater(); +} +CString CCommandReverse::GetStr() +{ + CString str = "_reverse ת˳-----"; + vector> &vec = m_ObjContainer.GetObjVec(); + if(vec.empty()==false) + { + CString str1; + str1.Format("%ld",vec.size()); + str +="[] : <"+str1+">"; + } + return str; +} +void CCommandReverse::Operater() +{ + vector> &vec = m_ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->Operate(m_Par); + } + } +} diff --git a/LaipuDrawing/CommandReverse.h b/LaipuDrawing/CommandReverse.h new file mode 100644 index 0000000..64f3879 --- /dev/null +++ b/LaipuDrawing/CommandReverse.h @@ -0,0 +1,15 @@ +#pragma once +#include "commandbase.h" +//תڵ˳ +class CCommandReverse :public CCommandBase +{ +public: + CCommandReverse(void); + ~CCommandReverse(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +private: + void Operater(); +}; + diff --git a/LaipuDrawing/CommandRotato.cpp b/LaipuDrawing/CommandRotato.cpp new file mode 100644 index 0000000..a7702eb --- /dev/null +++ b/LaipuDrawing/CommandRotato.cpp @@ -0,0 +1,34 @@ +#include "StdAfx.h" +#include "CommandRotato.h" + + +CCommandRotato::CCommandRotato(void) +{ +} +CCommandRotato::~CCommandRotato(void) +{ +} +CString CCommandRotato::GetStr() +{ + CString str1 = "_rotato ת-------- [Ƕ] : <"; + double angle = m_Par.Angle; + if(angle>180) + { + angle = (360-angle)*(-1); + } + CString str2; + str2.Format("%lf",angle); + CString str3 = ">"; + return str1+str2+str3; +} +void CCommandRotato::ExcuteExt() +{ + m_ObjContainer.OperateObj(m_Par,false); +} +void CCommandRotato::UndoExt() +{ + SObjOperatePar par = m_Par; + par.Angle = par.Angle*(-1); + m_ObjContainer.OperateObj(par,false); +} + diff --git a/LaipuDrawing/CommandRotato.h b/LaipuDrawing/CommandRotato.h new file mode 100644 index 0000000..55adc7a --- /dev/null +++ b/LaipuDrawing/CommandRotato.h @@ -0,0 +1,12 @@ +#pragma once +#include "CommandBase.h" +class CCommandRotato :public CCommandBase +{ +public: + CCommandRotato(void); + ~CCommandRotato(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); +}; + diff --git a/LaipuDrawing/CommandStretch.cpp b/LaipuDrawing/CommandStretch.cpp new file mode 100644 index 0000000..d7cbd23 --- /dev/null +++ b/LaipuDrawing/CommandStretch.cpp @@ -0,0 +1,70 @@ +#include "StdAfx.h" +#include "CommandStretch.h" + + +CCommandStretch::CCommandStretch(void) +{ + m_bSetXY = false;//ǷͬʱXY +} +CCommandStretch::~CCommandStretch(void) +{ +} +CString CCommandStretch::GetStr() +{ + CString str1 = "_stretch -------- [] : <"; + CString str2; + if(m_Par.xy == _X) + str2 = "X> [ɳߴ] : <"; + else + str2 = "Y> [ɳߴ] : <"; + CString str3; + str3.Format("%lf",m_Par.OldSize); + CString str4 = "> [³ߴ] : <"; + CString str5; + str5.Format("%lf",m_Par.NewSize); + CString str6 = ">"; + return str1+str2+str3+str4+str5+str6; +}; +void CCommandStretch::SetOperateParY(SObjOperatePar par) +{ + m_bSetXY = true;//ǷͬʱXY + m_ParY = par; +}; +void CCommandStretch::ExcuteExt() +{ + if(m_bSetXY) + { + m_ObjContainer.OperateObj(m_Par,true); + m_ObjContainer.OperateObj(m_ParY,true); + } + else + { + m_ObjContainer.OperateObj(m_Par,true); + } +} +void CCommandStretch::UndoExt() +{ + SObjOperatePar par = m_Par; + par.OpType = _OP_STRETCH; + par.BasePt = m_Par.BasePt; + par.OldSize = m_Par.NewSize; + par.Diff = m_Par.Diff*(-1); + par.xy = m_Par.xy; + + SObjOperatePar parY = m_ParY; + parY.OpType = _OP_STRETCH; + parY.BasePt = m_ParY.BasePt; + parY.OldSize = m_ParY.NewSize; + parY.Diff = m_ParY.Diff*(-1); + parY.xy = m_ParY.xy; + + if(m_bSetXY) + { + m_ObjContainer.OperateObj(par,true); + m_ObjContainer.OperateObj(parY,true); + } + else + { + m_ObjContainer.OperateObj(par,true); + } +} diff --git a/LaipuDrawing/CommandStretch.h b/LaipuDrawing/CommandStretch.h new file mode 100644 index 0000000..8566877 --- /dev/null +++ b/LaipuDrawing/CommandStretch.h @@ -0,0 +1,16 @@ +#pragma once +#include "commandBase.h" +class CCommandStretch :public CCommandBase +{ +public: + CCommandStretch(void); + ~CCommandStretch(void); + virtual CString GetStr(); + virtual void ExcuteExt(); + virtual void UndoExt(); + void SetOperateParY(SObjOperatePar par); +private: + bool m_bSetXY;//ǷͬʱXY + SObjOperatePar m_ParY;// +}; + diff --git a/LaipuDrawing/CommomText.h b/LaipuDrawing/CommomText.h new file mode 100644 index 0000000..cdeb207 --- /dev/null +++ b/LaipuDrawing/CommomText.h @@ -0,0 +1,32 @@ +#pragma once + + +//һЩõַ + + +#define COMMON_TEXT_1 "ǹܱ,ִ֧˲!" +#define COMMON_TEXT_2 "ûù,ִ֧˲!" +#define COMMON_TEXT_3 "ûù˥,ִ֧˲!" +#define COMMON_TEXT_4 "ǰΪֶģʽ!" +#define COMMON_TEXT_5 "ڹλøܹر˥!" +#define COMMON_TEXT_6 "ǰ޷˥!" +#define COMMON_TEXT_7 "豸δʼܴ򿪹բ!" +#define COMMON_TEXT_8 "ƶȫΧ!" +#define COMMON_TEXT_9 "豸δʼ!" +#define COMMON_TEXT_10 "ûжȡĿб!" +#define COMMON_TEXT_11 "Wait AsixXY Stop Over time!" +#define COMMON_TEXT_12 "ݶȡ" +#define COMMON_TEXT_13 "豸״̬δ!" +#define COMMON_TEXT_14 "˻ǰ׼:" + + + + + + + + + + + + diff --git a/LaipuDrawing/CommonFlowMgr.cpp b/LaipuDrawing/CommonFlowMgr.cpp new file mode 100644 index 0000000..514c78b --- /dev/null +++ b/LaipuDrawing/CommonFlowMgr.cpp @@ -0,0 +1,765 @@ +#include "StdAfx.h" +#include "CommonFlowMgr.h" +#include "MsgBox.h" +#include "WorkCmdInvoker.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "LogMgr.h" +#include "CStringFuc.h" +#include "Laser.h" +#include "MarkAreaMgr.h" +#include "ObjComponentMgr.h" +#include "MeasureMgr.h" +#include "ExceptionMsg.h" +#include "FileMgr.h" +#include "DrawSimpleShape.h" +#include "LaiPuLaserView.h" +#include "Layer.h" +#include "ObjContainer.h" +#include "WorkRecord.h" +#include "EncryptionMgr.h" +#include "WorkFileMgr.h" +#include "ProgramLaserTuiHuo.h" +#include "ProgressMgr.h" +#include "WorkCmdTimingProgress.h" +#include "TimingProgressMgr.h" +#include "WaferRecipeDataMgr.h" +#include "CommomText.h" +#include "RecipeMgr.h" +#include "WaferRecipeDataMgr.h" +#include "LaserPowCheckMgr.h" +#include "WorkAreaMgr.h" +#include "ModuleDeviceMgr.h" +#include "CriticalSection.h" + +UINT AutomationWorkFlowStartThread(LPVOID pParam) +{ + CCommonFlowMgr *p = (CCommonFlowMgr *)pParam; + p->StartAutomationWorkFlow(); + return 0; +} + + +#define MAX_AREA_SIZE 10000 //area ķΧֵ +#define NOT_MOVE_Z_COORD 99999 +#define ORG_POS_MAX_ADJUST_VAL 10//ԭλõ + +#define SPOT_METER_LASER_FRE 1000 //ʱĹ̶Ƶ +#define SPOT_METER_LASER_PULSE_DELAY 0 //ʱĹ̶˫ʱ + +CCommonFlowMgr *gCommonFlowMgr = new CCommonFlowMgr; +CCommonFlowMgr::CCommonFlowMgr(void) +{ + m_bIniPlatfrom = true;//Ƿʼƽ̨ + m_bIniConfirmMsgBox = true;//Ƿ񵯳ʼȷ϶Ի + m_bIniMotorZ = false;//ǷʼZ + m_bInitedToProductPt = false;//ʼɺǷ񷵻ϵ + + m_bSetLightState = true;//Ƿþʾ״̬ + m_bConnectObj = true;//ǷӶobj + m_bNeedInit = false;//ǷҪʼܽв + m_bShowErrMsg = true;//ʱԻʾ + + m_bStopWorkMsg = true;//ֹͣťǷʾԻ + m_bShowStartMsg = true;//ڿʼӹʱǷԻʾ + + m_MotorZSafeCoord = 10;//Z İȫλ + m_DrawLineGapCnt = 1;//ÿ߻һ + m_OneLineScanSpeed = 150;//ɨߵٶ + m_TransferTestDelay = 10000;//Ƭʱms + m_OneLineAnnealTimeAdjsut = 150;//߶˻ʱĵ + m_MoveTestDelay = 300;//ƶʱms + m_bXyMoveTesting = false; + m_bLaserSpotMarkMode = false;//ǰǷΪģʽ + m_LightAlamTime = 10;//ʱ + m_bKeepJobN2Air = false;//job ʱһֱִ + m_bCtrlN2Air = true;//ǷƵ(ʱԹر) + + m_bAutomationWorking = false; + m_bStopAutomationWork = false; +} +CCommonFlowMgr::~CCommonFlowMgr(void) +{ +} +CString CCommonFlowMgr::GetParDirName() +{ + CString DirName = _T("CommonFlowMgr"); + return DirName; +} +CMFCPropertyGridProperty * CCommonFlowMgr::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = GetParDirName(); + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T(""); + ModuleName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); + { + { + GroupName = ("ͨ趨"); + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(GroupName); + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + { + //Աӳ + Name = _T("m_bNeedInit");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bNeedInit); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Ҫʼ"); + Description = _T("ǷҪʼܽв"); + + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + pPropertie->SetModuleName(ModuleName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bNeedInit, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_DrawLineGapCnt");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_DrawLineGapCnt); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Ƽ"); + Description = _T("ÿ߻һ,Щ߶ûʾ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_DrawLineGapCnt, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_OneLineAnnealTimeAdjsut");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_OneLineAnnealTimeAdjsut); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Ӽʱ"); + Description = _T("߶˻ʱĵms"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_OneLineAnnealTimeAdjsut, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_bShowStartMsg");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bShowStartMsg); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ӹǰʾ"); + Description = _T("ڿʼӹʱǷԻʾ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bShowStartMsg, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_bShowErrMsg");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bShowErrMsg); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ʱ"); + Description = _T("йзʱԻʾ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bShowErrMsg, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_bStopWorkMsg");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bStopWorkMsg); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ֹͣʾ"); + Description = _T("йеֹͣǷ񵯳Իʾ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bStopWorkMsg, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_LightAlamTime");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_LightAlamTime); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ʱ"); + Description = _T("ʱ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LightAlamTime, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_MotorZSafeCoord");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_MotorZSafeCoord); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Zᰲȫ"); + Description = _T("Zᰲȫ(Σ)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorZSafeCoord, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_TransferTestDelay");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_TransferTestDelay); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Ƭʱ"); + Description = _T("ƬÿƬʱʱms"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_TransferTestDelay, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_MoveTestDelay");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_MoveTestDelay); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ƶʱ"); + Description = _T("ƶʱms"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MoveTestDelay, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bKeepJobN2Air");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bKeepJobN2Air); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Job "); + Description = _T("job ʱһֱִ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bKeepJobN2Air, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_bCtrlN2Air");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bCtrlN2Air); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T(""); + Description = _T("ǷƵ(ʱԹر)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCtrlN2Air, Description); + pGroup1->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + } + { + GroupName = ("豸ʼ"); + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("豸ʼ")); + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + { + //Աӳ + Name = _T("m_bIniConfirmMsgBox");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bIniConfirmMsgBox); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ʼmsgbox"); + Description = _T("Ƿ񵯳Իȷ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bIniConfirmMsgBox, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bIniPlatfrom");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bIniPlatfrom); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ʼƽ̨"); + Description = _T("ǷʼXY ƽ̨"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bIniPlatfrom, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bIniMotorZ");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bIniMotorZ); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ʼZ"); + Description = _T("ǷʼZ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bIniMotorZ, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + } + + } + return pGroup; +} +void CCommonFlowMgr::OnAppInitialize() +{ + +} + +void CCommonFlowMgr::Draw(CDC* pDC) +{ + //ƹmark + DrawLaserSpotPt(pDC); + + DrawTestLineVec(pDC); +} +void CCommonFlowMgr::DrawTestLineVec(CDC* pDC) +{ + int size = m_CTestLineVec.size(); + for(int k=0;kGetCatchNodePen(),TestLine.m_pt1,TestLine.m_pt2); + else + DrawLine(pDC,gDraw->GetScanLine(),TestLine.m_pt1,TestLine.m_pt2); + } +} +//ƹmark +void CCommonFlowMgr::DrawLaserSpotPt(CDC* pDC) +{ + if(!m_bLaserSpotMarkMode) + return; + int CenterIdx = 0; + int size = m_LaserSpotPtVec.size(); + for(int k=0;kIsbScanByDirX()) + Size = DbSize(w,h); + else + Size = DbSize(h,w); + + DbRect rect(SpotPt.m_Coord,DbSize(h,w)); + + COLORREF color; + if(SpotPt.m_AdjustZVal==0) + { + color = RGB_RED; + CenterIdx = k; + } + else + { + color = RGB_YELLOW; + } + DrawSolidRect(pDC,color,rect); + //ÿZ ʾ + CString str; + str.Format(_T("%.2f"),SpotPt.m_AdjustZVal); + if(gLaser->IsbScanByDirX()) + { + SpotPt.m_Coord.x -= 0.5; + SpotPt.m_Coord.y += 3; + } + else + { + SpotPt.m_Coord.x += 3; + } + gDraw->DrawTxt(pDC,str,SpotPt.m_Coord); + + int Idx = k+1; + if(CenterIdx>0 && color == RGB_YELLOW) + { + //Idx = (size-k)+(k-CenterIdx); + } + str.Format(_T("%d"),Idx); + if(gLaser->IsbScanByDirX()) + SpotPt.m_Coord.y -= 6; + else + SpotPt.m_Coord.x -= 6; + + gDraw->DrawTxt(pDC,str,SpotPt.m_Coord); + } +} +#if 1 +//豸ʼ״̬ +bool CCommonFlowMgr::CheckDeviceInitState() +{ + + return true; +} +//ʼ豸(ƽ̨,Z ) +bool CCommonFlowMgr::InitDeviceFlow(bool bConfirmMsgBox) +{ + + return true; +} + +#endif +#if 1 +//ʼӹǰͳһ +bool CCommonFlowMgr::CommWorkStart() +{ + //ָɨߵɫ + gWaferRecipeDataMgr->SetbScanEnd(false); + //Ƿʼ豸 + if(!CheckDeviceInitState()) + return false; + //ӹ¼ʼ + gWorkRecordMgr->StartRecord(); + + m_pView->RefreshView(); + return true; +} +//ӹͳһ +void CCommonFlowMgr::CommWorkEnd() +{ + //¼ + gWorkRecordMgr->EndRecord(); +} +#endif +#if 1 +//ƶָλ(MotorZCoord ƶZ ) +bool CCommonFlowMgr::MoveToPos(Dbxy MovePt,Dbxy TargetPt,double MotorZCoord) +{ + + return true; +} +//ǰǷڼⰲȫλ +bool CCommonFlowMgr::AtLaserSafePlace(Dbxy PlatformCoord) +{ + + return false; +} +#endif +#if 1 +//ռƶ(˻Ҫʱ) +//ABCDEFձʼԭͼ +int CCommonFlowMgr::CollectMultiMovePoint() +{ + + return 1; +} +#endif +#if 1 +//رռ +void CCommonFlowMgr::CloseLaserLddFlow() +{ + +} +#endif +#if 1 +//ֶƶƽ̨ +void CCommonFlowMgr::ManualMoveAsixXY(double MoveDis,DIRECTION MoveDir) +{ + +} +//ֶƶZ +void CCommonFlowMgr::ManualMoveAsixZ(double dis) +{ + +} +//ֶȡwafer (//ƿ) +void CCommonFlowMgr::ManualCtrlPlatWaferFlow(bool bWaferOn) +{ + +} +#endif +#if 1 +//òƽȲ +void CCommonFlowMgr::PlanenessMeasureFlow() +{ + +} + +//XY ˶ +void CCommonFlowMgr::XyMoveTestFlow() +{ + +} +//˶Զ +void CCommonFlowMgr::OpenMoveTestObj() +{ + +} +//¼ +void CCommonFlowMgr::XYMoveSaveCoord() +{ + +} +//ӡ˶Խ +void CCommonFlowMgr::CalXYMoveTestResult(int MeasurePtCnt) +{ + +} +//ʼб +void CCommonFlowMgr::InitMoveRetList(CListCtrl &List) +{ + +} +//б +void CCommonFlowMgr::InsertMoveRetList(CListCtrl &List) +{ + +} +void CCommonFlowMgr::InsertMoveRetListExt(CListCtrl &List,int Line,int Idx,CMovePtData &MovePtData,X_OR_Y Xy) +{ + +} +#endif +#if 1 +//׼cmd +void CCommonFlowMgr::CreatPowCheckPrepareCmd(CWorkCmdInvoker &WorkCmdInvoker) +{ + +} +//⹦ʵ(LDD,˫̹ʱֻһ·Ϊ0) +bool CCommonFlowMgr::LaserPowCheckFlow() +{ + return true; +} +#endif +#if 1 +//ԶУ׼ָ(bToLaserFocusʾɺǷصλ) +void CCommonFlowMgr::CreatAutoFindFocusInvokerCmd(CWorkCmdInvoker &WorkCmdInvoker,bool bToLaserFocus) +{ + +} +//ԶZ ό +void CCommonFlowMgr::AutoFindFocusFlow() +{ + +} +#endif + +#if 1//߹ +void CCommonFlowMgr::SetbLaserSpotMarkMode(bool b) +{ + +} +//ݵ +void CCommonFlowMgr::CreatLaserSpotMarkPt() +{ + +} +//ݰȫ +bool CCommonFlowMgr::CheckLaserSpotData() +{ + + return true; +} +// +void CCommonFlowMgr::LaserSpotMarkFlow() +{ + +} +#endif +#if 1 +//߶ɨtest(ҽ) +void CCommonFlowMgr::OneLineLaserTest() +{ + +} +//ɨ赥߶ +void CCommonFlowMgr::OneLineLaserTestExt(Dbxy Pt1,Dbxy Pt2) +{ + +} +#endif + +#if 1 +// +void CCommonFlowMgr::CollectMultiPointVecToFile() +{ + +} +#endif +#if 1 +// +bool CCommonFlowMgr::CheckLaserBeamFlow() +{ + return true; +} +//ƶʲλõ(ֻƶXYZ) +bool CCommonFlowMgr::MoveToPowMeasureFlow() +{ + return true; +} +//ͨ⹦жϵǰܶȺrecipe Ƿƥ +//ԶĻ,ֻLaser1Curr ĵֵ +bool CCommonFlowMgr::CheckRecipeEnergyDensityFlow(double Laser1Curr) +{ + return true; +} + +#endif + +#if 1//µִ +//ָ׵ +bool CCommonFlowMgr::ExcuteSimpleFlowType(eExcuteFlowType FlowType) +{ + return true; +} +#endif +#if 1//job +void CCommonFlowMgr::JobQueueCtrlFlow() +{ + +} +//ͣjob cmd +void CCommonFlowMgr::PauseJobQueueCtrlFlow() +{ + +} +//ֹͣjob cmd +void CCommonFlowMgr::StopJobQueueCtrlFlow() +{ + +} +#endif + +#if 1 + +//ֶWafer +bool CCommonFlowMgr::ManualTransferWaferFlow() +{ + + return true; +} + +void CCommonFlowMgr::StartAutomationWorkFlowThread() +{ + +} + + +//Զ +void CCommonFlowMgr::StartAutomationWorkFlow() +{ + +} +//ֹͣԶ +void CCommonFlowMgr::StopAutomationWorkFlow() +{ + +} +#endif diff --git a/LaipuDrawing/CommonFlowMgr.h b/LaipuDrawing/CommonFlowMgr.h new file mode 100644 index 0000000..823db42 --- /dev/null +++ b/LaipuDrawing/CommonFlowMgr.h @@ -0,0 +1,229 @@ +#pragma once +#include "module.h" +#include "WorkCmdContainer.h" +#include "EnumDirection.h" +#include "WorkCmdInvoker.h" + +//ִָ +enum eExcuteFlowType +{ + _ExcuteFlow_Null = 0, + _ExcuteFlow_Foup_LoadMap_Port1, + _ExcuteFlow_Foup_LoadMap_Port2, + _ExcuteFlow_Foup_Unload_Port1, + _ExcuteFlow_Foup_Unload_Port2, + _ExcuteFlow_Manual_Anneal_Start,//ֶ˻ +}; + + +//߲Բ +class CLaserSpotMarkPar +{ +public: + CLaserSpotMarkPar(void) + { + m_SpotGap = 2;//ߵX mm + m_SpotOffsetZ = 0.1;//ߵZ mm + m_SpotCntZ = 30;// + m_SpotCntF = 30;// + m_SpotMarkDelay = 2;//ÿ㿪ʱms + }; +public: + double m_SpotGap;//ߵX mm + double m_SpotOffsetZ;//ߵZ mm + int m_SpotCntZ;// + int m_SpotCntF;// + int m_SpotMarkDelay;//ÿ㿪ʱs +}; + +class CLaserSpotPt +{ +public: + CLaserSpotPt(void) + { + m_AdjustZVal = 0;//Zֵ + }; +public: + Dbxy m_Coord; + double m_AdjustZVal;//Zֵ +}; + +//XY ˶Բ +class CXyMoveTestPar +{ +public: + CXyMoveTestPar(void) + { + m_CycleTimes = 10;//ѭ + m_MoveSpeed = 200;// ƶٶX + }; +public: + int m_CycleTimes;//ѭ + double m_MoveSpeed;// ƶٶ +}; +//˶ƶ +class CMovePtData +{ +public: + CMovePtData(void) + { + + }; +public: + Dbxy m_MaxCoord;//ֵ + Dbxy m_MinCoord;//Сֵ + Dbxy m_AvgCoord;//ƽֵ + vector m_PtVec;// +}; + +class CTestLine +{ +public: + CTestLine(void) + { + + }; +public: + + Dbxy m_pt1; + Dbxy m_pt2; +}; + +// +class CCommonFlowMgr :public CModule +{ +public: + CCommonFlowMgr(void); + ~CCommonFlowMgr(void); + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual MODULE GetModuleType(){return _COMMON_FLOW_PROP;}; + virtual void OnAppInitialize(); + virtual void Draw(CDC* pDC); + virtual CString GetParDirName(); + + bool InitDeviceFlow(bool bConfirmMsgBox); + bool IsbConnectObj(){return m_bConnectObj;}; + bool IsbShowErrMsg(){return m_bShowErrMsg;}; + bool IsbStopWorkMsg(){return m_bStopWorkMsg;}; + bool IsbShowStartMsg(){return m_bShowStartMsg;}; + void SetErrMsg(CString s){m_ErrMsg = s;}; + CString GetErrMsg(){return m_ErrMsg;}; + bool MoveToPos(Dbxy MovePt,Dbxy TargetPt,double MotorZCoord); + bool CheckDeviceInitState(); + double GetOneLineScanSpeed(){return m_OneLineScanSpeed;}; + void SetOneLineScanSpeed(double val){m_OneLineScanSpeed = val;}; + + + void OneLineLaserTest(); + + bool AtLaserSafePlace(Dbxy PlatformCoord); + void ManualMoveAsixXY(double MoveDis,DIRECTION MoveDir); + void ManualMoveAsixZ(double dis); + CXyMoveTestPar GetCurXyMoveTestPar(){return m_CurXyMoveTestPar;}; + void SetCurXyMoveTestPar(CXyMoveTestPar par){m_CurXyMoveTestPar = par;}; + void XyMoveTestFlow(); + bool IsbXyMoveTesting(){return m_bXyMoveTesting;}; + void XYMoveSaveCoord(); + void OpenMoveTestObj(); + void InitMoveRetList(CListCtrl &List); + void InsertMoveRetList(CListCtrl &List); + + bool LaserPowCheckFlow(); + CLaserSpotMarkPar GetLaserSpotMarkPar(){return m_LaserSpotMarkPar;}; + void SetLaserSpotMarkPar(CLaserSpotMarkPar par){m_LaserSpotMarkPar = par;}; + void CreatLaserSpotMarkPt(); + void LaserSpotMarkFlow(); + void SetbLaserSpotMarkMode(bool b); + bool IsbLaserSpotMarkMode(){return m_bLaserSpotMarkMode;}; + bool IsbIniMotorZ(){return m_bIniMotorZ;}; + bool IsbIniPlatfrom(){return m_bIniPlatfrom;}; + int GetLightAlamTime(){return m_LightAlamTime;}; + int CollectMultiMovePoint(); + void CollectMultiPointVecToFile(); + void PlanenessMeasureFlow(); + bool CheckLaserBeamFlow(); + bool CheckRecipeEnergyDensityFlow(double Laser1Curr); + bool MoveToPowMeasureFlow(); + bool IsbKeepJobN2Air(){return m_bKeepJobN2Air;}; + + bool ManualTransferWaferFlow(); + void JobQueueCtrlFlow(); + void PauseJobQueueCtrlFlow(); + void StopJobQueueCtrlFlow(); + bool ExcuteSimpleFlowType(eExcuteFlowType FlowType); + void AutoFindFocusFlow(); + void ManualCtrlPlatWaferFlow(bool bWaferOn); + void CloseLaserLddFlow(); + + bool IsbAutomationWorking(){return m_bAutomationWorking;}; + bool IsbStopAutomationWork(){return m_bStopAutomationWork;}; + void StartAutomationWorkFlowThread(); + void StartAutomationWorkFlow(); + void StopAutomationWorkFlow(); +private: + + bool CommWorkStart(); + void CommWorkEnd(); + void CreatAnnealScanCmd(CWorkCmdInvoker &CmdInvoker); + + void InsertMoveRetListExt(CListCtrl &List,int line,int Idx,CMovePtData &MovePtData,X_OR_Y Xy); + void OneLineLaserTestExt(Dbxy Pt1,Dbxy Pt2); + void CalXYMoveTestResult(int MeasurePtCnt); + bool LaserPowCheckFlowExt(); + void DrawLaserSpotPt(CDC* pDC); + bool CheckLaserSpotData(); + void DrawTestLineVec(CDC* pDC); + void CreatAutoFindFocusInvokerCmd(CWorkCmdInvoker &WorkCmdInvoker,bool bToLaserFocus); + void CreatPowCheckPrepareCmd(CWorkCmdInvoker &CmdInvoker); + +private: + //ͨ趨 + bool m_bNeedInit;//ǷҪʼܽв + bool m_bShowStartMsg;//ڿʼӹʱǷԻʾ + bool m_bShowErrMsg;//ʱԻʾ + + CString m_ErrMsg;//Ϣ + + bool m_bStopWorkMsg;//ֹͣťǷʾԻ + + double m_OneLineScanSpeed;//ɨߵٶ + //ʼز----------------------------------------------------- + bool m_bIniConfirmMsgBox;//Ƿ񵯳ʼȷ϶Ի + bool m_bIniPlatfrom;//Ƿʼƽ̨ + bool m_bIniMotorZ;//ǷʼZ + bool m_bInitedToProductPt;//ʼɺǷ񷵻ϵ + + bool m_bConnectObj;//ǷӶobj + bool m_bSetLightState;//Ƿþʾ״̬ + + double m_MotorZSafeCoord;//Z İȫλ(ֵ) + int m_CurDrawLineCnt;//ǰƵ߶μ + int m_DrawLineGapCnt;//ÿ߻һ(ֵ) + int m_TransferTestDelay;//Ƭʱms + + int m_OneLineAnnealTimeAdjsut;//߶˻ʱĵms + + + CXyMoveTestPar m_CurXyMoveTestPar;//ǰXY ˶Բ + bool m_bXyMoveTesting;//ǷXY ƶ + int m_MoveTestDelay;//ƶʱms + vector m_XyMoveTestVec;//ƶ + vector m_MovePtDataVec;// + + + bool m_bLaserSpotMarkMode;//ǰǷΪģʽ + vector m_LaserSpotPtVec;//ߵ + CLaserSpotMarkPar m_LaserSpotMarkPar;//ߵIJ + + int m_LightAlamTime;//ʱ + + vector m_CTestLineVec; + bool m_bKeepJobN2Air;//job ʱһֱִ + bool m_bCtrlN2Air;//ǷƵ(ʱԹر) + + + bool m_bAutomationWorking;//ǷԶ + bool m_bStopAutomationWork;//ֹͣԶ +}; + +extern CCommonFlowMgr *gCommonFlowMgr; diff --git a/LaipuDrawing/CommonParaMgr.cpp b/LaipuDrawing/CommonParaMgr.cpp new file mode 100644 index 0000000..a5c31a0 --- /dev/null +++ b/LaipuDrawing/CommonParaMgr.cpp @@ -0,0 +1,69 @@ +#include "StdAfx.h" +#include "CommonParaMgr.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "CStringFuc.h" + +#define COMM_PARA_FILE _T("\\CommPar\\CommPara.bin") + +CCommonParaMgr *gCommonParaMgr = new CCommonParaMgr; + +CCommonParaMgr::CCommonParaMgr(void) +{ +} +CCommonParaMgr::~CCommonParaMgr(void) +{ +} +//ʱ +void CCommonParaMgr::OnAppInitialize() +{ + //ļжȡòֵ + ReadCommonParaFile(); +} +//ļжȡòֵ +void CCommonParaMgr::ReadCommonParaFile() +{ + gLogMgr->WriteDebugLog("Func--->ReadCommonParaFile"); + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,COMM_PARA_FILE);//ļ· + vector> StrVec; + FileMgr.ReadFileToStrVec(FilePath,StrVec); + + m_CommonParaVec.clear(); + int size = StrVec.size(); + for(int k=0;kWriteDebugLog(log); + } + } +} +//ֻͨȡֵ +double CCommonParaMgr::GetCommonParaVal(CString ParName) +{ + int size = m_CommonParaVec.size(); + for(int k=0;kWriteDebugLog(log); + return 0; +} \ No newline at end of file diff --git a/LaipuDrawing/CommonParaMgr.h b/LaipuDrawing/CommonParaMgr.h new file mode 100644 index 0000000..f5589a8 --- /dev/null +++ b/LaipuDrawing/CommonParaMgr.h @@ -0,0 +1,34 @@ +#pragma once +#include "module.h" + + +class CCommonPara +{ +public: + CCommonPara(void) + { + m_ParaVal = 0; + }; +public: + CString m_ParaName; + double m_ParaVal; +}; + + +//ò +class CCommonParaMgr:public CModule +{ +public: + CCommonParaMgr(void); + ~CCommonParaMgr(void); + virtual void OnAppInitialize();//ʱ + + double GetCommonParaVal(CString ParName); + +private: + void ReadCommonParaFile(); +private: + vector m_CommonParaVec; +}; + +extern CCommonParaMgr *gCommonParaMgr; \ No newline at end of file diff --git a/LaipuDrawing/CriticalSection.cpp b/LaipuDrawing/CriticalSection.cpp new file mode 100644 index 0000000..762e675 --- /dev/null +++ b/LaipuDrawing/CriticalSection.cpp @@ -0,0 +1,28 @@ +#include "StdAfx.h" +#include "CriticalSection.h" + +//עʹٽʱ,Unlock ֮ǰ׳쳣,ٽ + +CCriticalSection gCriticalSection_LaserDevice;//߳ٽ +CCriticalSection gCriticalSection_RedLaserDevice;//߳ٽ +CCriticalSection gCriticalSection_WarningMsg;//Ϣ߳ٽ + +CCriticalSection gCriticalSection_Secs;//Secs ͨ߳ٽ +CCriticalSection gCriticalSection_TransferArm;//еͨ߳ٽ +CCriticalSection gCriticalSection_PlcComm;//PLC ͨٽ + +CCriticalSection gCriticalSection_CassetteToAligner;//CassetteToAligner ߳ٽ + +CCriticalSection gCriticalSection_MonitoringOnAnnealProcess;//˻̼ٽ + +CCriticalSection gCriticalSection_WorkCmdInvoker;//cmd ٽ +CCriticalSection gCriticalSection_JobQueue;//JobQueue ٽ +CCriticalSection gCriticalSection_SendLog;//ڷ־ٽ + +CCriticalSection gCriticalSection_AutomationWork; +CCriticalSection gCriticalSection_TransferWaferInfo; +CCriticalSection gCriticalSection_ViewInvalidate; + + + + diff --git a/LaipuDrawing/CriticalSection.h b/LaipuDrawing/CriticalSection.h new file mode 100644 index 0000000..e31d90a --- /dev/null +++ b/LaipuDrawing/CriticalSection.h @@ -0,0 +1,29 @@ + +#pragma once + +extern CCriticalSection gCriticalSection_LaserDevice;//߳ٽ +extern CCriticalSection gCriticalSection_RedLaserDevice;//߳ٽ +extern CCriticalSection gCriticalSection_WarningMsg;//Ϣ߳ٽ +extern CCriticalSection gCriticalSection_Secs;//Secs ͨ߳ٽ +extern CCriticalSection gCriticalSection_TransferArm;//еͨ߳ٽ +extern CCriticalSection gCriticalSection_PlcComm;//PLC ͨٽ +extern CCriticalSection gCriticalSection_CassetteToAligner;//CassetteToAligner ߳ٽ +extern CCriticalSection gCriticalSection_MonitoringOnAnnealProcess;//˻̼ٽ +extern CCriticalSection gCriticalSection_WorkCmdInvoker;//cmd ٽ +extern CCriticalSection gCriticalSection_JobQueue;//JobQueue ٽ +extern CCriticalSection gCriticalSection_SendLog;//ڷ־ٽ + +extern CCriticalSection gCriticalSection_AutomationWork; +extern CCriticalSection gCriticalSection_TransferWaferInfo; +extern CCriticalSection gCriticalSection_ViewInvalidate; + + + + + + + + + + + diff --git a/LaipuDrawing/DataPoint.cpp b/LaipuDrawing/DataPoint.cpp new file mode 100644 index 0000000..ada1a5f --- /dev/null +++ b/LaipuDrawing/DataPoint.cpp @@ -0,0 +1,100 @@ +#include "StdAfx.h" +#include "DataPoint.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" + +CDataPoint::CDataPoint(Dbxy _pt) +{ + m_bIsNode = false;//ǷΪڵ + m_pt = _pt; +} +CDataPoint::CDataPoint() +{ + m_bIsNode = false;//ǷΪڵ +} +CDataPoint::~CDataPoint(void) +{ +} +//ػõĻ +CPoint CDataPoint::GetDevicePt() +{ + return gDraw->Dbxy2CPoint(m_pt); +} +#if 1 +//ݲַ +void CDataPoint::Operate(SObjOperatePar &par) +{ + switch(par.OpType) + { + case _OP_MOVE: + Move(par.MoveX,par.MoveY); + break; + case _OP_MIRROR: + Mirror(par.BasePt,par.xy); + break; + case _OP_ROTATO: + Rotato(par.BasePt,_360ToAngle(par.Angle)); + break; + case _OP_STRETCH: + Stretch(par.BasePt,par.OldSize,par.Diff,par.xy); + break; + default: + break; + } +} +//ƶ +void CDataPoint::Move(double MoveX,double MoveY) +{ + m_pt.x = m_pt.x+MoveX; + m_pt.y = m_pt.y+MoveY; +} +// +//BasePt ׼ +//Size ǰijߴ +//Diff Ǿɳߴ³ߴIJ +void CDataPoint::Stretch(Dbxy BasePt,double Size,double Diff,X_OR_Y xy) +{ + if(Diff == 0) + return; + if(xy == _X) + { + m_pt.x = m_pt.x+Diff*((m_pt.x-BasePt.x)/Size); + } + else + { + m_pt.y = m_pt.y+Diff*((m_pt.y-BasePt.y)/Size); + } +} +//pt Ϊ׼ +void CDataPoint::Mirror(Dbxy pt,X_OR_Y xy) +{ + if(xy == _X) + { + m_pt.x = m_pt.x+(pt.x-m_pt.x)*2; + } + else + { + m_pt.y = m_pt.y+(pt.y-m_pt.y)*2; + } +} +//Angle : Ƚpt : תĵ +void CDataPoint::Rotato(Dbxy pt,double Angle) +{ + m_pt = RotatoPt(m_pt,Angle,pt); +} +#endif +bool CDataPoint::Equal(CDataPoint &pt) +{ + return pt.GetPt().Equal(m_pt); +} + +//ж߶Ƿ +bool DbLine::IsSerialLine(DbLine &line) +{ + if(m_pt1.Equal(line.m_pt1)||m_pt1.Equal(line.m_pt2) + ||m_pt2.Equal(line.m_pt1)||m_pt2.Equal(line.m_pt2)) + { + return true; + } + return false; +} \ No newline at end of file diff --git a/LaipuDrawing/DataPoint.h b/LaipuDrawing/DataPoint.h new file mode 100644 index 0000000..da80967 --- /dev/null +++ b/LaipuDrawing/DataPoint.h @@ -0,0 +1,39 @@ +#pragma once +#include "GlobalDefine.h" + +//ݵĽṹ +class CDataPoint +{ +public: + CDataPoint(Dbxy _pt); + CDataPoint(void); + ~CDataPoint(void); + Dbxy GetPt(){return m_pt;}; + void SetPt(Dbxy pt){m_pt = pt;}; + CPoint GetDevicePt(); + void Operate(SObjOperatePar &par); + bool IsNode(){return m_bIsNode;}; + void SetIsNode(bool bIsNode){m_bIsNode = bIsNode;}; + bool Equal(CDataPoint &pt); +private: + void Move(double MoveX,double MoveY); + void Mirror(Dbxy pt,X_OR_Y xy); + void Rotato(Dbxy pt,double Angle); + void Stretch(Dbxy BasePt,double Size,double MaxStep,X_OR_Y xy); +private: + Dbxy m_pt;//ֵ + bool m_bIsNode;//ǷΪڵ +}; + +class DbLine +{ +public: + DbLine(CDataPoint pt1,CDataPoint pt2):m_pt1(pt1),m_pt2(pt2){}; + ~DbLine(void){}; + bool IsSerialLine(DbLine &line); + Dbxy GetPt1(){return m_pt1.GetPt();}; + Dbxy GetPt2(){return m_pt2.GetPt();}; +public: + CDataPoint m_pt1; + CDataPoint m_pt2; +}; diff --git a/LaipuDrawing/DlgArray.cpp b/LaipuDrawing/DlgArray.cpp new file mode 100644 index 0000000..edadf46 --- /dev/null +++ b/LaipuDrawing/DlgArray.cpp @@ -0,0 +1,207 @@ +// ArrayDlg.cpp : ʵļ +// + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "DlgArray.h" +#include "afxdialogex.h" + + +// CDlgArray Ի + +IMPLEMENT_DYNAMIC(CDlgArray, CDialogEx) + +CDlgArray::CDlgArray(CWnd* pParent /*=NULL*/) + : CDialogEx(CDlgArray::IDD, pParent) +{ +} + +CDlgArray::~CDlgArray() +{ +} + +void CDlgArray::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Text(pDX, IDC_ARRAY_CNT_H,m_ArrayPar.m_ArrayCntH); + DDX_Text(pDX, IDC_ARRAY_CNT_V, m_ArrayPar.m_ArrayCntV); + DDX_Text(pDX, IDC_ARRAY_OFFSET_H, m_ArrayPar.m_ArrayOffsetH); + DDX_Text(pDX, IDC_ARRAY_OFFSET_V, m_ArrayPar.m_ArrayOffsetV); + DDX_Text(pDX, IDC_ARRAY_CNT,m_ArrayPar.m_ArrayCnt); + DDX_Text(pDX, IDC_RADIUS, m_ArrayPar.m_Radius); + DDX_Text(pDX, IDC_GAP_ANGLE, m_ArrayPar.m_GapAngle); + DDX_Text(pDX, IDC_FILL_OFFSET, m_ArrayPar.m_FillOffset); + DDX_Text(pDX, IDC_FIIL_CNT, m_ArrayPar.m_FillCnt); +} + +BEGIN_MESSAGE_MAP(CDlgArray, CDialogEx) + ON_BN_CLICKED(IDOK,OnBnClickedOk) + ON_BN_CLICKED(IDC_RECT, &CDlgArray::OnBnClickedRect) + ON_BN_CLICKED(IDC_CIRCLE, &CDlgArray::OnBnClickedCircle) + ON_BN_CLICKED(IDC_CIRCLE2, &CDlgArray::OnBnClickedCircle2) +END_MESSAGE_MAP() + +BOOL CDlgArray::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + ((CButton *)GetDlgItem(IDC_RECT))->SetCheck(TRUE); + OnBnClickedRect(); + UpdateData(FALSE); + return TRUE; +} + +void CDlgArray::OnBnClickedRect() +{ + m_ArrayPar.m_bRectArray = true; + m_ArrayPar.m_bCircleArray = false; + m_ArrayPar.m_bFillArray = false; + ((CButton *)GetDlgItem(IDC_CIRCLE))->SetCheck(FALSE); + ((CButton *)GetDlgItem(IDC_CIRCLE2))->SetCheck(FALSE); + CWnd *pWnd; + pWnd = GetDlgItem(IDC_STATIC4); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_STATIC5); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_STATIC6); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_STATIC7); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_ARRAY_CNT_H); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_ARRAY_CNT_V); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_ARRAY_OFFSET_H); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_ARRAY_OFFSET_V); + pWnd->ShowWindow(SW_SHOW); + + pWnd = GetDlgItem(IDC_STATIC1); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC2); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC3); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_ARRAY_CNT); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_RADIUS); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_GAP_ANGLE); + pWnd->ShowWindow(SW_HIDE); + + + pWnd = GetDlgItem(IDC_STATIC8); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC9); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_FILL_OFFSET); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_FIIL_CNT); + pWnd->ShowWindow(SW_HIDE); +} +void CDlgArray::OnBnClickedCircle() +{ + m_ArrayPar.m_bRectArray = false; + m_ArrayPar.m_bCircleArray = true; + m_ArrayPar.m_bFillArray = false; + ((CButton *)GetDlgItem(IDC_RECT))->SetCheck(FALSE); + ((CButton *)GetDlgItem(IDC_CIRCLE2))->SetCheck(FALSE); + CWnd *pWnd; + pWnd = GetDlgItem(IDC_ARRAY_CNT_H); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_ARRAY_CNT_V); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_ARRAY_OFFSET_H); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_ARRAY_OFFSET_V); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC4); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC5); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC6); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC7); + pWnd->ShowWindow(SW_HIDE); + + + pWnd = GetDlgItem(IDC_STATIC1); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_STATIC2); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_STATIC3); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_ARRAY_CNT); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_RADIUS); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_GAP_ANGLE); + pWnd->ShowWindow(SW_SHOW); + + pWnd = GetDlgItem(IDC_STATIC8); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC9); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_FILL_OFFSET); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_FIIL_CNT); + pWnd->ShowWindow(SW_HIDE); +} +void CDlgArray::OnBnClickedOk() +{ + UpdateData(TRUE); + //й + CArrayMgr ArrayMgr; + // + ArrayMgr.Creat(m_ArrayPar); + OnOK(); +} + +void CDlgArray::OnBnClickedCircle2() + { + m_ArrayPar.m_bRectArray = false; + m_ArrayPar.m_bCircleArray = false; + m_ArrayPar.m_bFillArray = true; + ((CButton *)GetDlgItem(IDC_RECT))->SetCheck(FALSE); + ((CButton *)GetDlgItem(IDC_CIRCLE))->SetCheck(FALSE); + CWnd *pWnd; + pWnd = GetDlgItem(IDC_ARRAY_CNT_H); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_ARRAY_CNT_V); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_ARRAY_OFFSET_H); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_ARRAY_OFFSET_V); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC4); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC5); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC6); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC7); + pWnd->ShowWindow(SW_HIDE); + + + pWnd = GetDlgItem(IDC_STATIC1); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC2); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_STATIC3); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_ARRAY_CNT); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_RADIUS); + pWnd->ShowWindow(SW_HIDE); + pWnd = GetDlgItem(IDC_GAP_ANGLE); + pWnd->ShowWindow(SW_HIDE); + + pWnd = GetDlgItem(IDC_STATIC8); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_STATIC9); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_FILL_OFFSET); + pWnd->ShowWindow(SW_SHOW); + pWnd = GetDlgItem(IDC_FIIL_CNT); + pWnd->ShowWindow(SW_SHOW); + } + diff --git a/LaipuDrawing/DlgArray.h b/LaipuDrawing/DlgArray.h new file mode 100644 index 0000000..d8928fb --- /dev/null +++ b/LaipuDrawing/DlgArray.h @@ -0,0 +1,28 @@ +#pragma once + +#include "ArrayMgr.h" +// CDlgArray Ի + +class CDlgArray : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgArray) + +public: + CDlgArray(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgArray(); + +// Ի + enum { IDD = IDD_ARRAY_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + afx_msg void OnBnClickedOk(); + DECLARE_MESSAGE_MAP() +private: + SArrayPar m_ArrayPar;//в +public: + afx_msg void OnBnClickedRect(); + afx_msg void OnBnClickedCircle(); + afx_msg void OnBnClickedCircle2(); + +}; diff --git a/LaipuDrawing/DlgAuthorityAccount.cpp b/LaipuDrawing/DlgAuthorityAccount.cpp new file mode 100644 index 0000000..1d3b9b8 --- /dev/null +++ b/LaipuDrawing/DlgAuthorityAccount.cpp @@ -0,0 +1,112 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "DlgAuthorityAccount.h" +#include "afxdialogex.h" +#include "MsgBox.h" +#include "AuthorityMgr.h" +#include "DlgAuthorityCreatAccount.h" +#include "DlgAuthorityPar.h" + +IMPLEMENT_DYNAMIC(CDlgAuthorityAccount, CDialogEx) +CDlgAuthorityAccount::CDlgAuthorityAccount(CWnd* pParent /*=NULL*/) + : CDialogEx(CDlgAuthorityAccount::IDD, pParent) +{ + m_CurSelIdx = -1;//ǰѡ +} +CDlgAuthorityAccount::~CDlgAuthorityAccount() +{ +} +void CDlgAuthorityAccount::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Control(pDX, IDC_USER_LIST, m_UserList); +} +BEGIN_MESSAGE_MAP(CDlgAuthorityAccount, CDialogEx) + + ON_NOTIFY(NM_CLICK, IDC_USER_LIST, &CDlgAuthorityAccount::OnNMClickUserList) + ON_BN_CLICKED(IDC_DEL_SEL, &CDlgAuthorityAccount::OnBnClickedDelSel) + ON_BN_CLICKED(IDC_CREAT, &CDlgAuthorityAccount::OnBnClickedCreatAccount) + ON_BN_CLICKED(IDC_OPEN_AUTH_PAR_DLG, &CDlgAuthorityAccount::OnBnClickedOpenAuthorityDlg) +END_MESSAGE_MAP() + +//ػһּ +BOOL CDlgAuthorityAccount::PreTranslateMessage(MSG* pMsg) +{ + if(pMsg->message==WM_KEYDOWN) + { + char c = pMsg->wParam; + if(c==VK_RETURN || c==VK_ESCAPE) + { + return TRUE; + } + } + return CDialogEx::PreTranslateMessage(pMsg); +} + +BOOL CDlgAuthorityAccount::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + IniUserList(); + UpdateUserList(); + UpdateData(FALSE); + return TRUE; +} +void CDlgAuthorityAccount::IniUserList() +{ + //÷ + m_UserList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + int idx = 0; + m_UserList.InsertColumn(idx,"",LVCFMT_CENTER,120,-1); + idx++; + m_UserList.InsertColumn(idx,"û",LVCFMT_CENTER,150,-1); +} +void CDlgAuthorityAccount::UpdateUserList() +{ + m_UserList.DeleteAllItems(); + gAuthorityMgr->InsertToList(m_UserList); + UpdateData(FALSE); +} +//ȡlist ǰѡк +int CDlgAuthorityAccount::GetCurListIdx(CListCtrl &list) +{ + POSITION pos = list.GetFirstSelectedItemPosition(); + if (pos == NULL) + { + return -1; + } + else + { + while (pos) + { + int nItem = list.GetNextSelectedItem(pos); + return nItem; + } + } + return -1; +} +void CDlgAuthorityAccount::OnNMClickUserList(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast(pNMHDR); + *pResult = 0; + m_CurSelIdx=GetCurListIdx(m_UserList); +} +void CDlgAuthorityAccount::OnBnClickedDelSel() +{ + gAuthorityMgr->DelUser(m_CurSelIdx); + UpdateUserList(); +} +void CDlgAuthorityAccount::OnBnClickedCreatAccount() +{ + CDlgAuthorityCreatAccount dlg; + dlg.DoModal(); + UpdateUserList(); +} +void CDlgAuthorityAccount::OnBnClickedOpenAuthorityDlg() +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_AuthorityEdit",true)) + return; + CDlgAuthorityPar dlg; + dlg.DoModal(); +} \ No newline at end of file diff --git a/LaipuDrawing/DlgAuthorityAccount.h b/LaipuDrawing/DlgAuthorityAccount.h new file mode 100644 index 0000000..ec8985e --- /dev/null +++ b/LaipuDrawing/DlgAuthorityAccount.h @@ -0,0 +1,29 @@ +#pragma once + +//û +class CDlgAuthorityAccount : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgAuthorityAccount) + +public: + CDlgAuthorityAccount(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgAuthorityAccount(); + void IniUserList(); + void UpdateUserList(); + int GetCurListIdx(CListCtrl &list); +// Ի + enum { IDD = IDD_USER_MGR }; +private: + CListCtrl m_UserList; + int m_CurSelIdx;//ǰѡ +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() +public: + afx_msg BOOL PreTranslateMessage(MSG* pMsg); + afx_msg void OnNMClickUserList(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedDelSel(); + afx_msg void OnBnClickedCreatAccount(); + afx_msg void CDlgAuthorityAccount::OnBnClickedOpenAuthorityDlg(); +}; diff --git a/LaipuDrawing/DlgAuthorityCreatAccount.cpp b/LaipuDrawing/DlgAuthorityCreatAccount.cpp new file mode 100644 index 0000000..b1af28d --- /dev/null +++ b/LaipuDrawing/DlgAuthorityCreatAccount.cpp @@ -0,0 +1,93 @@ +// DlgCreatAccount.cpp : ʵļ +// + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "DlgAuthorityCreatAccount.h" +#include "afxdialogex.h" +#include "AuthorityMgr.h" +#include "MsgBox.h" +// CDlgAuthorityCreatAccount Ի + +IMPLEMENT_DYNAMIC(CDlgAuthorityCreatAccount, CDialogEx) + +CDlgAuthorityCreatAccount::CDlgAuthorityCreatAccount(CWnd* pParent /*=NULL*/) + : CDialogEx(CDlgAuthorityCreatAccount::IDD, pParent) +{ + +} + +CDlgAuthorityCreatAccount::~CDlgAuthorityCreatAccount() +{ +} + +void CDlgAuthorityCreatAccount::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Text(pDX, IDC_NAME, m_Name); + DDX_Text(pDX, IDC_PASSWORD, m_PassWord1); + DDX_Text(pDX, IDC_PASSWORD2, m_PassWord2); + DDX_Control(pDX, IDC_AUTHORITY_COMB, m_AuthorityComb); +} + + +BEGIN_MESSAGE_MAP(CDlgAuthorityCreatAccount, CDialogEx) + ON_BN_CLICKED(IDOK, &CDlgAuthorityCreatAccount::OnBnClickedOk) +END_MESSAGE_MAP() + + +// CDlgAuthorityCreatAccount Ϣ +BOOL CDlgAuthorityCreatAccount::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + + IniAuthorityComb(); + + UpdateData(FALSE); + return TRUE; +} +//ʼAuthorityComb +void CDlgAuthorityCreatAccount::IniAuthorityComb() +{ + eAuthorityType CurAuthority = gAuthorityMgr->GetCurAuthority(); + int idx = 0; + m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_Operator)); + m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_OperatorAdmin)); + m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_Engineer)); + m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_Technics)); + if(CurAuthority== _Authority_Factory) + { + m_AuthorityComb.InsertString(idx++,gAuthorityMgr->GetAccountName(_Authority_Factory)); + } + m_AuthorityComb.SetCurSel(0); +} +void CDlgAuthorityCreatAccount::OnBnClickedOk() +{ + eAuthorityType CurAuthority = gAuthorityMgr->GetCurAuthority(); + if(!UpdateData(TRUE)) + return; + if(m_Name=="") + { + CMsgBox MsgBox; + MsgBox.Show("ûΪ!"); + return; + } + if(m_PassWord1=="") + { + CMsgBox MsgBox; + MsgBox.Show("벻Ϊ!"); + return; + } + if(m_PassWord1 != m_PassWord2) + { + CMsgBox MsgBox; + MsgBox.Show("ȷ벻һ!"); + return; + } + CAccount Account; + Account.m_Name = m_Name; + Account.m_PassWord = m_PassWord1; + Account.m_Authority = (eAuthorityType)(m_AuthorityComb.GetCurSel()+1);//Ȩ + gAuthorityMgr->AddAccount(Account); + CDialogEx::OnOK(); +} diff --git a/LaipuDrawing/DlgAuthorityCreatAccount.h b/LaipuDrawing/DlgAuthorityCreatAccount.h new file mode 100644 index 0000000..a2f0c9d --- /dev/null +++ b/LaipuDrawing/DlgAuthorityCreatAccount.h @@ -0,0 +1,29 @@ +#pragma once + + +// CDlgAuthorityCreatAccount Ի + +class CDlgAuthorityCreatAccount : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgAuthorityCreatAccount) + +public: + CDlgAuthorityCreatAccount(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgAuthorityCreatAccount(); + +// Ի + enum { IDD = IDD_AUTHORITY_CREAT_ACCOUNT }; +private: + CString m_Name; + CString m_PassWord1; + CString m_PassWord2; + CComboBox m_AuthorityComb; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() +private: + void IniAuthorityComb(); +public: + afx_msg void OnBnClickedOk(); +}; diff --git a/LaipuDrawing/DlgAuthorityLogin.cpp b/LaipuDrawing/DlgAuthorityLogin.cpp new file mode 100644 index 0000000..418a43c --- /dev/null +++ b/LaipuDrawing/DlgAuthorityLogin.cpp @@ -0,0 +1,119 @@ +// DlgAuthorityMgr->cpp : ʵļ +// + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "DlgAuthorityLogin.h" +#include "afxdialogex.h" + +#include "MsgBox.h" +#include "AuthorityMgr.h" +#include "LogMgr.h" +#include "GlobalFunction.h" + + + +IMPLEMENT_DYNAMIC(CDlgAuthorityLogin, CDialogEx) + +CDlgAuthorityLogin::CDlgAuthorityLogin(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgAuthorityLogin::IDD, pParent) +{ +} +CDlgAuthorityLogin::~CDlgAuthorityLogin() +{ +} +void CDlgAuthorityLogin::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Text(pDX, IDC_NAME, m_Name); + DDX_Text(pDX, IDC_PASSWORD, m_PassWord); + DDX_Control(pDX, NEW_LOGIN_BTN, m_LoginBtn); +} +BEGIN_MESSAGE_MAP(CDlgAuthorityLogin, CDialogEx) + ON_WM_PAINT() + ON_BN_CLICKED(NEW_LOGIN_BTN, &CDlgAuthorityLogin::OnBnClickedLogin) + ON_BN_CLICKED(CHILD_SHOW_WINDOW_MIN_BTN, &CDlgAuthorityLogin::OnBnClickedShowWindowMinBtn) +END_MESSAGE_MAP() + +//ػһּ +BOOL CDlgAuthorityLogin::PreTranslateMessage(MSG* pMsg) +{ + if(pMsg->message==WM_KEYDOWN) + { + char c = pMsg->wParam; + if(c==VK_RETURN || c==VK_ESCAPE) + { + return TRUE; + } + } + return CDialogEx::PreTranslateMessage(pMsg); +} +void CDlgAuthorityLogin::OnCancel() +{ + + return; + //CDialogEx::OnCancel(); +} + +// CDlgAuthorityCreatAccount Ϣ +BOOL CDlgAuthorityLogin::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + + CRect cr; + GetClientRect(&cr); + ClientToScreen(&cr); + //öԻλ + MoveWindow(2 ,0,cr.Width()+20,cr.Height()+20); + + m_LoginBtn.SetUpColor(RGB_GREEN); + + gAuthorityMgr->Lock(); + gAuthorityMgr->SetbLoginDlgOpen(true); + UpdateData(FALSE); + return TRUE; +} +void CDlgAuthorityLogin::OnPaint() +{ + { + // + // ӱ + // + CPaintDC dc(this); + CRect rc; + GetClientRect(&rc); + CDC dcMem; + dcMem.CreateCompatibleDC(&dc); + CBitmap bmpBackground; + bmpBackground.LoadBitmap(IDB_BTN_IMG123); + + BITMAP bitmap; + bmpBackground.GetBitmap(&bitmap); + CBitmap* pOldBitmap = dcMem.SelectObject(&bmpBackground); + dc.StretchBlt(0,0,bitmap.bmWidth,bitmap.bmHeight, &dcMem,0,0,bitmap.bmWidth, bitmap.bmHeight, SRCCOPY); + + dcMem.SelectObject(pOldBitmap); + VERIFY(dcMem.DeleteDC()); + } + +} + +//¼ +void CDlgAuthorityLogin::OnBnClickedLogin() +{ + if(!UpdateData(TRUE)) + return; + if(gAuthorityMgr->Login(m_Name,m_PassWord)) + { + gAuthorityMgr->SetbLoginDlgOpen(false); + OnOK(); + } +} + + + +void CDlgAuthorityLogin::OnBnClickedShowWindowMinBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedShowWindowMinBtn"); + GetFrame()->ShowWindowMin(); +} diff --git a/LaipuDrawing/DlgAuthorityLogin.h b/LaipuDrawing/DlgAuthorityLogin.h new file mode 100644 index 0000000..8b61af8 --- /dev/null +++ b/LaipuDrawing/DlgAuthorityLogin.h @@ -0,0 +1,31 @@ +#pragma once +#include "MyBttom.h" + + +// CDlgAuthorityLogin Ի +//Ȩ޹ +class CDlgAuthorityLogin : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgAuthorityLogin) + +public: + CDlgAuthorityLogin(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgAuthorityLogin(); + virtual void OnCancel(); +// Ի + enum { IDD = IDD_AUTHORITY_LOGIN }; +private: + + CString m_Name; + CString m_PassWord; + CMyBottom m_LoginBtn; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() +public: + afx_msg BOOL PreTranslateMessage(MSG* pMsg); + afx_msg void OnBnClickedLogin(); + afx_msg void OnPaint(); + afx_msg void OnBnClickedShowWindowMinBtn(); +}; diff --git a/LaipuDrawing/DlgAuthorityPar.cpp b/LaipuDrawing/DlgAuthorityPar.cpp new file mode 100644 index 0000000..f44f4e4 --- /dev/null +++ b/LaipuDrawing/DlgAuthorityPar.cpp @@ -0,0 +1,54 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgAuthorityPar.h" +#include "AuthorityMgr.h" + + +IMPLEMENT_DYNAMIC(CDlgAuthorityPar, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgAuthorityPar, CDialogEx) + ON_BN_CLICKED(IDOK,OnBnClickedOk) + ON_CBN_SELCHANGE(IDC_AUTH_TYPE_COMBO, &CDlgAuthorityPar::OnCbnSelchangeAuthTypeCombo) +END_MESSAGE_MAP() + + +CDlgAuthorityPar::CDlgAuthorityPar(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgAuthorityPar::IDD, pParent) +{ + m_CurAuthorityType = 0; +} + +CDlgAuthorityPar::~CDlgAuthorityPar() +{ +} + +void CDlgAuthorityPar::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Control(pDX, NEW_AUTH_PAR_LIST, m_AuthorityParList); + DDX_Control(pDX, IDC_AUTH_TYPE_COMBO, m_AuthorityTypeCombo); +} + +BOOL CDlgAuthorityPar::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + + gAuthorityMgr->InitAuthorityParList(m_AuthorityParList); + gAuthorityMgr->InitAuthorityTypeComb(m_AuthorityTypeCombo); + UpdateData(FALSE); + return TRUE; +} + +void CDlgAuthorityPar::OnBnClickedOk() +{ + gAuthorityMgr->UpdateAuthorityPar(m_AuthorityParList,m_CurAuthorityType); + gAuthorityMgr->SaveAuthorityParaFile(); + OnOK(); +} +void CDlgAuthorityPar::OnCbnSelchangeAuthTypeCombo() +{ + gAuthorityMgr->UpdateAuthorityPar(m_AuthorityParList,m_CurAuthorityType); + m_CurAuthorityType = m_AuthorityTypeCombo.GetCurSel(); + gAuthorityMgr->UpdateAuthorityParList(m_AuthorityParList,m_CurAuthorityType); +} diff --git a/LaipuDrawing/DlgAuthorityPar.h b/LaipuDrawing/DlgAuthorityPar.h new file mode 100644 index 0000000..6dcfc97 --- /dev/null +++ b/LaipuDrawing/DlgAuthorityPar.h @@ -0,0 +1,24 @@ +#pragma once + +class CDlgAuthorityPar : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgAuthorityPar) + +public: + CDlgAuthorityPar(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgAuthorityPar(); + +// Ի + enum { IDD = IDD_AUTHORITY_PAR_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + afx_msg void OnBnClickedOk(); + DECLARE_MESSAGE_MAP() +private: + CListCtrl m_AuthorityParList; + CComboBox m_AuthorityTypeCombo; + int m_CurAuthorityType; +public: + afx_msg void OnCbnSelchangeAuthTypeCombo(); +}; diff --git a/LaipuDrawing/DlgChildAlarmLog.cpp b/LaipuDrawing/DlgChildAlarmLog.cpp new file mode 100644 index 0000000..358ca15 --- /dev/null +++ b/LaipuDrawing/DlgChildAlarmLog.cpp @@ -0,0 +1,288 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildAlarmLog.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "ProgramLaserTuiHuo.h" + + +IMPLEMENT_DYNAMIC(CDlgChildAlarmLog, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildAlarmLog, CMyDlgView) + + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildAlarmLog::OnBnClickedSearchBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildAlarmLog::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildAlarmLog::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildAlarmLog::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildAlarmLog::OnBnClickedSearchByDate) +END_MESSAGE_MAP() + + +#define Data_List_Item_Cnt 20 +CDlgChildAlarmLog::CDlgChildAlarmLog(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildAlarmLog::IDD, pParent) +, m_SelDate(COleDateTime::GetCurrentTime()) +{ + +} + +CDlgChildAlarmLog::~CDlgChildAlarmLog() +{ +} + +void CDlgChildAlarmLog::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList); + DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate); +} + +BOOL CDlgChildAlarmLog::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildAlarmLog::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedSearchBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildAlarmLog::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\AlarmLog\\"); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgChildAlarmLog::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\AlarmLog\\"); + CString DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildAlarmLog::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildAlarmLog::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildAlarmLog::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildAlarmLog::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgChildAlarmLog::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +void CDlgChildAlarmLog::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgChildAlarmLog::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + m_DataList.DeleteAllItems(); + vector> StrVec; + CString log("ReadFile : "); + log += strPath; + gLogMgr->WriteDebugLog(log); + + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + } + *pResult = 0; +} +void CDlgChildAlarmLog::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} + + +void CDlgChildAlarmLog::OnBnClickedSearchByDate() +{ + UpdateData(TRUE); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot,m_SelDate); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + + + diff --git a/LaipuDrawing/DlgChildAlarmLog.h b/LaipuDrawing/DlgChildAlarmLog.h new file mode 100644 index 0000000..8c6c5fc --- /dev/null +++ b/LaipuDrawing/DlgChildAlarmLog.h @@ -0,0 +1,46 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildAlarmLog : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildAlarmLog) + +public: + CDlgChildAlarmLog(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildAlarmLog(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + void UpdateDataList(CString FilePath); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_ALARM_LOG }; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByDate(); + // ǰѡе + COleDateTime m_SelDate; +}; + + diff --git a/LaipuDrawing/DlgChildBeamDataHistory.cpp b/LaipuDrawing/DlgChildBeamDataHistory.cpp new file mode 100644 index 0000000..5e90e46 --- /dev/null +++ b/LaipuDrawing/DlgChildBeamDataHistory.cpp @@ -0,0 +1,289 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildBeamDataHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" + +IMPLEMENT_DYNAMIC(CDlgChildBeamDataHistory, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildBeamDataHistory, CMyDlgView) + + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildBeamDataHistory::OnBnClickedSearchBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildBeamDataHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildBeamDataHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildBeamDataHistory::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildBeamDataHistory::OnBnClickedSearchByDate) +END_MESSAGE_MAP() + +#define Data_List_Item_Cnt 30 +CDlgChildBeamDataHistory::CDlgChildBeamDataHistory(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildBeamDataHistory::IDD, pParent) +, m_SelDate(COleDateTime::GetCurrentTime()) +{ + +} + +CDlgChildBeamDataHistory::~CDlgChildBeamDataHistory() +{ +} + +void CDlgChildBeamDataHistory::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList); + DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate); +} + +BOOL CDlgChildBeamDataHistory::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildBeamDataHistory::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedSearchBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildBeamDataHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\BeamData\\"); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgChildBeamDataHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\BeamData\\"); + CString DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildBeamDataHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildBeamDataHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildBeamDataHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildBeamDataHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgChildBeamDataHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +void CDlgChildBeamDataHistory::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgChildBeamDataHistory::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + m_DataList.DeleteAllItems(); + vector> StrVec; + CString log("ReadFile : "); + log += strPath; + gLogMgr->WriteDebugLog(log); + + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + } + if(strPath.Find(".bmp")!=-1)//ͼ + { + //windowsͼƬ鿴 + PictureWindows(strPath); + } + *pResult = 0; +} +void CDlgChildBeamDataHistory::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} + + +void CDlgChildBeamDataHistory::OnBnClickedSearchByDate() +{ + UpdateData(TRUE); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot,m_SelDate); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + + diff --git a/LaipuDrawing/DlgChildBeamDataHistory.h b/LaipuDrawing/DlgChildBeamDataHistory.h new file mode 100644 index 0000000..565f5fa --- /dev/null +++ b/LaipuDrawing/DlgChildBeamDataHistory.h @@ -0,0 +1,45 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildBeamDataHistory : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildBeamDataHistory) + +public: + CDlgChildBeamDataHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildBeamDataHistory(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + void UpdateDataList(CString FilePath); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_BEAM_HISTORY }; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByDate(); + // ǰѡе + COleDateTime m_SelDate; +}; + diff --git a/LaipuDrawing/DlgChildCheckHistory.cpp b/LaipuDrawing/DlgChildCheckHistory.cpp new file mode 100644 index 0000000..5f97c29 --- /dev/null +++ b/LaipuDrawing/DlgChildCheckHistory.cpp @@ -0,0 +1,282 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildCheckHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" + +IMPLEMENT_DYNAMIC(CDlgChildCheckHistory, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildCheckHistory, CMyDlgView) + + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildCheckHistory::OnBnClickedSearchBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildCheckHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildCheckHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildCheckHistory::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildCheckHistory::OnBnClickedSearchByDate) +END_MESSAGE_MAP() + +#define Data_List_Item_Cnt 20 +CDlgChildCheckHistory::CDlgChildCheckHistory(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildCheckHistory::IDD, pParent) +, m_SelDate(COleDateTime::GetCurrentTime()) +{ + +} + +CDlgChildCheckHistory::~CDlgChildCheckHistory() +{ +} + +void CDlgChildCheckHistory::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList); + DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate); +} + +BOOL CDlgChildCheckHistory::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildCheckHistory::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedSearchBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildCheckHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\CheckData\\"); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgChildCheckHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\CheckData\\"); + CString DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildCheckHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildCheckHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildCheckHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildCheckHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgChildCheckHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +void CDlgChildCheckHistory::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgChildCheckHistory::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + #if 1 + m_DataList.DeleteAllItems(); + vector> StrVec; + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + #endif + } + *pResult = 0; +} +void CDlgChildCheckHistory::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} + + +void CDlgChildCheckHistory::OnBnClickedSearchByDate() +{ + UpdateData(TRUE); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot,m_SelDate); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + + diff --git a/LaipuDrawing/DlgChildCheckHistory.h b/LaipuDrawing/DlgChildCheckHistory.h new file mode 100644 index 0000000..7f96229 --- /dev/null +++ b/LaipuDrawing/DlgChildCheckHistory.h @@ -0,0 +1,45 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildCheckHistory : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildCheckHistory) + +public: + CDlgChildCheckHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildCheckHistory(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + void UpdateDataList(CString FilePath); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_CHECK_HISTORY }; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByDate(); + // ǰѡе + COleDateTime m_SelDate; +}; + diff --git a/LaipuDrawing/DlgChildConfigHistory.cpp b/LaipuDrawing/DlgChildConfigHistory.cpp new file mode 100644 index 0000000..e6dba50 --- /dev/null +++ b/LaipuDrawing/DlgChildConfigHistory.cpp @@ -0,0 +1,288 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildConfigHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" + +IMPLEMENT_DYNAMIC(CDlgChildConfigHistory, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildConfigHistory, CMyDlgView) + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildConfigHistory::OnBnClickedSearchBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildConfigHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildConfigHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildConfigHistory::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildConfigHistory::OnBnClickedSearchByDate) +END_MESSAGE_MAP() + +#define Data_List_Item_Cnt 20 +CDlgChildConfigHistory::CDlgChildConfigHistory(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildConfigHistory::IDD, pParent) +, m_SelDate(COleDateTime::GetCurrentTime()) +{ + +} + +CDlgChildConfigHistory::~CDlgChildConfigHistory() +{ +} + +void CDlgChildConfigHistory::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_DATA_LIST, m_DataList); + DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate); +} + +BOOL CDlgChildConfigHistory::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildConfigHistory::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedSearchBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildConfigHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\ConfigHistory\\"); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgChildConfigHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\ConfigHistory\\"); + CString DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildConfigHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildConfigHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildConfigHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildConfigHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgChildConfigHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +void CDlgChildConfigHistory::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgChildConfigHistory::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + m_DataList.DeleteAllItems(); + vector> StrVec; + CString log("ReadFile : "); + log += strPath; + gLogMgr->WriteDebugLog(log); + + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + } + if(strPath.Find(".bmp")!=-1)//ͼ + { + //windowsͼƬ鿴 + PictureWindows(strPath); + } + *pResult = 0; +} +void CDlgChildConfigHistory::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} + + +void CDlgChildConfigHistory::OnBnClickedSearchByDate() +{ + UpdateData(TRUE); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot,m_SelDate); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + + diff --git a/LaipuDrawing/DlgChildConfigHistory.h b/LaipuDrawing/DlgChildConfigHistory.h new file mode 100644 index 0000000..ced4a7e --- /dev/null +++ b/LaipuDrawing/DlgChildConfigHistory.h @@ -0,0 +1,45 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildConfigHistory : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildConfigHistory) + +public: + CDlgChildConfigHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildConfigHistory(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + void UpdateDataList(CString FilePath); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_CONFIG_HISTORY }; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByDate(); + // ǰѡе + COleDateTime m_SelDate; +}; + diff --git a/LaipuDrawing/DlgChildDataAnalysis.cpp b/LaipuDrawing/DlgChildDataAnalysis.cpp new file mode 100644 index 0000000..b542fe5 --- /dev/null +++ b/LaipuDrawing/DlgChildDataAnalysis.cpp @@ -0,0 +1,45 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildDataAnalysis.h" +#include "WorkRecord.h" +#include "GlobalFunction.h" +#include "LogMgr.h" + + + +IMPLEMENT_DYNAMIC(CDlgChildDataAnalysis, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildDataAnalysis, CMyDlgView) + +END_MESSAGE_MAP() + + +CDlgChildDataAnalysis::CDlgChildDataAnalysis(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildDataAnalysis::IDD, pParent) +{ + +} + +CDlgChildDataAnalysis::~CDlgChildDataAnalysis() +{ +} + +void CDlgChildDataAnalysis::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + +} + +BOOL CDlgChildDataAnalysis::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildDataAnalysis::OnViewOpen() +{ + +} diff --git a/LaipuDrawing/DlgChildDataAnalysis.h b/LaipuDrawing/DlgChildDataAnalysis.h new file mode 100644 index 0000000..fba4b05 --- /dev/null +++ b/LaipuDrawing/DlgChildDataAnalysis.h @@ -0,0 +1,24 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" + +class CDlgChildDataAnalysis : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildDataAnalysis) + +public: + CDlgChildDataAnalysis(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildDataAnalysis(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ +// Ի + enum { IDD = IDD_CHILD_DATA_ANALYSIS }; +private: + +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + +}; diff --git a/LaipuDrawing/DlgChildEventLog.cpp b/LaipuDrawing/DlgChildEventLog.cpp new file mode 100644 index 0000000..24e7699 --- /dev/null +++ b/LaipuDrawing/DlgChildEventLog.cpp @@ -0,0 +1,146 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildEventLog.h" +#include "WorkRecord.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" + + + +IMPLEMENT_DYNAMIC(CDlgChildEventLog, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildEventLog, CMyDlgView) + ON_BN_CLICKED(IDC_CLEAR_LIST_BTN, &CDlgChildEventLog::OnBnClickedClearListBtn) + ON_BN_CLICKED(IDC_OPEN_LOG_DIR_BTN, &CDlgChildEventLog::OnBnClickedOpenLogDirBtn) + ON_CBN_SELCHANGE(IDC_LOG_TYPE_COMBO, &CDlgChildEventLog::OnCbnSelchangeLogTypeCombo) + ON_BN_CLICKED(IDC_STOP_REV_LOG_BTN, &CDlgChildEventLog::OnBnClickedStopRevLogBtn) +END_MESSAGE_MAP() + +#define MAX_LOG_LIST_ROWS 1000//log + +CDlgChildEventLog::CDlgChildEventLog(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildEventLog::IDD, pParent) +{ + m_bStopRevLog = false;//ͣµlog (Ӱlog 浽ļ) +} +CDlgChildEventLog::~CDlgChildEventLog() +{ +} + +void CDlgChildEventLog::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, NEW_REV_LOG_LIST, m_LaipuLaserLogList); + DDX_Control(pDX, NEW_LAIPU_DRAWING_LOG_LIST, m_LaipuDrawingLogList); + DDX_Control(pDX, IDC_LOG_TYPE_COMBO, m_SelLogTypeComb); +} + +BOOL CDlgChildEventLog::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + InitLogList(m_LaipuLaserLogList); + InitLogList(m_LaipuDrawingLogList); + + //ʼSelLogTypeComb + m_SelLogTypeComb.InsertString(0,"LaipuLaser"); + m_SelLogTypeComb.InsertString(1,"LaipuDrawing"); + m_SelLogTypeComb.SetCurSel(0); + m_CurLogListType = _LogListType_LaipuLaser; + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildEventLog::OnViewOpen() +{ + +} +//ʼ־б +void CDlgChildEventLog::InitLogList(CListCtrl &List) +{ + //÷ + List.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + int idx = 0; + List.InsertColumn(idx,"LOG",LVCFMT_LEFT,2000,-1); + idx++; +} +CListCtrl &CDlgChildEventLog::GetLogList(eLogListType LogListType) +{ + if(LogListType==_LogListType_LaipuLaser) + return m_LaipuLaserLogList; + return m_LaipuDrawingLogList; +} + +void CDlgChildEventLog::InsertLogToList(CString &LogStr,eLogListType LogListType) +{ + if(!m_bStopRevLog) + { + InsertLogToListExt(LogStr,GetLogList(LogListType)); + } +} +//һlog +void CDlgChildEventLog::InsertLogToListExt(CString &LogStr,CListCtrl &List) +{ + int CurItemCount = List.GetItemCount();//ǰ + if(CurItemCount>=MAX_LOG_LIST_ROWS)//ɾһ + { + List.DeleteItem(0); + CurItemCount--; + } + //²һ + int idx = CurItemCount; + List.InsertItem(idx," ");//һ + List.SetItemText(idx,0,LogStr); + //ʾһ + List.EnsureVisible(idx,FALSE); +} +void CDlgChildEventLog::OnBnClickedClearListBtn() +{ + CListCtrl &List = GetLogList(m_CurLogListType); + List.DeleteAllItems(); + + gLogMgr->WriteDebugLog("Func---->OnBnClickedClearListBtn"); +} +void CDlgChildEventLog::OnBnClickedOpenLogDirBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedOpenLogDirBtn"); + CString DirPath; + if(m_CurLogListType==_LogListType_LaipuLaser) + DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\LogFile\\"); + else + DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\LogFile_DataMgr\\"); + CFileMgr FileMgr; + FileMgr.OpenDir(DirPath); +} + +void CDlgChildEventLog::OnCbnSelchangeLogTypeCombo() +{ + gLogMgr->WriteDebugLog("Func---->OnCbnSelchangeLogTypeCombo"); + int idx = m_SelLogTypeComb.GetCurSel(); + if(idx==1) + { + GetDlgItem(NEW_REV_LOG_LIST)->ShowWindow(SW_HIDE); + GetDlgItem(NEW_LAIPU_DRAWING_LOG_LIST)->ShowWindow(SW_SHOW); + m_CurLogListType = _LogListType_LaipuDrawing; + } + else + { + GetDlgItem(NEW_REV_LOG_LIST)->ShowWindow(SW_SHOW); + GetDlgItem(NEW_LAIPU_DRAWING_LOG_LIST)->ShowWindow(SW_HIDE); + m_CurLogListType = _LogListType_LaipuLaser; + } +} + + +void CDlgChildEventLog::OnBnClickedStopRevLogBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedStopRevLogBtn"); + m_bStopRevLog = !m_bStopRevLog; + if(m_bStopRevLog) + GetDlgItem(IDC_STOP_REV_LOG_BTN)->SetWindowText("ʼ"); + else + GetDlgItem(IDC_STOP_REV_LOG_BTN)->SetWindowText("ͣ"); +} diff --git a/LaipuDrawing/DlgChildEventLog.h b/LaipuDrawing/DlgChildEventLog.h new file mode 100644 index 0000000..11e0d64 --- /dev/null +++ b/LaipuDrawing/DlgChildEventLog.h @@ -0,0 +1,45 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" + +enum eLogListType +{ + _LogListType_LaipuLaser = 0, + _LogListType_LaipuDrawing, +}; + + +class CDlgChildEventLog : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildEventLog) + +public: + CDlgChildEventLog(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildEventLog(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InsertLogToListExt(CString &LogStr,CListCtrl &List); + void InsertLogToList(CString &LogStr,eLogListType LogListType); + void InitLogList(CListCtrl &List); + CListCtrl &GetLogList(eLogListType LogListType); +// Ի + enum { IDD = IDD_CHILD_EVENT_LOG }; +private: + CListCtrl m_LaipuLaserLogList; + CListCtrl m_LaipuDrawingLogList; + + CComboBox m_SelLogTypeComb; + + eLogListType m_CurLogListType; + bool m_bStopRevLog;//ͣµlog (Ӱlog 浽ļ) +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + + afx_msg void OnBnClickedClearListBtn(); + afx_msg void OnBnClickedOpenLogDirBtn(); + afx_msg void OnCbnSelchangeLogTypeCombo(); + afx_msg void OnBnClickedStopRevLogBtn(); +}; diff --git a/LaipuDrawing/DlgChildJobHistory.cpp b/LaipuDrawing/DlgChildJobHistory.cpp new file mode 100644 index 0000000..0578c17 --- /dev/null +++ b/LaipuDrawing/DlgChildJobHistory.cpp @@ -0,0 +1,291 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildJobHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" + +IMPLEMENT_DYNAMIC(CDlgChildJobHistory, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildJobHistory, CMyDlgView) + ON_BN_CLICKED(IDC_UPDATE_DATA_BTN, &CDlgChildJobHistory::OnBnClickedUpdateDataBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildJobHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildJobHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_EXPORT_BTN, &CDlgChildJobHistory::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildJobHistory::OnBnClickedSearchByDate) +END_MESSAGE_MAP() + +#define DATA_PATH "\\JobHistory\\" +#define Data_List_Item_Cnt 20 + + +CDlgChildJobHistory::CDlgChildJobHistory(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildJobHistory::IDD, pParent) +, m_SelDate(COleDateTime::GetCurrentTime()) +{ + +} + +CDlgChildJobHistory::~CDlgChildJobHistory() +{ +} + +void CDlgChildJobHistory::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_DATA_LIST, m_DataList); + DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate); +} + +BOOL CDlgChildJobHistory::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +#if 1 +//Ӧview 򿪵ʱ +void CDlgChildJobHistory::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedUpdateDataBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildJobHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(DATA_PATH); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgChildJobHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(DATA_PATH); + CString DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildJobHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildJobHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildJobHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildJobHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +void CDlgChildJobHistory::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} + +#endif +#if 1 +// +void CDlgChildJobHistory::OnBnClickedUpdateDataBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} +//tree +void CDlgChildJobHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + m_DataList.DeleteAllItems(); + vector> StrVec; + CString log("ReadFile : "); + log += strPath; + gLogMgr->WriteDebugLog(log); + + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + } + if(strPath.Find(".bmp")!=-1)//ͼ + { + //windowsͼƬ鿴 + PictureWindows(strPath); + } + *pResult = 0; +} +// +void CDlgChildJobHistory::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} +//ڲѯ +void CDlgChildJobHistory::OnBnClickedSearchByDate() +{ + UpdateData(TRUE); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot,m_SelDate); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб +} +#endif + diff --git a/LaipuDrawing/DlgChildJobHistory.h b/LaipuDrawing/DlgChildJobHistory.h new file mode 100644 index 0000000..7644f12 --- /dev/null +++ b/LaipuDrawing/DlgChildJobHistory.h @@ -0,0 +1,44 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildJobHistory : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildJobHistory) + +public: + CDlgChildJobHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildJobHistory(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_JOB_HISTORY}; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + afx_msg void OnBnClickedUpdateDataBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByDate(); + // ǰѡе + COleDateTime m_SelDate; +}; + diff --git a/LaipuDrawing/DlgChildLoginHistory.cpp b/LaipuDrawing/DlgChildLoginHistory.cpp new file mode 100644 index 0000000..c2c266b --- /dev/null +++ b/LaipuDrawing/DlgChildLoginHistory.cpp @@ -0,0 +1,285 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildLoginHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" + +IMPLEMENT_DYNAMIC(CDlgChildLoginHistory, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildLoginHistory, CMyDlgView) + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildLoginHistory::OnBnClickedSearchBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildLoginHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildLoginHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildLoginHistory::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildLoginHistory::OnBnClickedSearchByDate) +END_MESSAGE_MAP() + +#define Data_List_Item_Cnt 20 +CDlgChildLoginHistory::CDlgChildLoginHistory(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildLoginHistory::IDD, pParent) +, m_SelDate(COleDateTime::GetCurrentTime()) +{ + +} + +CDlgChildLoginHistory::~CDlgChildLoginHistory() +{ +} + +void CDlgChildLoginHistory::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList); + DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate); +} + +BOOL CDlgChildLoginHistory::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildLoginHistory::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedSearchBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildLoginHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\LoginRecord\\"); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgChildLoginHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\LoginRecord\\"); + CString DateStr; + if(bByMonth) + DateStr = SelDate.Format("%Y\\%m\\"); + else + DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildLoginHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildLoginHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildLoginHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildLoginHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgChildLoginHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +void CDlgChildLoginHistory::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgChildLoginHistory::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + #if 1 + m_DataList.DeleteAllItems(); + vector> StrVec; + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + #endif + } + *pResult = 0; +} +void CDlgChildLoginHistory::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} + + +void CDlgChildLoginHistory::OnBnClickedSearchByDate() +{ + UpdateData(TRUE); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot,m_SelDate,true); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + + diff --git a/LaipuDrawing/DlgChildLoginHistory.h b/LaipuDrawing/DlgChildLoginHistory.h new file mode 100644 index 0000000..5c74325 --- /dev/null +++ b/LaipuDrawing/DlgChildLoginHistory.h @@ -0,0 +1,45 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildLoginHistory : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildLoginHistory) + +public: + CDlgChildLoginHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildLoginHistory(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + void UpdateDataList(CString FilePath); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_USER_HISTORY }; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth = false); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByDate(); + // ǰѡе + COleDateTime m_SelDate; +}; + diff --git a/LaipuDrawing/DlgChildParaHistory.cpp b/LaipuDrawing/DlgChildParaHistory.cpp new file mode 100644 index 0000000..bb6bd61 --- /dev/null +++ b/LaipuDrawing/DlgChildParaHistory.cpp @@ -0,0 +1,364 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildParaHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "CStringFuc.h" + + + +IMPLEMENT_DYNAMIC(CDlgChildParaHistory, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildParaHistory, CMyDlgView) + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildParaHistory::OnBnClickedSearchBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildParaHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildParaHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildParaHistory::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildParaHistory::OnBnClickedSearchByName) +END_MESSAGE_MAP() + +#define PARA_MODIFY_DATA_PATH _T("\\ParaModifyRecord\\") + +#define Data_List_Item_Cnt 20 +CDlgChildParaHistory::CDlgChildParaHistory(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildParaHistory::IDD, pParent) +{ + +} + +CDlgChildParaHistory::~CDlgChildParaHistory() +{ +} + +void CDlgChildParaHistory::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList); +} + +BOOL CDlgChildParaHistory::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildParaHistory::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedSearchBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildParaHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\ParaModifyRecord\\"); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgChildParaHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\ParaModifyRecord\\"); + CString DateStr; + if(bByMonth) + DateStr = SelDate.Format("%Y\\%m\\"); + else + DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildParaHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildParaHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildParaHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildParaHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgChildParaHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +// +void CDlgChildParaHistory::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgChildParaHistory::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + m_DataList.DeleteAllItems(); + vector> StrVec; + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + } + *pResult = 0; +} +void CDlgChildParaHistory::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} +//·µĽڵ,ݹ麯 +void CDlgChildParaHistory::GetDriveDir_ByPath(HTREEITEM hParent,CString FindPath,CString SearchName) +{ + COleDateTime SelDateStart; + COleDateTime SelDateEnd = COleDateTime::GetCurrentTime(); + + CFileMgr FileMgr; + vector DirPathVec;//Ŀ¼· + FileMgr.GetChildFileOrDirName(true,FindPath,DirPathVec,""); + //ûĿ¼ʾĿ¼ + if(DirPathVec.empty()) + { + CString DataPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(PARA_MODIFY_DATA_PATH); + int FindPathLen = FindPath.GetLength(); + int DataPathLen = DataPath.GetLength(); + if(DataPathLen>=FindPathLen) + return; + CString ChildDirName = FindPath.Right(FindPathLen-DataPathLen);//ӽڵ + + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + + bool bChild2Creat = false; + vector FilePathVec;//ļ· + FileMgr.GetChildFileOrDirName(false,FindPath,FilePathVec,"xlsx"); + int size = FilePathVec.size(); + for(int k=0;kWriteDebugLog("Func-->OnBnClickedSearchByName"); + CString SearchName; + GetDlgItem(IDC_SEARCH_RECIPE_NAME)->GetWindowText(SearchName); + + if(SearchName=="") + return; + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root");//ڵ + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(PARA_MODIFY_DATA_PATH); + m_tree.InsertItem(path, m_hRoot);//ڸڵhParent̷ + + m_bFirstDir = true;//һĿ¼ + GetDriveDir_ByPath(m_hRoot,path,SearchName);//Զ庯 ȡ + //m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб + + ExpandTree(&m_tree,m_hRoot);//չнڵ +} +void CDlgChildParaHistory::SearchByName(CString SearchName) +{ + GetDlgItem(IDC_SEARCH_RECIPE_NAME)->SetWindowText(SearchName); + OnBnClickedSearchByName(); + m_bFirstOpen = false; +} diff --git a/LaipuDrawing/DlgChildParaHistory.h b/LaipuDrawing/DlgChildParaHistory.h new file mode 100644 index 0000000..0c4c504 --- /dev/null +++ b/LaipuDrawing/DlgChildParaHistory.h @@ -0,0 +1,48 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildParaHistory : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildParaHistory) + +public: + CDlgChildParaHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildParaHistory(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + void UpdateDataList(CString FilePath); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_RCP_PAR_HISTORY }; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· + + HTREEITEM m_hChild2;//Ӽڵ + bool m_bFirstDir;//һĿ¼ +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth = false); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + void SearchByName(CString SearchName); + void GetDriveDir_ByPath(HTREEITEM hParent,CString FindPath,CString SearchName); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByName(); +}; + diff --git a/LaipuDrawing/DlgChildRealTimeDataHistory.cpp b/LaipuDrawing/DlgChildRealTimeDataHistory.cpp new file mode 100644 index 0000000..781372b --- /dev/null +++ b/LaipuDrawing/DlgChildRealTimeDataHistory.cpp @@ -0,0 +1,296 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildRealTimeDataHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" + +IMPLEMENT_DYNAMIC(CDlgChildRealTimeDataHistory, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildRealTimeDataHistory, CMyDlgView) + + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildRealTimeDataHistory::OnBnClickedSearchBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildRealTimeDataHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildRealTimeDataHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildRealTimeDataHistory::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildRealTimeDataHistory::OnBnClickedSearchByDate) +END_MESSAGE_MAP() + +#define Data_List_Item_Cnt 60 +CDlgChildRealTimeDataHistory::CDlgChildRealTimeDataHistory(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildRealTimeDataHistory::IDD, pParent) +, m_SelDate(COleDateTime::GetCurrentTime()) +{ + +} + +CDlgChildRealTimeDataHistory::~CDlgChildRealTimeDataHistory() +{ +} + +void CDlgChildRealTimeDataHistory::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList); + DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate); +} + +BOOL CDlgChildRealTimeDataHistory::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildRealTimeDataHistory::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedSearchBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildRealTimeDataHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\RealTimeData\\"); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgChildRealTimeDataHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir("\\MonitoringData\\RealTimeData\\"); + CString DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildRealTimeDataHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildRealTimeDataHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildRealTimeDataHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildRealTimeDataHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgChildRealTimeDataHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +void CDlgChildRealTimeDataHistory::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgChildRealTimeDataHistory::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + //ɾе + m_DataList.DeleteAllItems(); + while (m_DataList.DeleteColumn(0)); + + vector> StrVec; + CString log("ReadFile : "); + log += strPath; + gLogMgr->WriteDebugLog(log); + + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + } + *pResult = 0; +} +void CDlgChildRealTimeDataHistory::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} + + +void CDlgChildRealTimeDataHistory::OnBnClickedSearchByDate() +{ + UpdateData(TRUE); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot,m_SelDate); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + + diff --git a/LaipuDrawing/DlgChildRealTimeDataHistory.h b/LaipuDrawing/DlgChildRealTimeDataHistory.h new file mode 100644 index 0000000..2bb7b5f --- /dev/null +++ b/LaipuDrawing/DlgChildRealTimeDataHistory.h @@ -0,0 +1,45 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildRealTimeDataHistory : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildRealTimeDataHistory) + +public: + CDlgChildRealTimeDataHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildRealTimeDataHistory(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + void UpdateDataList(CString FilePath); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_REAL_TIME_HISTORY }; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent,COleDateTime SelDate); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByDate(); + // ǰѡе + COleDateTime m_SelDate; +}; + diff --git a/LaipuDrawing/DlgChildRecipe.cpp b/LaipuDrawing/DlgChildRecipe.cpp new file mode 100644 index 0000000..ccab957 --- /dev/null +++ b/LaipuDrawing/DlgChildRecipe.cpp @@ -0,0 +1,703 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildRecipe.h" +#include "LogMgr.h" +#include "AuthorityMgr.h" +#include "WaferRecipeDataMgr.h" +#include "RecipeMgr.h" +#include "ProgramLaserTuiHuo.h" +#include "CStringFuc.h" +#include "MsgBox.h" +#include "LogMgr.h" +#include "GlobalFunction.h" +#include "WaferRecipeDataMgr.h" +#include "TimingProgressMgr.h" +#include "Layer.h" +#include "GlobalFunction.h" +#include "Laser.h" +#include "WorkFileMgr.h" +#include "WorkRecord.h" +#include "LanguageMgr.h" +#include "DlgLayerViewShow.h" +#include "GlobalDrawMgr.h" +#include "DlgRecipeCompare.h" +#include "DlgDeviceMain.h" +#include "DlgChildParaHistory.h" +#include "FileMgr.h" +#include "DlgOffsetTable.h" + + + + +IMPLEMENT_DYNAMIC(CDlgChildRecipe, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildRecipe, CMyDlgView) + ON_WM_TIMER() + ON_BN_CLICKED(IDC_RECIPE_NAME_BTN, &CDlgChildRecipe::OnBnClickedRecipeNameBtn) + ON_BN_CLICKED(IDC_GROUP_NAME_BTN, &CDlgChildRecipe::OnBnClickedGroupNameBtn) + ON_BN_CLICKED(IDC_RECIPE_COPY_BTN, &CDlgChildRecipe::OnBnClickedRecipeCopyBtn) + ON_BN_CLICKED(IDC_RECIPE_PASTE_BTN, &CDlgChildRecipe::OnBnClickedRecipeMoveBtn) + ON_BN_CLICKED(IDC_OPEN_VIEW_DLG_BTN, &CDlgChildRecipe::OnBnClickedOpenViewDlgBtn) + ON_BN_CLICKED(NEW_ADD_GROUP_BTN, &CDlgChildRecipe::OnBnClickedAddGroupBtn) + ON_BN_CLICKED(NEW_DEL_GROUP_BTN, &CDlgChildRecipe::OnBnClickedDelGroupBtn) + ON_BN_CLICKED(NEW_ADD_RECIPE_BTN, &CDlgChildRecipe::OnBnClickedAddRecipeBtn) + ON_BN_CLICKED(NEW_DEL_RECIPE_BTN, &CDlgChildRecipe::OnBnClickedDelRecipeBtn) + ON_BN_CLICKED(NEW_RECIPE_TO_EDIT_BTN, &CDlgChildRecipe::OnBnClickedRecipeToEditBtn) + ON_CBN_SELCHANGE(NEW_RECIPE_GROUP_COMBO, &CDlgChildRecipe::OnCbnSelchangeNewRecipeGroupCombo) + + ON_NOTIFY(NM_CLICK, NEW_GROUP_RECIPE_LIST, &CDlgChildRecipe::OnNMClickGroupRecipeList) + ON_NOTIFY(NM_CLICK, NEW_EDIT_RECIPE_LIST, &CDlgChildRecipe::OnNMClickEditRecipeList) + ON_NOTIFY(NM_CLICK, NEW_SUB_RECIPE_LIST, &CDlgChildRecipe::OnNMClickEditSubRecipeList) + ON_BN_CLICKED(IDC_EDIT_PAR_SAVE_BTN, &CDlgChildRecipe::OnBnClickedEditParSaveBtn) + ON_BN_CLICKED(NEW_ADD_SUB_RECIPE_BTN, &CDlgChildRecipe::OnBnClickedAddSubRecipeBtn) + ON_BN_CLICKED(NEW_DEL_SUB_RECIPE_BTN, &CDlgChildRecipe::OnBnClickedDelSubRecipeBtn) + ON_BN_CLICKED(NEW_SUB_RECIPE_MOVE_UP, &CDlgChildRecipe::OnBnClickedSubRecipeMoveUp) + ON_BN_CLICKED(NEW_SUB_RECIPE_MOVE_DOWN, &CDlgChildRecipe::OnBnClickedSubRecipeMoveDown) + ON_BN_CLICKED(NEW_RENAME_SUB_RECIPE_BTN, &CDlgChildRecipe::OnBnClickedRenameSubRecipeBtn) + ON_BN_CLICKED(IDC_RCP_COMPARE_BTN, &CDlgChildRecipe::OnBnClickedRcpCompareBtn) + ON_EN_KILLFOCUS(IDC_EDIT_PAR_DOUBLE, &CDlgChildRecipe::OnEnKillfocusDoubleEdit) + ON_CBN_SELCHANGE(IDC_SEL_SCAN_AREA_COMBO, &CDlgChildRecipe::OnCbnSelchangeSelScanAreaCombo) + ON_CBN_SELCHANGE(IDC_SEL_AREA_IDX_COMBO, &CDlgChildRecipe::OnCbnSelchangeSelAreaIdxCombo) + ON_CBN_SELCHANGE(IDC_SEL_BOOL_VAL_COMBO, &CDlgChildRecipe::OnCbnSelchangeSelBoolValCombo) + ON_CBN_SELCHANGE(IDC_SEL_OFFSET_TAB_COMBO, &CDlgChildRecipe::OnCbnSelchangeSelOffsetTableCombo) + + ON_NOTIFY(NM_CUSTOMDRAW, NEW_EDIT_RECIPE_LIST, &CDlgChildRecipe::OnDrawEditRecipeList) + ON_NOTIFY(NM_CUSTOMDRAW, NEW_EDIT_RECIPE_INFO_LIST, &CDlgChildRecipe::OnDrawEditRecipeInfoList) + ON_BN_CLICKED(IDC_RCP_HISTORY_BTN, &CDlgChildRecipe::OnBnClickedRcpHistoryBtn) + ON_BN_CLICKED(IDC_RCP_OFFSET_TAB, &CDlgChildRecipe::OnBnClickedRcpOffsetTab) + ON_BN_CLICKED(NEW_UPDATE_RECIPE_BTN, &CDlgChildRecipe::OnBnClickedUpdateRecipeBtn) +END_MESSAGE_MAP() + + +CDlgChildRecipe::CDlgChildRecipe(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildRecipe::IDD, pParent) +{ + InitParIDVec(); + m_EditRecipeParVal = 0; +} + +CDlgChildRecipe::~CDlgChildRecipe() +{ +} + +void CDlgChildRecipe::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, NEW_RECIPE_GROUP_COMBO, m_NewRecipeGroupComb); + + DDX_Control(pDX, NEW_GROUP_RECIPE_LIST, m_GroupRecipeList); + DDX_Control(pDX, NEW_EDIT_RECIPE_LIST, m_EditRecipeList); + DDX_Control(pDX, NEW_SUB_RECIPE_LIST, m_EditSubRecipeList); + DDX_Control(pDX, NEW_EDIT_RECIPE_INFO_LIST, m_EditRecipeInfoList); + DDX_Control(pDX, IDC_SEL_SCAN_AREA_COMBO, m_SelScanAreaComb); + DDX_Control(pDX, IDC_SEL_AREA_IDX_COMBO, m_SelScanAreaIdxComb); + DDX_Control(pDX, IDC_SEL_BOOL_VAL_COMBO, m_SelBoolValComb); + DDX_Control(pDX, IDC_SEL_OFFSET_TAB_COMBO, m_SelOffsetTableComb); + + DDX_Text(pDX,IDC_EDIT_PAR_DOUBLE,m_EditRecipeParVal); + + DDX_Control(pDX, IDC_EDIT_PAR_DOUBLE, m_DoubleParEdit); +} + +void CDlgChildRecipe::OnTimer(UINT nIDEvent) +{ + CDialog::OnTimer(nIDEvent); + +} + +BOOL CDlgChildRecipe::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + #ifdef __OFFSET_TABLE__ + GetDlgItem(IDC_RCP_OFFSET_TAB)->ShowWindow(SW_SHOW); + #endif + UpdateData(FALSE); + return TRUE; +} +void CDlgChildRecipe::UpdateLanguageTxt() +{ + + +} +void CDlgChildRecipe::SetTextCtrlItemID() +{ + +} +void CDlgChildRecipe::ChangeItemState() +{ + bool bEnable = true; +} +void CDlgChildRecipe::OnDrawEditRecipeList( NMHDR* pNMHDR, LRESULT* pResult ) +{ + NMLVCUSTOMDRAW* pLVCD = reinterpret_cast( pNMHDR ); + *pResult = CDRF_DODEFAULT; + if( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYITEMDRAW; + } + else if( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYSUBITEMDRAW; + } + else if((CDDS_ITEMPREPAINT | CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage ) + { + COLORREF crText, crBkgnd; + crText = RGB_BLACK; + crBkgnd = RGB_WHITE; + int iRow = pLVCD->nmcd.dwItemSpec;//к + int iCol = Rcp_List_Val_Col; + if(iCol == pLVCD->iSubItem)//к + { + if(gRecipeMgr->IsErrRangeParIdx(iRow))//ݳΧ + crBkgnd = RGB_RED; + else if(gRecipeMgr->IsChangeParIdx(iRow))//ıIJ + crBkgnd = RGB_YELLOW; + else if(gRecipeMgr->IsInvalidParIdx(iRow))//ЧIJ + crBkgnd = RGB_GRAY1; + } + pLVCD->clrText = crText; + pLVCD->clrTextBk = crBkgnd; + *pResult = CDRF_DODEFAULT; + } +} +void CDlgChildRecipe::OnDrawEditRecipeInfoList( NMHDR* pNMHDR, LRESULT* pResult ) +{ + NMLVCUSTOMDRAW* pLVCD = reinterpret_cast( pNMHDR ); + *pResult = CDRF_DODEFAULT; + if( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYITEMDRAW; + } + else if( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYSUBITEMDRAW; + } + else if((CDDS_ITEMPREPAINT | CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage ) + { + COLORREF crText, crBkgnd; + crText = RGB_BLACK; + crBkgnd = RGB_WHITE; + int iRow = pLVCD->nmcd.dwItemSpec;//к + int iCol = Rcp_List_Val_Col; + if(iCol == pLVCD->iSubItem)//к + { + if(gRecipeMgr->IsErrRangeParIdx(iRow+Rcp_CalInfo_Start_Idx)) + crBkgnd = RGB_RED; + } + pLVCD->clrText = crText; + pLVCD->clrTextBk = crBkgnd; + + *pResult = CDRF_DODEFAULT; + } +} + +#if 1 +//ʼԻؼ +void CDlgChildRecipe::InitDialogItem() +{ + gRecipeMgr->BindingRecipeGroupComb(&m_NewRecipeGroupComb); + gRecipeMgr->InitGroupRecipeList(m_GroupRecipeList); + gRecipeMgr->InitEditRecipeList(m_EditRecipeList,true); + gRecipeMgr->InitEditRecipeList(m_EditRecipeInfoList,true); + gRecipeMgr->InitEditSubRecipeList(m_EditSubRecipeList); + + + UpdateData(FALSE); +} +void CDlgChildRecipe::InitParIDVec() +{ + +} +//µǰѡrecipe Ϣ +void CDlgChildRecipe::UpdateRecipeParInfo() +{ + +} +//浱ǰѡrecipe +bool CDlgChildRecipe::SaveCurSelRecipe() +{ + + return true; +} +#endif +#if 1 +//ֵб +void CDlgChildRecipe::UpdateAreaIdxCombo() +{ + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + int AreaCnt = ObjContainer.GetScanAreaCnt(); + m_SelScanAreaIdxComb.ResetContent();// + int idx = 0; + for(int k=0;kWriteDebugLog("Func---->OnBnClickedRecipeNameBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_RecipeName)) + return; + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); + GetDlgItem(IDC_CUR_EDIT_RCP_PATH)->SetWindowText(gRecipeMgr->GetCurEditRecipeInfo()); +} +//õǰѡgourp +void CDlgChildRecipe::OnBnClickedGroupNameBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedGroupNameBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_GroupName)) + return; + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); + GetDlgItem(IDC_CUR_EDIT_RCP_PATH)->SetWindowText(gRecipeMgr->GetCurEditRecipeInfo()); +} +//Ƶǰѡеrecipe +void CDlgChildRecipe::OnBnClickedRecipeCopyBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedRecipeCopyBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_CopyRecipe)) + return; + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); +} +//ճǰѡеrecipe +void CDlgChildRecipe::OnBnClickedRecipeMoveBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedRecipeMoveBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_MoveRecipe)) + return; + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); + ResetEditRecipeItem();//õǰ༭recipe Ϣ +} +void CDlgChildRecipe::OnBnClickedOpenViewDlgBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedOpenViewDlgBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_CheckRecipe",true)) + return; + if(gDraw->IsbDlgLayerViewShow()) + { + gLogMgr->WriteDebugLog("Cannot Re-Open"); + return; + } + CDlgLayerViewShow *dlg = new CDlgLayerViewShow; + dlg->Create(IDD_LAYER_VIEW_SHOW_DLG, this); + dlg->ShowWindow(SW_SHOW); +} +#endif + +#if 1 +void CDlgChildRecipe::OnBnClickedAddGroupBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedAddGroupBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_AddGroup)) + return; + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); +} +void CDlgChildRecipe::OnBnClickedDelGroupBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedDelGroupBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_DelRecipeGroup",true)) + return; + CMsgBox MsgBox; + MsgBox.Show("ע:ɾὫrecipe ɾ!"); + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_DelGroup)) + return; + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); +} +void CDlgChildRecipe::OnBnClickedAddRecipeBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedAddRecipeBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_AddRecipe)) + return; + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); +} +void CDlgChildRecipe::OnBnClickedDelRecipeBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedDelRecipeBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_DelRecipe)) + return; + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); + ResetEditRecipeItem();//õǰ༭recipe Ϣ +} +void CDlgChildRecipe::OnBnClickedRecipeToEditBtn() +{ + +} +void CDlgChildRecipe::OnCbnSelchangeNewRecipeGroupCombo() +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_CheckRecipe",true)) + return; + int Idx = m_NewRecipeGroupComb.GetCurSel(); + gRecipeMgr->SetCurSelGourpIdx(Idx); + gRecipeMgr->UpdateGroupRecipeList(m_GroupRecipeList); + ResetEditRecipeItem();//õǰ༭recipe Ϣ +} +//recipe б +void CDlgChildRecipe::OnNMClickGroupRecipeList(NMHDR *pNMHDR, LRESULT *pResult) +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_CheckRecipe",true)) + return; + *pResult = 0; + int Idx = GetCurListIdx(m_GroupRecipeList); + if(Idx>=0) + { + gRecipeMgr->OnSelRecipeIdxChange(Idx); + //Ϊǰ༭recipe + if(gRecipeMgr->ReadEditRecipeFromFile()) + { + gRecipeMgr->UpdateEditRecipeList(m_EditRecipeList,m_EditRecipeInfoList); + gRecipeMgr->UpdateEditSubRecipeList(m_EditSubRecipeList); + + CString EditRecipePath = gRecipeMgr->GetCurEditRecipeInfo(); + CFileMgr FileMgr; + m_CurSelRecipeName = FileMgr.GetFileNameFromPath(EditRecipePath,true);//浱ǰѡrecipe + + GetDlgItem(IDC_CUR_EDIT_RCP_PATH)->SetWindowText(EditRecipePath); + GetDlgItem(IDC_CUR_EDIT_SUB_RCP_NAME)->SetWindowText(gRecipeMgr->GetCurEditSubRecipeInfo()); + //б + gWaferRecipeDataMgr->InitScanAreaComb(m_SelScanAreaComb); + #ifdef __OFFSET_TABLE__ + gWaferRecipeDataMgr->InitOffsetTableComb(m_SelOffsetTableComb); + #endif + gRecipeMgr->UpdatParBoolComb(m_SelBoolValComb); + + HideEditRecipeParItem(); + + gRecipeMgr->CreatCurEditRecipeScanPath(); + } + } +} +void CDlgChildRecipe::OnNMClickEditSubRecipeList(NMHDR *pNMHDR, LRESULT *pResult) +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_CheckRecipe",true)) + return; + *pResult = 0; + int Idx = GetCurListIdx(m_EditSubRecipeList); + if(Idx>=0) + { + gRecipeMgr->SetSubRecipeIdx(Idx); + gRecipeMgr->UpdateEditRecipeList(m_EditRecipeList,m_EditRecipeInfoList); + GetDlgItem(IDC_CUR_EDIT_SUB_RCP_NAME)->SetWindowText(gRecipeMgr->GetCurEditSubRecipeInfo()); + + gRecipeMgr->CreatCurEditRecipeScanPath(); + + + UpdateData(FALSE); + } +} + +#endif + + +void CDlgChildRecipe::OnBnClickedAddSubRecipeBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedAddSubRecipeBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_AddSubRecipe)) + return; + gRecipeMgr->UpdateEditSubRecipeList(m_EditSubRecipeList); + gRecipeMgr->UpdateEditRecipeList(m_EditRecipeList,m_EditRecipeInfoList); +} +void CDlgChildRecipe::OnBnClickedDelSubRecipeBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedDelSubRecipeBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_DelSubRecipe)) + return; + gRecipeMgr->UpdateEditSubRecipeList(m_EditSubRecipeList); + GetDlgItem(IDC_CUR_EDIT_SUB_RCP_NAME)->SetWindowText(gRecipeMgr->GetCurEditSubRecipeInfo()); +} +void CDlgChildRecipe::OnBnClickedRenameSubRecipeBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedRenameSubRecipeBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!gRecipeMgr->EditRecipeByCtrlType(_RecipeCtrl_SubRecipeName)) + return; + gRecipeMgr->UpdateEditSubRecipeList(m_EditSubRecipeList); + gRecipeMgr->UpdateEditRecipeList(m_EditRecipeList,m_EditRecipeInfoList); +} +//õǰ༭recipe Ϣ +void CDlgChildRecipe::ResetEditRecipeItem() +{ + gRecipeMgr->SetCurSelRecipeName(""); + gRecipeMgr->UpdateEditSubRecipeList(m_EditSubRecipeList); + gRecipeMgr->UpdateEditRecipeList(m_EditRecipeList,m_EditRecipeInfoList); + GetDlgItem(IDC_CUR_EDIT_SUB_RCP_NAME)->SetWindowText(gRecipeMgr->GetCurEditSubRecipeInfo()); + GetDlgItem(IDC_CUR_EDIT_RCP_PATH)->SetWindowText(gRecipeMgr->GetCurEditRecipeInfo()); + HideEditRecipeParItem(); + +} +void CDlgChildRecipe::HideEditRecipeParItem() +{ + GetDlgItem(IDC_EDIT_PAR_DOUBLE)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_SEL_BOOL_VAL_COMBO)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_SEL_SCAN_AREA_COMBO)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_SEL_AREA_IDX_COMBO)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_SEL_OFFSET_TAB_COMBO)->ShowWindow(SW_HIDE); +} + +void CDlgChildRecipe::OnBnClickedSubRecipeMoveUp() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedSubRecipeMoveUp"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(gRecipeMgr->MoveSubRecipe(true)) + { + gRecipeMgr->UpdateEditSubRecipeList(m_EditSubRecipeList); + GetDlgItem(IDC_CUR_EDIT_SUB_RCP_NAME)->SetWindowText(gRecipeMgr->GetCurEditSubRecipeInfo()); + } +} + + +void CDlgChildRecipe::OnBnClickedSubRecipeMoveDown() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedSubRecipeMoveDown"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(gRecipeMgr->MoveSubRecipe(false)) + { + gRecipeMgr->UpdateEditSubRecipeList(m_EditSubRecipeList); + GetDlgItem(IDC_CUR_EDIT_SUB_RCP_NAME)->SetWindowText(gRecipeMgr->GetCurEditSubRecipeInfo()); + } +} +//recipe Ƚ +void CDlgChildRecipe::OnBnClickedRcpCompareBtn() +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_CheckRecipe",true)) + return; + CDlgRecipeCompare dlg; + dlg.DoModal(); +} + +#if 1 +//recipe б +void CDlgChildRecipe::OnNMClickEditRecipeList(NMHDR *pNMHDR, LRESULT *pResult) +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",false)) + return; + HideEditRecipeParItem(); + *pResult = 0; + NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + int Row = pNMListView->iItem; + if(Row >= 0)//к + { + CListCtrl &ListCtrl = m_EditRecipeList; + int Col = pNMListView->iSubItem; + if (Col == Rcp_List_Val_Col) + { + //¼ǰк + m_row = Row; + m_col = Col; + + CRect rc; + ListCtrl.GetSubItemRect(Row,Col, LVIR_LABEL, rc);//ȡľ + ListCtrl.ClientToScreen(&rc); + ScreenToClient(&rc); + CString s = ListCtrl.GetItemText(Row,Col);//ȡ + if((Row SetCurSel(Idx-1); + } + else if(Row ==Rcp_N2_Idx) + { + pComb = &m_SelBoolValComb; + int Idx = (s==BOOL_STR_ON)?(0):(1); + pComb->SetCurSel(Idx); + } + else if (Row == Rcp_UseCurN2Val_Idx) + { + pComb = &m_SelBoolValComb; + int Idx = (s == BOOL_STR_ON) ? (0) : (1); + pComb->SetCurSel(Idx); + } + #ifdef __OFFSET_TABLE__ + else if(Row ==Rcp_OffsetTab_Idx) + { + pComb = &m_SelOffsetTableComb; + } + #endif + if(pComb) + { + pComb->SetWindowText(s); + pComb->MoveWindow(&rc);//༭ƶ棬 + pComb->ShowDropDown();//Զ + pComb->ShowWindow(SW_SHOW);//ʾ༭ + pComb->SetFocus();//ʹ༭ȡý + } + } + } + } +} +//Edit 뽹ʱΪlist ֵ +void CDlgChildRecipe::OnEnKillfocusDoubleEdit() +{ + m_DoubleParEdit.ShowWindow(SW_HIDE); + if(m_col < 0 || m_row < 0) + return; + CString key; + m_DoubleParEdit.GetWindowText(key); + m_EditRecipeList.SetItemText(m_row, m_col, key); +} +//ѡļ +void CDlgChildRecipe::OnCbnSelchangeSelScanAreaCombo() +{ + gLogMgr->WriteDebugLog("Func---->OnCbnSelchangeSelScanAreaCombo"); + + int SelIdx = m_SelScanAreaComb.GetCurSel(); + + CString s; + s.Format("SelIdx = %d",SelIdx); + gLogMgr->WriteDebugLog(s); + //SelIdx Ӧɨ + CString AreaName = gWaferRecipeDataMgr->SelScanArea(SelIdx); + //Ĭѡһ + m_EditRecipeList.SetItemText(Rcp_AreaIdx_Idx,Rcp_List_Val_Col,Int2CString(1)); + //ɨ·(һ) + gRecipeMgr->CreatScanPath(AreaName,0); + + //ļΪlist item + m_SelScanAreaComb.ShowWindow(SW_HIDE); + if(m_col < 0 || m_row < 0) + return; + m_EditRecipeList.SetItemText(m_row, m_col, AreaName); +} +//ѡOffsetTable ļ +void CDlgChildRecipe::OnCbnSelchangeSelOffsetTableCombo() +{ + gLogMgr->WriteDebugLog("Func---->OnCbnSelchangeSelOffsetTableCombo"); + + int SelIdx = m_SelOffsetTableComb.GetCurSel(); + + CString s; + s.Format("SelIdx = %d",SelIdx); + gLogMgr->WriteDebugLog(s); + CString OffsetTableName = gWaferRecipeDataMgr->SelOffsetTable(SelIdx); + //ļΪlist item + m_SelOffsetTableComb.ShowWindow(SW_HIDE); + if(m_col < 0 || m_row < 0) + return; + m_EditRecipeList.SetItemText(m_row, m_col, OffsetTableName); +} + +//ѡ +void CDlgChildRecipe::OnCbnSelchangeSelAreaIdxCombo() +{ + int SelIdx = m_SelScanAreaIdxComb.GetCurSel(); + CString AreaName = m_EditRecipeList.GetItemText(Rcp_AreaName_Idx,Rcp_List_Val_Col);//ȡArea + gRecipeMgr->CreatScanPath(AreaName,SelIdx); + + //ļΪlist item + m_SelScanAreaIdxComb.ShowWindow(SW_HIDE); + if(m_col < 0 || m_row < 0) + return; + m_EditRecipeList.SetItemText(m_row, m_col, Int2CString(SelIdx+1)); +} +void CDlgChildRecipe::OnCbnSelchangeSelBoolValCombo() +{ + int SelIdx = m_SelBoolValComb.GetCurSel(); + //ļΪlist item + m_SelBoolValComb.ShowWindow(SW_HIDE); + if(m_col < 0 || m_row < 0) + return; + CString s = (SelIdx==0)?(BOOL_STR_ON):(BOOL_STR_OFF); + m_EditRecipeList.SetItemText(m_row, m_col,s); +} +// +void CDlgChildRecipe::OnBnClickedEditParSaveBtn() +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!UpdateData(TRUE)) + return; + gRecipeMgr->SaveEditRecipePar(m_EditRecipeList,m_EditRecipeInfoList); +} +#endif + +//ѯǰѡrecipe history +void CDlgChildRecipe::OnBnClickedRcpHistoryBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedRcpHistoryBtn"); + CString RecipeName = m_CurSelRecipeName; + if(RecipeName!="") + { + CDlgChildParaHistory *pDlg = dynamic_cast(gChildParaHistory); + pDlg->SearchByName(RecipeName); + + gDlgDeviceMain->OnBnClickedRecordBtn(); + gDlgDeviceMain->OnBnClickedModuleChildViewBtn4(); + } +} +void CDlgChildRecipe::OnBnClickedRcpOffsetTab() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedRcpOffsetTab"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_CheckRecipe",true)) + return; + CDlgOffsetTable dlg; + dlg.DoModal(); + #ifdef __OFFSET_TABLE__ + gWaferRecipeDataMgr->InitOffsetTableComb(m_SelOffsetTableComb); + #endif +} +//ǿˢRecipe Ϣ +void CDlgChildRecipe::OnBnClickedUpdateRecipeBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedUpdateRecipeBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_CheckRecipe",true)) + return; + CMsgBox MsgBox; + if(MsgBox.ConfirmOkCancel("ˢrecipe б?")) + { + gRecipeMgr->UpdateRecipeGroupInfo(); + m_NewRecipeGroupComb.SetCurSel(-1); + OnCbnSelchangeNewRecipeGroupCombo(); + } +} diff --git a/LaipuDrawing/DlgChildRecipe.h b/LaipuDrawing/DlgChildRecipe.h new file mode 100644 index 0000000..c832d9d --- /dev/null +++ b/LaipuDrawing/DlgChildRecipe.h @@ -0,0 +1,102 @@ + +#pragma once +#include "MyDlgView.h" +#include "GlobalDefine.h" +#include "RecipeMgr.h" + +//double Ϳؼ +class CDoubleParItem +{ +public: + CDoubleParItem() + { + }; +public: + int m_NameItemID;//ֿؼID + int m_ValItemID;//ֵؼID +}; + + +class CDlgChildRecipe : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildRecipe) + +public: + CDlgChildRecipe(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildRecipe(); + virtual void UpdateLanguageTxt(); + virtual void ChangeItemState(); + virtual void SetTextCtrlItemID(); + void InitDialogItem(); + // Ի + enum { IDD = IDD_CHILD_RECIPE }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + void OnTimer(UINT nIDEvent); + void OnDrawEditRecipeList( NMHDR* pNMHDR, LRESULT* pResult ); + void OnDrawEditRecipeInfoList( NMHDR* pNMHDR, LRESULT* pResult ); + DECLARE_MESSAGE_MAP() +private: + void UpdateRecipeParInfo(); + void InitParIDVec(); + void UpdateAreaIdxCombo(); + bool SaveCurSelRecipe(); + void ResetEditRecipeItem(); + void HideEditRecipeParItem(); +private: + CString m_CurSelRecipeName; + vector m_DoubleParItemVec;//double ֵؼ + + CComboBox m_NewRecipeGroupComb;//ѡб + CListCtrl m_GroupRecipeList;//Group recipe list + CListCtrl m_EditRecipeList;//Edit recipe list + CListCtrl m_EditRecipeInfoList;//ʾlist + CListCtrl m_EditSubRecipeList;//Edit Sub recipe list + CComboBox m_EditRecipeParComb; + + + double m_EditRecipeParVal; + CString m_EditRecipeParName; + + + + CEdit m_DoubleParEdit;//ڱ༭doubleı༭ + CComboBox m_SelScanAreaComb; + CComboBox m_SelScanAreaIdxComb; + CComboBox m_SelBoolValComb; + CComboBox m_SelOffsetTableComb; + int m_row;//ѡ + int m_col;//ѡ +public: + afx_msg void OnBnClickedLaserPowCheck(); + afx_msg void OnBnClickedRecipeNameBtn(); + afx_msg void OnBnClickedGroupNameBtn(); + afx_msg void OnBnClickedRecipeCopyBtn(); + afx_msg void OnBnClickedRecipeMoveBtn(); + afx_msg void OnBnClickedOpenViewDlgBtn(); + afx_msg void OnBnClickedAddGroupBtn(); + afx_msg void OnBnClickedDelGroupBtn(); + afx_msg void OnBnClickedAddRecipeBtn(); + afx_msg void OnBnClickedDelRecipeBtn(); + afx_msg void OnBnClickedRecipeToEditBtn(); + afx_msg void OnCbnSelchangeNewRecipeGroupCombo(); + afx_msg void OnNMClickGroupRecipeList(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnNMClickEditRecipeList(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnNMClickEditSubRecipeList(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedEditParSaveBtn(); + afx_msg void OnBnClickedAddSubRecipeBtn(); + afx_msg void OnBnClickedDelSubRecipeBtn(); + afx_msg void OnBnClickedSubRecipeMoveUp(); + afx_msg void OnBnClickedSubRecipeMoveDown(); + afx_msg void OnCbnSelchangeSelScanAreaCombo(); + afx_msg void OnCbnSelchangeSelOffsetTableCombo(); + afx_msg void OnCbnSelchangeSelAreaIdxCombo(); + afx_msg void OnCbnSelchangeSelBoolValCombo(); + afx_msg void OnBnClickedRenameSubRecipeBtn(); + afx_msg void OnBnClickedRcpCompareBtn(); + afx_msg void OnEnKillfocusDoubleEdit(); + afx_msg void OnBnClickedRcpHistoryBtn(); + afx_msg void OnBnClickedRcpOffsetTab(); + afx_msg void OnBnClickedUpdateRecipeBtn(); +}; diff --git a/LaipuDrawing/DlgChildWaferHistory.cpp b/LaipuDrawing/DlgChildWaferHistory.cpp new file mode 100644 index 0000000..d999862 --- /dev/null +++ b/LaipuDrawing/DlgChildWaferHistory.cpp @@ -0,0 +1,425 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgChildWaferHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "CStringFuc.h" +#include "MsgBox.h" + + +IMPLEMENT_DYNAMIC(CDlgChildWaferHistory, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgChildWaferHistory, CMyDlgView) + + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgChildWaferHistory::OnBnClickedSearchBtn) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgChildWaferHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgChildWaferHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BTN2, &CDlgChildWaferHistory::OnBnClickedExport) + ON_BN_CLICKED(IDC_SEARCH_BTN3, &CDlgChildWaferHistory::OnBnClickedSearchByDate) + ON_BN_CLICKED(IDC_SEARCH_BY_RANGE_BTN, &CDlgChildWaferHistory::OnBnClickedSearchByRangeBtn) +END_MESSAGE_MAP() + +#define DATA_PATH "\\MonitoringData\\WaferProcessData\\" + + +#define Data_List_Item_Cnt 60 +CDlgChildWaferHistory::CDlgChildWaferHistory(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgChildWaferHistory::IDD, pParent) +, m_SelDate(COleDateTime::GetCurrentTime()), m_SelDateStart(COleDateTime::GetCurrentTime()), m_SelDateEnd(COleDateTime::GetCurrentTime()) +{ + +} + +CDlgChildWaferHistory::~CDlgChildWaferHistory() +{ +} + +void CDlgChildWaferHistory::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, IDC_ANNEAL_DATA_LIST, m_DataList); + DDX_DateTimeCtrl(pDX, IDC_DATETIMEPICKER1, m_SelDate); + DDX_DateTimeCtrl(pDX, IDC_DATETIME_START_PICKER, m_SelDateStart); + DDX_DateTimeCtrl(pDX, IDC_DATETIME_END_PICKER, m_SelDateEnd); + DDX_Text(pDX, IDC_SEARCH_LOTID, m_SearchLotID); +} + +BOOL CDlgChildWaferHistory::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + + UpdateData(FALSE); + return TRUE; +} +//Ӧview 򿪵ʱ +void CDlgChildWaferHistory::OnViewOpen() +{ + if(m_bFirstOpen) + { + OnBnClickedSearchBtn(); + m_bFirstOpen = false; + } +} +//:ȡ :· +void CDlgChildWaferHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(DATA_PATH); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgChildWaferHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgChildWaferHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgChildWaferHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find("xlsx")!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgChildWaferHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgChildWaferHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +void CDlgChildWaferHistory::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgChildWaferHistory::InitDataList() +{ + //÷ + m_DataList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + //m_DataList.InsertColumn(0,"Idx",LVCFMT_LEFT,50,-1); + CString s; + for(int k=0;k(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find("xlsx")!=-1) + { + CFileMgr FileMgr; + m_DataList.DeleteAllItems(); + //ɾе + while (m_DataList.DeleteColumn(0)); + + //鿴ScanTraceCoordData ҪProcessStateData + //anneal в鿴ScanTraceCoordData + if(strPath.Find("ProcessMonitoringData")!=-1 ||strPath.Find("ScanTraceCoordData")!=-1)//ѵһед + { + CString Path = strPath; + Path.Replace("ScanTraceCoordData","ProcessStateData"); + if(!FileMgr.IsFileExist(Path)) + { + CMsgBox MsgBox; + MsgBox.Show("Can not Open ScanTraceCoordData Now"); + *pResult = 0; + return; + } + } + vector> StrVec; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_DataList.SetItemText(k,i,StrVec[k][i]);// + } + } + } + *pResult = 0; +} + +void CDlgChildWaferHistory::OnBnClickedExport() +{ + CFileMgr FileMgr; + bool bFile = m_CurSelPath.Find(".xlsx") > 0; + CString destDir; + if (bFile) + { + CFileDialog dlg( FALSE, _T(".xlsx"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("ļ(*.xlsx)|*.xlsx")); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } + else + { + CFolderPickerDialog dlg(NULL, 0, this, 0); + if (dlg.DoModal() == IDOK) + { + destDir = dlg.GetPathName(); + FileMgr.CopyDirOrFile(m_CurSelPath, destDir); + } + } +} +#if 1 +void CDlgChildWaferHistory::GetLogicalDrives_ByDay(HTREEITEM hParent, COleDateTime SelDate) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(DATA_PATH); + CString DateStr = SelDate.Format("%Y\\%m\\%d\\"); + path += DateStr; + m_tree.InsertItem(path, hParent); //ڸڵhParent̷ +} +//ղѯ +void CDlgChildWaferHistory::OnBnClickedSearchByDate() +{ + UpdateData(TRUE); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root");//ڵ + GetLogicalDrives_ByDay(m_hRoot,m_SelDate); //Զ庯 ȡ + GetDriveDir(m_hRoot);//Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); // չб +} +void CDlgChildWaferHistory::GetDriveDir_ByDayRange(HTREEITEM hParent,COleDateTime SelDateStart,COleDateTime SelDateEnd) +{ + CTime tt1( SelDateEnd.GetYear() , SelDateEnd.GetMonth() , SelDateEnd.GetDay() , SelDateEnd.GetHour() , SelDateEnd.GetMinute() , SelDateEnd.GetSecond() ) ; + CTime tt2( SelDateStart.GetYear() , SelDateStart.GetMonth() , SelDateStart.GetDay() , SelDateStart.GetHour() , SelDateStart.GetMinute() , SelDateStart.GetSecond() ) ; + CTimeSpan span = tt1 - tt2 ; + int iDay = span.GetDays()+1; + if(iDay>100) + { + CMsgBox MsgBox; + MsgBox.Show("ѯܳ100"); + return; + } + GetDlgItem(IDC_SEARCH_RET_DAYS)->SetWindowText(Int2CString(iDay));// + + int WaferHistoryCnt = 0;//ѯ¼ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + HTREEITEM hChild2; + bool bFirst = true; + CFileMgr FileMgr; + CString ProcessDataPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(DATA_PATH); + while(SelDateStart<=SelDateEnd) + { + //ռǰCurDate + int StartY = SelDateStart.GetYear(); + int StartM = SelDateStart.GetMonth(); + int StartD = SelDateStart.GetDay(); + CString DayPath; + DayPath += Int2Str_LeftZero(StartY)+"\\"; + DayPath += Int2Str_LeftZero(StartM)+"\\"; + DayPath += Int2Str_LeftZero(StartD)+"\\"; + CString DatePath = ProcessDataPath+DayPath; + if(FileMgr.IsDirectoryExists(DatePath)) + { + //ռDatePath ChildDir + vector NameVec; + vector FilePathVec; + FileMgr.GetChildFileOrDirName(true,DatePath,FilePathVec,""); + int size = FilePathVec.size(); + for(int k=0;kSetWindowText(Int2CString(WaferHistoryCnt));//¼ +} +//ղѯ +void CDlgChildWaferHistory::OnBnClickedSearchByRangeBtn() +{ + gLogMgr->WriteDebugLog("Func-->OnBnClickedSearchByRangeBtn"); + UpdateData(TRUE); + if(m_SelDateStart>m_SelDateEnd) + { + CMsgBox MsgBox; + MsgBox.Show("ʱ䷶Χ"); + return; + } + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root");//ڵ + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(DATA_PATH); + m_tree.InsertItem(path, m_hRoot);//ڸڵhParent̷ + GetDriveDir_ByDayRange(m_hRoot,m_SelDateStart,m_SelDateEnd);//Զ庯 ȡ + m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб +} +#endif diff --git a/LaipuDrawing/DlgChildWaferHistory.h b/LaipuDrawing/DlgChildWaferHistory.h new file mode 100644 index 0000000..72760ee --- /dev/null +++ b/LaipuDrawing/DlgChildWaferHistory.h @@ -0,0 +1,52 @@ +#pragma once +#include "MyDlgView.h" +#include "afxdtctl.h" +#include "ATLComTime.h" + +class CDlgChildWaferHistory : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgChildWaferHistory) + +public: + CDlgChildWaferHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgChildWaferHistory(); + virtual void OnViewOpen();//Ӧview 򿪵ʱ + void InitDataList(); + void UpdateDataList(CString FilePath); + CString GetDateStr(CTime &DateTime); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_CHILD_WAFER_HISTORY }; +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CListCtrl m_DataList; + CString m_CurSelPath;//еǰѡеļļ· + + // ǰѡе + COleDateTime m_SelDate; + + COleDateTime m_SelDateStart; + COleDateTime m_SelDateEnd; + CString m_SearchLotID; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() + +public: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives_ByDay(HTREEITEM hParent,COleDateTime SelDate); + void GetDriveDir_ByDayRange(HTREEITEM hParent,COleDateTime SelDateStart,COleDateTime SelDateEnd); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedExport(); + afx_msg void OnBnClickedSearchByDate(); + + afx_msg void OnBnClickedSearchByRangeBtn(); +}; diff --git a/LaipuDrawing/DlgCreatOffsetTable.cpp b/LaipuDrawing/DlgCreatOffsetTable.cpp new file mode 100644 index 0000000..da4b8e5 --- /dev/null +++ b/LaipuDrawing/DlgCreatOffsetTable.cpp @@ -0,0 +1,49 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgCreatOffsetTable.h" +#include "MsgBox.h" + + + +IMPLEMENT_DYNAMIC(CDlgCreatOffsetTable, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgCreatOffsetTable, CDialogEx) + ON_BN_CLICKED(IDOK,OnBnClickedOk) +END_MESSAGE_MAP() + + +CDlgCreatOffsetTable::CDlgCreatOffsetTable(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgCreatOffsetTable::IDD, pParent) +{ +} + +CDlgCreatOffsetTable::~CDlgCreatOffsetTable() +{ +} + +void CDlgCreatOffsetTable::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Text(pDX,IDC_NAME_EDIT,m_EditName); +} + +BOOL CDlgCreatOffsetTable::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + + UpdateData(FALSE); + return TRUE; +} + +void CDlgCreatOffsetTable::OnBnClickedOk() +{ + UpdateData(TRUE); + if(m_EditName == "") + { + CMsgBox MsgBox; + MsgBox.Show("ƲΪ"); + return; + } + OnOK(); +} \ No newline at end of file diff --git a/LaipuDrawing/DlgCreatOffsetTable.h b/LaipuDrawing/DlgCreatOffsetTable.h new file mode 100644 index 0000000..4d7ba71 --- /dev/null +++ b/LaipuDrawing/DlgCreatOffsetTable.h @@ -0,0 +1,21 @@ +#pragma once + +class CDlgCreatOffsetTable : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgCreatOffsetTable) + +public: + CDlgCreatOffsetTable(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgCreatOffsetTable(); + void SetEditName(CString s){m_EditName = s;}; + CString GetEditName(){return m_EditName;}; +// Ի + enum { IDD = IDD_OFFSET_TAB_CREATE_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + afx_msg void OnBnClickedOk(); + DECLARE_MESSAGE_MAP() +private: + CString m_EditName; +}; diff --git a/LaipuDrawing/DlgDeviceMain.cpp b/LaipuDrawing/DlgDeviceMain.cpp new file mode 100644 index 0000000..c848145 --- /dev/null +++ b/LaipuDrawing/DlgDeviceMain.cpp @@ -0,0 +1,752 @@ + +#include "stdafx.h" +#include "DlgDeviceMain.h" +#include "afxdialogex.h" +#include "CommonFlowMgr.h" +#include "LogMgr.h" +#include "AuthorityMgr.h" +#include "AllThreadMgr.h" +#include "CStringFuc.h" +#include "GlobalFunction.h" +#include "DlgChildWaferHistory.h" +#include "ProgramLaserTuiHuo.h" +#include "LogMgr.h" +#include "AuthorityMgr.h" +#include "WarningMgr.h" +#include "DlgChildRecipe.h" +#include "DlgAuthorityLogin.h" +#include "ProgramLaserTuiHuo.h" +#include "AllThreadMgr.h" +#include "LaiPuLaser.h" +#include "MyDlgView.h" +#include "EncryptionMgr.h" +#include "Laser.h" +#include "GlobalDrawMgr.h" +#include "LanguageMgr.h" +#include "CommonFlowMgr.h" +#include "MarkArea.h" +#include "FileMgr.h" +#include "WorkCmdInvoker.h" +#include "DlgChildEventLog.h" +#include "DlgChildDataAnalysis.h" +#include "DlgChildAlarmLog.h" +#include "DlgChildCheckHistory.h" +#include "DlgChildParaHistory.h" +#include "DlgChildRealTimeDataHistory.h" +#include "DlgChildBeamDataHistory.h" +#include "DlgChildConfigHistory.h" +#include "DlgAuthorityAccount.h" +#include "DlgChildLoginHistory.h" +#include "DlgChildJobHistory.h" + + +#define UPDATE_INFO_TIMER 1 +#define UPDATE_INFO_TIMER_DELAY 1000 + + + + +#define SET_DLG_SIZE_TIMER 2 +#define SET_DLG_SIZE_TIMER_DELAY 500 + +#define ID_READ_LASER_DIS_METER_TIMER 3 + +#define SWITCH_DLG_TIMER 4 +#define SWITCH_DLG_TIMER_DELAY 100 + +#define MAX_MODULE_CHILD_VIEW_CNT 12//ӽ + +#define UPDATE_DATE_TIMER 5 +#define UPDATE_DATE_TIMER_DELAY 200 + +#define LAIPU_APP_WNDS_NAME "LaiPuLaser" //ҵĴ +HWND gLaipuAppHwnd = 0; +//ھ,Ҫôڳ +BOOL CALLBACK EnumLaipuAppWnds( HWND hwnd, LPARAM lParam ) +{ + const int size1 = 1024; + char szClass[size1]; + if( !GetWindow( hwnd, GW_OWNER ) && IsWindowVisible( hwnd ) ) // ˵ʾĴ + { + GetClassName( hwnd, szClass, size1 ); + // ˵// ˵ + if( strcmp( szClass, "Shell_TrayWnd" ) != 0 && strcmp( szClass, "Progman" ) != 0 ) + { + if(GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW) + { + return true; + } + char szTitle[size1]; + GetWindowText( hwnd, szTitle,size1); + CString s(szTitle); + if(s.Find(_T(LAIPU_APP_WNDS_NAME), 0)!=-1) + { + gLaipuAppHwnd = hwnd; + } + } + } + return TRUE; +} + + +IMPLEMENT_DYNAMIC(CDlgDeviceMain, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgDeviceMain, CMyDlgView) + ON_WM_TIMER() + ON_BN_CLICKED(CHILD_DEVICE_STATE_BTN, &CDlgDeviceMain::OnBnClickedDeviceStateBtn) + ON_BN_CLICKED(CHILD_PCS_BTN, &CDlgDeviceMain::OnBnClickedPCS) + ON_BN_CLICKED(CHILD_LOGIN_BTN, &CDlgDeviceMain::OnBnClickedLoginBtn) + ON_BN_CLICKED(CHILD_RECORD_BTN, &CDlgDeviceMain::OnBnClickedRecordBtn) + ON_BN_CLICKED(CHILD_CONFIG_BTN, &CDlgDeviceMain::OnBnClickedConfigBtn) + + ON_BN_CLICKED(CHILD_RECIPE_BTN, &CDlgDeviceMain::OnBnClickedRecipeBtn) + ON_BN_CLICKED(NEW_LOGO_BTN, &CDlgDeviceMain::OnBnClickedLogoBtn) + ON_BN_CLICKED(IDC_PCS_TEST_BTN, &CDlgDeviceMain::OnBnClickedPcsTestBtn) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN1, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn1) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN2, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn2) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN3, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn3) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN4, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn4) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN5, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn5) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN6, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn6) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN7, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn7) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN8, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn8) + + ON_BN_CLICKED(NEW_SUB_MODULE_BTN9, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn9) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN10, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn10) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN11, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn11) + ON_BN_CLICKED(NEW_SUB_MODULE_BTN12, &CDlgDeviceMain::OnBnClickedModuleChildViewBtn12) + + ON_BN_CLICKED(CHILD_CLOSE_APP_BTN, &CDlgDeviceMain::OnBnClickedCloseAppBtn) + ON_BN_CLICKED(CHILD_SHOW_WINDOW_MIN_BTN, &CDlgDeviceMain::OnBnClickedShowWindowMinBtn) + ON_BN_CLICKED(CHILD_USER_MGR_BTN, &CDlgDeviceMain::OnBnClickedUserMgrBtn) +END_MESSAGE_MAP() + +CDlgDeviceMain *gDlgDeviceMain = NULL; +CDlgDeviceMain::CDlgDeviceMain(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgDeviceMain::IDD, pParent) +{ + //m_TestStr1 = "33554431"; + m_TestStr1 = "0"; + m_WarningTimes = 0;//Ʊʱť˸ + for(int k=0;kCreate(gChildRecipe->GetIDD()); + gChildWaferHistory = new CDlgChildWaferHistory; + gChildWaferHistory->Create(gChildWaferHistory->GetIDD()); + gChildEventLog = new CDlgChildEventLog; + gChildEventLog->Create(gChildEventLog->GetIDD()); + gChildAlarmLog = new CDlgChildAlarmLog; + gChildAlarmLog->Create(gChildAlarmLog->GetIDD()); + + gChildCheckHistory = new CDlgChildCheckHistory; + gChildCheckHistory->Create(gChildCheckHistory->GetIDD()); + + gDlgChildRealTimeDataHistory = new CDlgChildRealTimeDataHistory; + gDlgChildRealTimeDataHistory->Create(gDlgChildRealTimeDataHistory->GetIDD()); + + gDlgChildBeamDataHistory = new CDlgChildBeamDataHistory; + gDlgChildBeamDataHistory->Create(gDlgChildBeamDataHistory->GetIDD()); + + gDlgChildConfigHistory = new CDlgChildConfigHistory; + gDlgChildConfigHistory->Create(gDlgChildConfigHistory->GetIDD()); + + gChildParaHistory = new CDlgChildParaHistory; + gChildParaHistory->Create(gChildParaHistory->GetIDD()); + + gDlgChildLoginHistory = new CDlgChildLoginHistory; + gDlgChildLoginHistory->Create(gDlgChildLoginHistory->GetIDD()); + + gDlgChildJobHistory = new CDlgChildJobHistory; + gDlgChildJobHistory->Create(gDlgChildJobHistory->GetIDD()); + + Sleep(200); + SetActiveView(_ChildView_Recipe); + //öԻijߴ + SetTimer(SET_DLG_SIZE_TIMER,SET_DLG_SIZE_TIMER_DELAY,NULL); + + SetTimer(UPDATE_INFO_TIMER,UPDATE_INFO_TIMER_DELAY,NULL); + return TRUE; +} +//ֹ汻ر +void CDlgDeviceMain::OnCancel() +{ + //CDialogEx::OnCancel(); +} + +void CDlgDeviceMain::OnTimer(UINT nIDEvent) +{ + if(nIDEvent == UPDATE_INFO_TIMER) + { + KillTimer(UPDATE_INFO_TIMER); + UpdateInfoExt(); + SetTimer(UPDATE_INFO_TIMER,UPDATE_INFO_TIMER_DELAY,NULL); + } + if(nIDEvent == SET_DLG_SIZE_TIMER) + { + KillTimer(SET_DLG_SIZE_TIMER); + SetWndSize(); + } + if(nIDEvent == SWITCH_DLG_TIMER) + { + KillTimer(SWITCH_DLG_TIMER); + SetActiveView(m_SwitchChildViewType); + } + + CDialog::OnTimer(nIDEvent); +} +//öԻĴС +void CDlgDeviceMain::SetWndSize() +{ + // + //GetFrame()->ShowWindowMin(); + //Sleep(1000); + // + //GetFrame()->ShowWindowMax(); + + //Ĭѡrcp + //OnBnClickedRecipeBtn(); + OnBnClickedRecordBtn(); + + //Ĭϵ¼ + if(!gAuthorityMgr->CheckAuthority(_Authority_Factory,false)) + { + //OnBnClickedLoginBtn();//22-08-02 + } +} +//沼 +void CDlgDeviceMain::AdjustLayout() +{ + if(gEncryptionMgr->IsbRunAtNoteBook()) + return; + int w = gDraw->GetDlgMainWidth(); + //GetFrame()->m_DeviceMainPane.MoveWindow(CRect(35,0,w,1100),TRUE,NULL); +} +void CDlgDeviceMain::SetTextCtrlItemID() +{ +} +void CDlgDeviceMain::UpdateLanguageTxt() +{ + +} + +void CDlgDeviceMain::UpdateInfoExt() +{ + if(gExitApp) + return; + + //û + SetItemText(IDC_CUR_USER_NAME,gAuthorityMgr->GetCurUserName()); + //˻ + SetItemText(IDC_CUR_USER_AUTH,gAuthorityMgr->GetCurAccountName()); + //汾 + SetItemText(IDC_CUR_SOFT_VISION,gProgramLaserTuiHuo->GetCurSoftVision()); +} +void CDlgDeviceMain::SwitchChildDlg(EChildViewType ViewType) +{ + m_SwitchChildViewType = ViewType;//лӽ + SetTimer(SWITCH_DLG_TIMER,SWITCH_DLG_TIMER_DELAY,NULL); +} +#if 1 +// ʼλС(Ҫȸm_EditChild 󶨿ؼ) +void CDlgDeviceMain::InitChildArea() +{ + //һeidt ӽĴС + m_EditChild.GetWindowRect(m_rChildRect); + CRect rect; + GetWindowRect(rect); + + // 㳤 + m_rChildRect.bottom -= m_rChildRect.top; + m_rChildRect.right -= m_rChildRect.left; + + // λ + m_rChildRect.left -= rect.left; + m_rChildRect.top -= rect.top; + m_rChildRect.bottom += m_rChildRect.top; + m_rChildRect.right += m_rChildRect.left; +} +CString CDlgDeviceMain::GetModuleChildViewName(EChildViewType ChildViewType) +{ + CString Name; + switch(ChildViewType) + { + case _ChildView_PCS: + Name = "Process"; + break; + case _ChildView_WorkPrepare: + Name = "Work Prepare"; + break; + case _ChildView_WorkWaferCnt: + Name = "Work Wafer Cnt"; + break; + case _ChildView_Recipe: + Name = "Recipe༭"; + break; + case _ChildView_RecipeScanAreaEdit: + Name = "ͼα༭"; + break; + case _ChildView_LaserPathState: + Name = "Laser Path State"; + break; + case _ChildView_LaserDeviceState: + Name = "Laser Device State"; + break; + case _ChildView_Robot: + Name = "Robot"; + break; + case _ChildView_IOState: + Name = "IO State"; + break; + case _ChildView_DeviceMaintenance: + Name = "Maintenance"; + break; + case _ChildView_LaserPowCheck: + Name = "Laser Pow Check"; + break; + case _ChildView_SysParaSet: + Name = "Sys Para Set"; + break; + case _ChildView_EventLog: + Name = "Event"; + break; + case _ChildView_AlarmLog: + Name = "Alarm History"; + break; + case _ChildView_WaferHistory: + Name = "Wafer History"; + break; + case _ChildView_CheckHistory: + Name = "Check History"; + break; + case _ChildView_RealTimeDataHistory: + Name = "RealTime History"; + break; + case _ChildView_BeamDataHistory: + Name = "BeamData History"; + break; + case _ChildView_ConfigHistory: + Name = "Config History"; + break; + case _ChildView_JobHistory: + Name = "Job History"; + break; + case _ChildView_ParHistory: + Name = "Recipe History"; + break; + case _ChildView_LoginHistory: + Name = "Login History"; + break; + case _ChildView_DataAnalysis: + Name = "Data Analyse"; + break; + default: + break; + } + return Name; +} +#endif + +#if 1 +//lock ״̬ı +void CDlgDeviceMain::ChangeItemState() +{ + ChangeItemStateExt(); + + gChildPCS->ChangeItemState(); + gChildLaserPathState->ChangeItemState(); + gChildWaferHistory->ChangeItemState(); + gChildCheckHistory->ChangeItemState(); + gDlgChildRealTimeDataHistory->ChangeItemState(); + gDlgChildBeamDataHistory->ChangeItemState(); + gDlgChildConfigHistory->ChangeItemState(); + gChildSysParaSet->ChangeItemState(); + gChildRecipe->ChangeItemState(); + gChildIOState->ChangeItemState(); + gChildParaHistory->ChangeItemState(); + gDlgChildLoginHistory->ChangeItemState(); + gDlgChildJobHistory->ChangeItemState(); +} +void CDlgDeviceMain::ChangeItemStateExt() +{ + +} +#endif +#if 1//л +void CDlgDeviceMain::ResetModuleChildView() +{ + for(int k=0;kSetWindowText(ChildViewName); + + if(ChildViewName!="") + GetDlgItem(BtnId)->ShowWindow(SW_SHOW); + else + GetDlgItem(BtnId)->ShowWindow(SW_HIDE); + } + + //ĬѡһView + if(!m_ModuleChildViewVec.empty()) + SetActiveView(m_ModuleChildViewVec[0]); +} +void CDlgDeviceMain::OnBnClickedPCS() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedPCS"); + ResetModuleChildView(); + int idx = 0; + m_ModuleChildViewVec[idx++] = _ChildView_PCS; + m_ModuleChildViewVec[idx++] = _ChildView_WorkPrepare; + m_ModuleChildViewVec[idx++] = _ChildView_WorkWaferCnt; + UpdateModuleChildView(); +} +void CDlgDeviceMain::OnBnClickedRecipeBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedRecipeBtn"); + ResetModuleChildView(); + int idx = 0; + m_ModuleChildViewVec[idx++] = _ChildView_Recipe; + m_ModuleChildViewVec[idx++] = _ChildView_RecipeScanAreaEdit; + UpdateModuleChildView(); +} +void CDlgDeviceMain::OnBnClickedDeviceStateBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedDeviceStateBtn"); + ResetModuleChildView(); + int idx = 0; + m_ModuleChildViewVec[idx++] = _ChildView_LaserPathState; + m_ModuleChildViewVec[idx++] = _ChildView_LaserDeviceState; + m_ModuleChildViewVec[idx++] = _ChildView_Robot; + m_ModuleChildViewVec[idx++] = _ChildView_IOState; + UpdateModuleChildView(); +} + +void CDlgDeviceMain::OnBnClickedRecordBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedRecordBtn"); + ResetModuleChildView(); + int idx = 0; + m_ModuleChildViewVec[idx++] = _ChildView_EventLog; + m_ModuleChildViewVec[idx++] = _ChildView_WaferHistory; + m_ModuleChildViewVec[idx++] = _ChildView_CheckHistory; + m_ModuleChildViewVec[idx++] = _ChildView_ParHistory; + m_ModuleChildViewVec[idx++] = _ChildView_RealTimeDataHistory; + m_ModuleChildViewVec[idx++] = _ChildView_BeamDataHistory; + m_ModuleChildViewVec[idx++] = _ChildView_ConfigHistory; + m_ModuleChildViewVec[idx++] = _ChildView_AlarmLog; + m_ModuleChildViewVec[idx++] = _ChildView_LoginHistory; + m_ModuleChildViewVec[idx++] = _ChildView_JobHistory; + //m_ModuleChildViewVec[idx++] = _ChildView_DataAnalysis; + UpdateModuleChildView(); +} + + +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn1() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn1"); + SetActiveView(m_ModuleChildViewVec[0]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn2() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn2"); + if(_ChildView_RecipeScanAreaEdit == m_ModuleChildViewVec[1]) + { + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditScanArea",true)) + return; + GetFrame()->m_DlgGraphEdit.ShowAllItem(); + //棬༭ͼ + ShowWindow(SW_HIDE); + } + else + { + SetActiveView(m_ModuleChildViewVec[1]); + } +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn3() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn3"); + SetActiveView(m_ModuleChildViewVec[2]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn4() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn4"); + SetActiveView(m_ModuleChildViewVec[3]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn5() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn5"); + SetActiveView(m_ModuleChildViewVec[4]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn6() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn6"); + SetActiveView(m_ModuleChildViewVec[5]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn7() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn7"); + SetActiveView(m_ModuleChildViewVec[6]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn8() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn8"); + SetActiveView(m_ModuleChildViewVec[7]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn9() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn9"); + SetActiveView(m_ModuleChildViewVec[8]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn10() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn10"); + SetActiveView(m_ModuleChildViewVec[9]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn11() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn11"); + SetActiveView(m_ModuleChildViewVec[10]); +} +void CDlgDeviceMain::OnBnClickedModuleChildViewBtn12() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedModuleChildViewBtn12"); + SetActiveView(m_ModuleChildViewVec[11]); +} + + + + +#endif +#if 1 +#define PCS_TEST_FUNC1 "test " +#define PCS_TEST_FUNC2 "Init Port1 Wafer State" +#define PCS_TEST_FUNC3 "Init Port2 Wafer State" +#define PCS_TEST_FUNC4 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC5 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC6 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC7 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC8 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC9 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC10 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC11 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC12 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC13 "AREA༭" +#define PCS_TEST_FUNC14 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC15 "xxxxxxxxxxxxx" +#define PCS_TEST_FUNC16 "xxxxxxxxxxxxx" + +void CDlgDeviceMain::InitPcsTestComb() +{ + int Idx = 0; + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC1); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC2); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC3); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC4); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC5); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC6); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC7); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC8); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC9); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC10); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC11); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC12); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC13); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC14); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC15); + m_PcsTestComb.InsertString(Idx++,PCS_TEST_FUNC16); +} +//Թ +void CDlgDeviceMain::OnBnClickedPcsTestBtn() +{ + if(gAuthorityMgr->CheckAuthority(_Authority_Factory,true)==false) + return; + if(!UpdateData(TRUE)) + return; + + vector DBValVec; + CFileMgr FileMgr; + FileMgr.GetDoubleVal(m_TestStr1,DBValVec); + + CString CombStr; + GetDlgItem(IDC_PCS_TEST_COMBO)->GetWindowText(CombStr); + if(CombStr==PCS_TEST_FUNC1) + { + ShowWindow(SW_HIDE); + } + if(CombStr==PCS_TEST_FUNC2) + { + } + if(CombStr==PCS_TEST_FUNC3) + { + + } + if(CombStr==PCS_TEST_FUNC4) + { + } + if(CombStr==PCS_TEST_FUNC5) + { + + } + if(CombStr==PCS_TEST_FUNC6) + { + + + } + if(CombStr==PCS_TEST_FUNC7) + { + + } + if(CombStr==PCS_TEST_FUNC8) + { + + } + if(CombStr==PCS_TEST_FUNC9) + { + + } + if(CombStr==PCS_TEST_FUNC10) + { + + } + if(CombStr==PCS_TEST_FUNC11) + { + + } + if(CombStr==PCS_TEST_FUNC12) + { + + } + if(CombStr==PCS_TEST_FUNC13) + { + + } + if(CombStr==PCS_TEST_FUNC14) + { + + } + if(CombStr==PCS_TEST_FUNC15) + { + + } + if(CombStr==PCS_TEST_FUNC16) + { + + } +} +#endif + +void CDlgDeviceMain::OnBnClickedCloseAppBtn() +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_CloseApp",true)) + return; + gProgramLaserTuiHuo->CloseAppBySysMsg(); +} +void CDlgDeviceMain::OnBnClickedConfigBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedReStatrBtn"); + + gProgramLaserTuiHuo->ReStartApp(); +} + +void CDlgDeviceMain::OnBnClickedShowWindowMinBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedShowWindowMinBtn"); + GetFrame()->ShowWindowMin(); +} +//û +void CDlgDeviceMain::OnBnClickedUserMgrBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedUserMgrBtn"); + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_UserEdit",true)) + return; + CDlgAuthorityAccount dlg; + dlg.DoModal(); +} +//¼ +void CDlgDeviceMain::OnBnClickedLoginBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedLoginBtn"); + CDlgAuthorityLogin dlg; + dlg.DoModal(); +} +void CDlgDeviceMain::OnBnClickedLogoBtn() +{ + +} + diff --git a/LaipuDrawing/DlgDeviceMain.h b/LaipuDrawing/DlgDeviceMain.h new file mode 100644 index 0000000..bb5852f --- /dev/null +++ b/LaipuDrawing/DlgDeviceMain.h @@ -0,0 +1,77 @@ +#pragma once + +#include "MyBttom.h" +#include "MyPictrueBttom.h" +#include "MyDlgView.h" + + + + +class CDlgDeviceMain : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgDeviceMain) +public: + CDlgDeviceMain(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgDeviceMain(); + virtual void SetTextCtrlItemID(); + virtual void OnCancel(); + virtual void UpdateLanguageTxt();//лʾ + void ChangeItemState(); + void FuncExecute(); + void SwitchChildDlg(EChildViewType ViewType); +// Ի + enum { IDD = IDD_DEVICE_MAIN_DLG}; +private: + void UpdateInfoExt(); + + void SetWndSize(); + void ChangeItemStateExt(); + void AdjustLayout(); + void ResetModuleChildView(); + void UpdateModuleChildView(); + void InitPcsTestComb(); + + void InitChildArea(); + CString GetModuleChildViewName(EChildViewType ChildViewType); +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + void OnTimer(UINT nIDEvent); + afx_msg BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() +private: + CComboBox m_PcsTestComb;//Թ + CString m_TestStr1; + CString m_TestStr2; + CString m_EquipMsg; + + int m_WarningTimes;//Ʊʱť˸ + vector m_ModuleChildViewVec;//ǰģӽ + +public: + afx_msg void OnBnClickedDeviceStateBtn(); + afx_msg void OnBnClickedPCS(); + afx_msg void OnBnClickedLoginBtn(); + afx_msg void OnBnClickedRecordBtn(); + afx_msg void OnBnClickedConfigBtn(); + afx_msg void OnBnClickedRecipeBtn(); + afx_msg void OnBnClickedLogoBtn(); + afx_msg void OnBnClickedPcsTestBtn(); + + afx_msg void OnBnClickedModuleChildViewBtn1(); + afx_msg void OnBnClickedModuleChildViewBtn2(); + afx_msg void OnBnClickedModuleChildViewBtn3(); + afx_msg void OnBnClickedModuleChildViewBtn4(); + afx_msg void OnBnClickedModuleChildViewBtn5(); + afx_msg void OnBnClickedModuleChildViewBtn6(); + afx_msg void OnBnClickedModuleChildViewBtn7(); + afx_msg void OnBnClickedModuleChildViewBtn8(); + afx_msg void OnBnClickedModuleChildViewBtn9(); + afx_msg void OnBnClickedModuleChildViewBtn10(); + afx_msg void OnBnClickedModuleChildViewBtn11(); + afx_msg void OnBnClickedModuleChildViewBtn12(); + afx_msg void OnBnClickedCloseAppBtn(); + afx_msg void OnBnClickedShowWindowMinBtn(); + afx_msg void OnBnClickedUserMgrBtn(); +}; + +extern CDlgDeviceMain *gDlgDeviceMain; \ No newline at end of file diff --git a/LaipuDrawing/DlgGraphEdit.cpp b/LaipuDrawing/DlgGraphEdit.cpp new file mode 100644 index 0000000..a234a89 --- /dev/null +++ b/LaipuDrawing/DlgGraphEdit.cpp @@ -0,0 +1,329 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgGraphEdit.h" +#include "PropertieMgr.h" +#include "ModuleDeviceMgr.h" +#include "ModuleDrawMgr.h" +#include "GlobalFunction.h" +#include "ObjSortMgr.h" +#include "AuthorityMgr.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" +#include "WorkFileMgr.h" +#include "MsgBox.h" +#include "DlgChildRecipe.h" +#include "LanguageMgr.h" +#include "DlgDeviceMain.h" +#include "Layer.h" +#include "DlgMapHistory.h" + + +#define OPEN_MAIN_DLG_TIMER 1 +#define OPEN_MAIN_DLG_TIMER_DELAY 300 + + +IMPLEMENT_DYNAMIC(CDlgGraphEdit, CMyDlgView) +BEGIN_MESSAGE_MAP(CDlgGraphEdit, CMyDlgView) + ON_WM_TIMER() + ON_REGISTERED_MESSAGE(AFX_WM_PROPERTY_CHANGED,OnPropertyChanged) + ON_BN_CLICKED(IDC_PER_OBJ, OnBnClickedPerObjBtn) + ON_BN_CLICKED(IDC_NEXT_OBJ,OnBnClickedNextObjBtn) + ON_BN_CLICKED(IDC_FRIST_OBJ,OnBnClickedFristObjBtn) + ON_BN_CLICKED(IDC_SHOW_OBJ_IDX,OnBnClickedShowObjIdx) + ON_BN_CLICKED(IDC_INSERT,OnBnClickedInsertBtn) + ON_BN_CLICKED(IDC_REVERSE_ORDER,OnBnClickedReverseOrderBtn) + ON_BN_CLICKED(IDC_OBJ_SORT_BTN,OnBnClickedObjSortBtn) + ON_BN_CLICKED(ID_OPEN_OBJ_BTN, OnBnClickedOpenObjBtn) + ON_BN_CLICKED(ID_SAVE_OBJ_BTN, OnBnClickedSaveObjBtn) + ON_BN_CLICKED(NEW_ZOOM_FULL_BTN, &CDlgGraphEdit::OnBnClickedZoomFullBtn) + ON_BN_CLICKED(NEW_ZOOM_IN_BTN, &CDlgGraphEdit::OnBnClickedZoomInBtn) + ON_BN_CLICKED(NEW_ZOOM_OUT_BTN, &CDlgGraphEdit::OnBnClickedZoomOutBtn) + ON_STN_CLICKED(NEW_OPEN_MAIN_DLG_BTN, &CDlgGraphEdit::OnStnClickedOpenMainDlg) + ON_BN_CLICKED(IDC_CREAT_AREA_BTN, &CDlgGraphEdit::OnBnClickedCreatAreaBtn) + ON_BN_CLICKED(ID_OPEN_TXT_BTN, &CDlgGraphEdit::OnBnClickedOpenTxtBtn) + ON_BN_CLICKED(ID_SAVE_TXT_BTN, &CDlgGraphEdit::OnBnClickedSaveTxtBtn) + ON_BN_CLICKED(IDC_SHOW_OBJ_PT_COORD, &CDlgGraphEdit::OnBnClickedShowObjPtCoord) + ON_BN_CLICKED(NEW_OPEN_MAP_HISTORY_BTN, &CDlgGraphEdit::OnBnClickedOpenMapHistoryBtn) +END_MESSAGE_MAP() + + +CDlgGraphEdit::CDlgGraphEdit(CWnd* pParent /*=NULL*/) +: CMyDlgView(CDlgGraphEdit::IDD, pParent) +{ + m_InsertIdx = 1;//λõֵ + m_AreaCrossPtRange = 10;//ڴɨĽ㷶Χ + m_CreatAreaGap = 2;//ļmm +} + +CDlgGraphEdit::~CDlgGraphEdit() +{ +} + +void CDlgGraphEdit::DoDataExchange(CDataExchange* pDX) +{ + CMyDlgView::DoDataExchange(pDX); + DDX_Control(pDX, IDC_SCAN_DIR_COMBO2, m_ObjSortDirComb); + DDX_Control(pDX, IDC_PROPERTY_OBJ, m_ObjPropList); + DDX_Text(pDX, IDC_INSERT_IDX, m_InsertIdx); + DDX_Text(pDX, IDC_CROSS_PT_RANGE, m_AreaCrossPtRange); + DDX_Text(pDX, IDC_CREAT_AREA_GAP, m_CreatAreaGap); +} + +BOOL CDlgGraphEdit::OnInitDialog() +{ + CMyDlgView::OnInitDialog(); + // + ::DeleteObject(m_fntPropList.Detach()); + LOGFONT lf; + afxGlobalData.fontRegular.GetLogFont(&lf); + NONCLIENTMETRICS info; + info.cbSize = sizeof(info); + afxGlobalData.GetNonClientMetrics(info); + lf.lfHeight = info.lfMenuFont.lfHeight; + lf.lfWeight = info.lfMenuFont.lfWeight; + lf.lfItalic = info.lfMenuFont.lfItalic; + m_fntPropList.CreateFontIndirect(&lf); + + + InitObjSortDirComb(); + InitPropList(m_ObjPropList); + + ((CButton *)GetDlgItem(IDC_SHOW_OBJ_PT_COORD))->SetCheck(TRUE); + + SetTimer(OPEN_MAIN_DLG_TIMER,OPEN_MAIN_DLG_TIMER_DELAY,NULL); + + UpdateData(FALSE); + return TRUE; +} +void CDlgGraphEdit::OnTimer(UINT nIDEvent) +{ + if(nIDEvent == OPEN_MAIN_DLG_TIMER) + { + KillTimer(OPEN_MAIN_DLG_TIMER); + OnStnClickedOpenMainDlg(); + } + CDialog::OnTimer(nIDEvent); +} +void CDlgGraphEdit::ShowAllItem() +{ + GetDlgItem(ID_OPEN_OBJ_BTN)->ShowWindow(SW_SHOW); + GetDlgItem(ID_SAVE_OBJ_BTN)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_SHOW_OBJ_IDX)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_FRIST_OBJ)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_PER_OBJ)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NEXT_OBJ)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_STATIC_INSERT_IDX)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_INSERT)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_REVERSE_ORDER)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_STATIC_SORT_DIR)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_OBJ_SORT_BTN)->ShowWindow(SW_SHOW); + + GetDlgItem(NEW_ZOOM_IN_BTN)->ShowWindow(SW_SHOW); + GetDlgItem(NEW_ZOOM_OUT_BTN)->ShowWindow(SW_SHOW); + GetDlgItem(NEW_ZOOM_FULL_BTN)->ShowWindow(SW_SHOW); + + GetDlgItem(NEW_OPEN_MAIN_DLG_BTN)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_PROPERTY_OBJ)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_STATIC_OBJ_PAR)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_GROUP_S_SORT)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_SCAN_DIR_COMBO2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_INSERT_IDX)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_GROUP_SORT_ADJUST)->ShowWindow(SW_SHOW); + + gDraw->SetbObjEditMode(true); +} +void CDlgGraphEdit::UpdateLanguageTxt() +{ + +} +#if 1 +void CDlgGraphEdit::InitPropList(CMFCPropertyGridCtrl &PropertyGridCtrl) +{ + PropertyGridCtrl.SetFont(&m_fntPropList); + PropertyGridCtrl.SetVSDotNetLook(); + HDITEM item; + item.cxy=220;//һеĿ + item.mask=HDI_WIDTH; + PropertyGridCtrl.GetHeaderCtrl().SetItem(0, new HDITEM(item)); +} +//ԸıϢӦ +LRESULT CDlgGraphEdit::OnPropertyChanged(WPARAM,LPARAM lParam) +{ + gDrawPropertieMgr.OnPropertyChanged(lParam); + return 0; +} +//ͼб +void CDlgGraphEdit::UpdateObjPropList() +{ + m_ObjPropList.RemoveAll(); + gDrawPropertieMgr.DelAllPropertie(); + gModuleDrawMgr.InsertModuleGridProperty(0,m_ObjPropList); + //µ + m_ObjPropList.AdjustLayout(); +} +#endif +#if 1 +void CDlgGraphEdit::InitObjSortDirComb() +{ + int idx = 0; + m_ObjSortDirComb.InsertString(idx++,""); + m_ObjSortDirComb.InsertString(idx++,"ҵ"); + m_ObjSortDirComb.InsertString(idx++,"ϵ"); + m_ObjSortDirComb.InsertString(idx++,"µ"); + m_ObjSortDirComb.SetCurSel(0); +} + +//ѡһobj +void CDlgGraphEdit::OnBnClickedFristObjBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedFristObjBtn"); + CLayer &layer = gLayer; + layer.SelFirstObj(); +} +void CDlgGraphEdit::OnBnClickedPerObjBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedPerObjBtn"); + CLayer &layer = gLayer; + layer.SelborderObj(false); +} +void CDlgGraphEdit::OnBnClickedNextObjBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedNextObjBtn"); + CLayer &layer = gLayer; + layer.SelborderObj(true); +} +//Ƿʾ˳ +void CDlgGraphEdit::OnBnClickedShowObjIdx() +{ + gLayer.SetbShowObjIdx(((CButton*)GetDlgItem(IDC_SHOW_OBJ_IDX))->GetCheck()); + GetCurViewPtr()->RefreshView(); +} +//뵽λ +void CDlgGraphEdit::OnBnClickedInsertBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedInsertBtn"); + if(!UpdateData(TRUE)) + return; + CLayer &layer = gLayer; + CObjContainer &ObjContainer = layer.GetObjContainer(); + int SelObjCnt = ObjContainer.GetSelObjCnt(); + layer.SelectedObjInsertToIdx(m_InsertIdx); + m_InsertIdx += SelObjCnt; + UpdateData(FALSE); +} +// +void CDlgGraphEdit::OnBnClickedReverseOrderBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedReverseOrderBtn"); + CLayer &layer = gLayer; + layer.ReverseSelObj(); +} +//S +void CDlgGraphEdit::OnBnClickedObjSortBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedObjSortBtn"); + int SortDirIdx = m_ObjSortDirComb.GetCurSel();//ɨ跽 + DIRECTION SortDir; + switch(SortDirIdx) + { + case 0:// + SortDir = _DIR_R; + break; + case 1://ҵ + SortDir = _DIR_L; + break; + case 2://ϵ + SortDir = _DIR_D; + break; + case 3://µ + SortDir = _DIR_U; + break; + default: + return; + } + + CObjSortMgr ObjSortMgr; + ObjSortMgr.SortObjByDir(SortDir); + + GetCurViewPtr()->RefreshView(); +} + +#endif +#if 1 +void CDlgGraphEdit::OnBnClickedOpenObjBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedOpenObjBtn"); + CWorkFileMgr WorkFileMgr; + WorkFileMgr.OpenObjFile(); +} +void CDlgGraphEdit::OnBnClickedSaveObjBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedSaveObjBtn"); + CWorkFileMgr WorkFileMgr; + WorkFileMgr.SaveObjFile(); +} +void CDlgGraphEdit::OnBnClickedOpenTxtBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedOpenTxtBtn"); + CWorkFileMgr WorkFileMgr; + WorkFileMgr.OpenObjTxtFile(); +} +void CDlgGraphEdit::OnBnClickedSaveTxtBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedSaveTxtBtn"); + CWorkFileMgr WorkFileMgr; + WorkFileMgr.SaveObjTxtFile(); +} +#endif +#if 1 +void CDlgGraphEdit::OnBnClickedZoomFullBtn() +{ + m_pView->DoZoomFull(); +} +void CDlgGraphEdit::OnBnClickedZoomInBtn() +{ + m_pView->OnZoomIn(); +} +void CDlgGraphEdit::OnBnClickedZoomOutBtn() +{ + m_pView->OnZoomOut(); +} +#endif +#define MAIN_DLG_SIZE_Y 1050 +void CDlgGraphEdit::OnStnClickedOpenMainDlg() +{ + if(gDlgDeviceMain) + { + gDraw->SetbObjEditMode(false);//رձ༭ģʽ + gDlgDeviceMain->ShowWindow(SW_SHOW); + //ȫʾ(Ӱ쵯Իλ) + gDlgDeviceMain->MoveWindow(CRect(0,0,1950,MAIN_DLG_SIZE_Y)); + } +} +void CDlgGraphEdit::OnBnClickedCreatAreaBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedCreatAreaBtn"); + UpdateData(TRUE); + if(m_AreaCrossPtRange<1) + { + CMsgBox MsgBox; + MsgBox.Show("ʶΧС1"); + return; + } + gLayer.SetAreaCrossPtRange(m_AreaCrossPtRange); + gLayer.QuickCreatScanArea(m_CreatAreaGap); +} +void CDlgGraphEdit::OnBnClickedShowObjPtCoord() +{ + gLayer.SetbShowObjPtCoord(((CButton*)GetDlgItem(IDC_SHOW_OBJ_PT_COORD))->GetCheck()); + GetCurViewPtr()->RefreshView(); +} + + +void CDlgGraphEdit::OnBnClickedOpenMapHistoryBtn() +{ + CDlgMapHistory dlg; + dlg.DoModal(); +} diff --git a/LaipuDrawing/DlgGraphEdit.h b/LaipuDrawing/DlgGraphEdit.h new file mode 100644 index 0000000..d44ce52 --- /dev/null +++ b/LaipuDrawing/DlgGraphEdit.h @@ -0,0 +1,56 @@ +#pragma once + +#include "MyDlgView.h" +#include "MyPictrueBttom.h" +#include "MyBttom.h" + +//ͼα༭ +class CDlgGraphEdit : public CMyDlgView +{ + DECLARE_DYNAMIC(CDlgGraphEdit) +public: + CDlgGraphEdit(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgGraphEdit(); + virtual UINT GetIDD(){return CDlgGraphEdit::IDD;}; + virtual void UpdateLanguageTxt(); + void UpdateObjPropList(); + void InitPropList(CMFCPropertyGridCtrl &PropertyGridCtrl); + void InitObjSortDirComb(); + void ShowAllItem(); + enum { IDD = IDD_GRAPHICS_EDIT }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + afx_msg BOOL OnInitDialog(); + void OnTimer(UINT nIDEvent); + DECLARE_MESSAGE_MAP() + +private: + CFont m_fntPropList; + CMFCPropertyGridCtrl m_ObjPropList; + + CComboBox m_ObjSortDirComb; + int m_InsertIdx;//λõֵ + + double m_AreaCrossPtRange;//ڴɨĽ㷶Χmm + double m_CreatAreaGap;//ļmm +public: + afx_msg LRESULT OnPropertyChanged(WPARAM,LPARAM); + afx_msg void OnBnClickedFristObjBtn(); + afx_msg void OnBnClickedNextObjBtn(); + afx_msg void OnBnClickedPerObjBtn(); + afx_msg void OnBnClickedInsertBtn(); + afx_msg void OnBnClickedReverseOrderBtn(); + afx_msg void OnBnClickedShowObjIdx(); + afx_msg void OnBnClickedObjSortBtn(); + afx_msg void OnBnClickedOpenObjBtn(); + afx_msg void OnBnClickedSaveObjBtn(); + afx_msg void OnBnClickedZoomFullBtn(); + afx_msg void OnBnClickedZoomInBtn(); + afx_msg void OnBnClickedZoomOutBtn(); + afx_msg void OnStnClickedOpenMainDlg(); + afx_msg void OnBnClickedCreatAreaBtn(); + afx_msg void OnBnClickedOpenTxtBtn(); + afx_msg void OnBnClickedSaveTxtBtn(); + afx_msg void OnBnClickedShowObjPtCoord(); + afx_msg void OnBnClickedOpenMapHistoryBtn(); +}; diff --git a/LaipuDrawing/DlgLayerViewShow.cpp b/LaipuDrawing/DlgLayerViewShow.cpp new file mode 100644 index 0000000..5cf854f --- /dev/null +++ b/LaipuDrawing/DlgLayerViewShow.cpp @@ -0,0 +1,100 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "DlgLayerViewShow.h" +#include "afxdialogex.h" +#include "GlobalDrawMgr.h" +#include "Layer.h" +#include "ModuleDeviceMgr.h" +#include "ModuleDrawMgr.h" +#include "LogMgr.h" + + + +IMPLEMENT_DYNAMIC(CDlgLayerViewShow, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgLayerViewShow, CDialogEx) + ON_WM_TIMER() + ON_WM_COPYDATA()//ӦϢ +END_MESSAGE_MAP() + +#define ID_DRAW_TIMER 1//timer ID +#define DRAW_TIME_DELAY 100 //timer ʱ +#define DRAW_TIME_DELAY2 4000 //timer ʱ + + +CDlgLayerViewShow::CDlgLayerViewShow(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgLayerViewShow::IDD, pParent) +{ +} + +CDlgLayerViewShow::~CDlgLayerViewShow() +{ + gDraw->ResetView(); +} +void CDlgLayerViewShow::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + +} + +BOOL CDlgLayerViewShow::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + gDraw->SetViewToDlg(); + + UpdateData(FALSE); + + SetTimer(ID_DRAW_TIMER,DRAW_TIME_DELAY,NULL); + return TRUE; +} +void CDlgLayerViewShow::OnTimer(UINT nIDEvent) +{ + if(nIDEvent == ID_DRAW_TIMER) + { + KillTimer(ID_DRAW_TIMER); + ReDraw(); + //϶ʾ,ػ + SetTimer(ID_DRAW_TIMER,DRAW_TIME_DELAY2,NULL); + } + CDialog::OnTimer(nIDEvent); +} +BOOL CDlgLayerViewShow::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct) +{ + CString strRecievedText = (LPCSTR)(pCopyDataStruct->lpData); + if("Invalidate"==strRecievedText) + { + SetTimer(ID_DRAW_TIMER,DRAW_TIME_DELAY,NULL); + } + return CDialogEx::OnCopyData(pWnd, pCopyDataStruct); +} +//ڷģ̬ԻԶ +void CDlgLayerViewShow::PostNcDestroy() +{ + gDraw->ResetView(); + CDialogEx::PostNcDestroy(); + delete this; +} +void CDlgLayerViewShow::OnCancel() +{ + //CDialogEx::OnCancel(); + DestroyWindow(); +} + +HDC CDlgLayerViewShow::GetHDC() +{ + return ::GetDC(GetSafeHwnd()); +} +CDC* CDlgLayerViewShow::GetCDC() +{ + return CDC::FromHandle(GetHDC()); +} +void CDlgLayerViewShow::ReDraw() +{ + gLogMgr->WriteDebugLog("CDlgLayerViewShowReDraw"); + + CDC *pDC = GetCDC(); + gModuleDeviceMgr.Draw(pDC); + gModuleDrawMgr.Draw(pDC); + gLayer.Draw(pDC); +} + diff --git a/LaipuDrawing/DlgLayerViewShow.h b/LaipuDrawing/DlgLayerViewShow.h new file mode 100644 index 0000000..ea5ab0f --- /dev/null +++ b/LaipuDrawing/DlgLayerViewShow.h @@ -0,0 +1,30 @@ +#pragma once + +//ӳview ͼεdlg +class CDlgLayerViewShow : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgLayerViewShow) + +public: + CDlgLayerViewShow(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgLayerViewShow(); + +// Ի + enum { IDD = IDD_LAYER_VIEW_SHOW_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + virtual void PostNcDestroy(); + virtual void OnCancel(); + afx_msg void OnTimer(UINT nIDEvent); + + afx_msg BOOL OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct); + DECLARE_MESSAGE_MAP() +private: + HDC GetHDC(); + CDC* GetCDC(); + void ReDraw(); +public: + + +}; diff --git a/LaipuDrawing/DlgMapHistory.cpp b/LaipuDrawing/DlgMapHistory.cpp new file mode 100644 index 0000000..13c4b80 --- /dev/null +++ b/LaipuDrawing/DlgMapHistory.cpp @@ -0,0 +1,344 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgMapHistory.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "CStringFuc.h" +#include "WorkFileMgr.h" +#include "LaiPuLaserView.h" + + + +#define MAP_HISTORY_PATH "\\MapHistory\\" +#define MAP_HISTORY_FILE_SUFFIX "obj" + + + +IMPLEMENT_DYNAMIC(CDlgMapHistory, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgMapHistory, CDialogEx) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgMapHistory::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgMapHistory::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_BY_NAME, &CDlgMapHistory::OnBnClickedSearchByName) +END_MESSAGE_MAP() + + +CDlgMapHistory::CDlgMapHistory(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgMapHistory::IDD, pParent) +{ +} + +CDlgMapHistory::~CDlgMapHistory() +{ +} + +void CDlgMapHistory::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); +} + +BOOL CDlgMapHistory::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + OnBnClickedSearchBtn(); + UpdateData(FALSE); + return TRUE; +} +//:ȡ :· +void CDlgMapHistory::GetLogicalDrives(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(MAP_HISTORY_PATH); + m_tree.InsertItem(path,hParent); //ڸڵhParent̷ +} +void CDlgMapHistory::GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(MAP_HISTORY_PATH); + CString DateStr; + if(bByMonth) + DateStr = SelDate.Format("%Y\\%m\\"); + else + DateStr = SelDate.Format("%Y\\%m\\%d\\"); + m_tree.InsertItem(path+ DateStr, hParent); //ڸڵhParent̷ +} +//:ȡ̷ļ +void CDlgMapHistory::GetDriveDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + while(hChild) + { + CString strText = m_tree.GetItemText(hChild); //бĿ + if(strText.Right(1) != "\\") //ұ1ʼȡnCountַ + strText += _T("\\"); + strText += "*.*"; + //ǰĿ¼ļöٲInsertItem״ʾ + CFileFind file; //屾ļ + BOOL bContinue = file.FindFile(strText); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + if(file.IsDirectory() && !file.IsDots()) //ҵļΪҲΪ"." + { + m_tree.InsertItem(file.GetFileName(),hChild); //̷·״ļ + } + } + GetDriveDir(hChild); //ݹ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } +} + +//:ȡĿȫ· +CString CDlgMapHistory::GetFullPath(HTREEITEM hCurrent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strTemp; + CString strReturn = ""; + while(hCurrent != m_hRoot) + { + strTemp = m_tree.GetItemText(hCurrent); //бĿ + if(strTemp.Right(1) != "\\") + strTemp += "\\"; + strReturn = strTemp + strReturn; + hCurrent = m_tree.GetParentItem(hCurrent); //ظĿ + } + return strReturn; +} +//:Ŀ¼ +void CDlgMapHistory::AddSubDir(HTREEITEM hParent) +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + CString strPath = GetFullPath(hParent); //ȡȫ· + + if(strPath.Find(MAP_HISTORY_FILE_SUFFIX)!=-1) + { + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + return; + } + if(strPath.Right(1) != "\\") + strPath += "\\"; + strPath += "*.*"; + CFileFind file; + BOOL bContinue = file.FindFile(strPath); //Ұַļ + while(bContinue) + { + bContinue = file.FindNextFile(); //һļ + //if(file.IsDirectory() && !file.IsDots()) + if(!file.IsDots()) + { + m_tree.InsertItem(file.GetFileName(),hParent); + } + } +} +//ɾhItem ӽڵ +void CDlgMapHistory::DelAllChildOfItem(HTREEITEM hItem) +{ + CTreeCtrl &m_Tree = m_MonitorDataTree; + { + HTREEITEM hNextItem=NULL; + HTREEITEM hChildItem=m_Tree.GetChildItem(hItem); + while (hChildItem!=NULL) + { + hNextItem=m_Tree.GetNextItem(hChildItem,TVGN_NEXT); + m_Tree.DeleteItem(hChildItem); + hChildItem=hNextItem; + } + } +} +//Ӧڵչ¼ +void CDlgMapHistory::OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +// +void CDlgMapHistory::OnBnClickedSearchBtn() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб +} + +void CDlgMapHistory::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find(MAP_HISTORY_FILE_SUFFIX)!=-1) + { + gWorkFileMgr->ReadObjTemplateFile(strPath); + m_pView->RefreshView(); + + CFileMgr FileMgr; + CString FileName = FileMgr.GetFileNameFromPath(strPath,true); + int len1 = FileName.GetLength(); + int idx = FileName.Find("]"); + if(idx!=-1)//ֻmap + { + FileName = FileName.Right(len1-idx-1); + } + GetDlgItem(IDC_MAP_NAME_EDIT)->SetWindowText(FileName); + } + *pResult = 0; +} +//·µĽڵ,ݹ麯 +void CDlgMapHistory::GetDriveDir_ByPath(HTREEITEM hParent,CString FindPath,CString SearchName) +{ + COleDateTime SelDateStart; + COleDateTime SelDateEnd = COleDateTime::GetCurrentTime(); + + CFileMgr FileMgr; + vector DirPathVec;//Ŀ¼· + FileMgr.GetChildFileOrDirName(true,FindPath,DirPathVec,""); + //ûĿ¼ʾĿ¼ + if(DirPathVec.empty()) + { + CString DataPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(MAP_HISTORY_PATH); + int FindPathLen = FindPath.GetLength(); + int DataPathLen = DataPath.GetLength(); + if(DataPathLen>=FindPathLen) + return; + CString ChildDirName = FindPath.Right(FindPathLen-DataPathLen);//ӽڵ + + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + + bool bChild2Creat = false; + vector FilePathVec;//ļ· + FileMgr.GetChildFileOrDirName(false,FindPath,FilePathVec,MAP_HISTORY_FILE_SUFFIX); + int size = FilePathVec.size(); + for(int k=0;kWriteDebugLog("Func-->OnBnClickedSearchByName"); + CString SearchName; + GetDlgItem(IDC_MAP_NAME_EDIT)->GetWindowText(SearchName); + + if(SearchName=="") + { + OnBnClickedSearchBtn(); + return; + } + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root");//ڵ + CString path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(MAP_HISTORY_PATH); + m_tree.InsertItem(path, m_hRoot);//ڸڵhParent̷ + + m_bFirstDir = true;//һĿ¼ + GetDriveDir_ByPath(m_hRoot,path,SearchName);//Զ庯 ȡ + //m_tree.Expand(m_hRoot, TVE_EXPAND); //չ۵б TVE_EXPANDչб + + ExpandTree(&m_tree,m_hRoot);//չнڵ +} +//չнڵ +void CDlgMapHistory::ExpandTree(CTreeCtrl* pTreeCtrl,HTREEITEM hItem) +{ + HTREEITEM hChild,hNext,hParent; + + if((!hItem)||(!pTreeCtrl)) + return; + //չڵ + pTreeCtrl->Expand(hItem,TVE_EXPAND); + + hChild = pTreeCtrl->GetNextItem(hItem,TVGN_CHILD); + if(hChild) + {//ӽڵ㣬չӽڵ + ExpandTree(pTreeCtrl,hChild); + } + else + {//ûӽڵ㣬Ѱֵܽڵ + hNext = pTreeCtrl->GetNextItem(hItem,TVGN_NEXT); + if(hNext) + {//ֵܽڵ + ExpandTree(pTreeCtrl,hNext); + } + else + {//ֵܽڵ㣬Ҹڵ + hParent = pTreeCtrl->GetParentItem(hItem); + hNext = pTreeCtrl->GetNextItem(hParent,TVGN_NEXT); + if(hNext) + ExpandTree(pTreeCtrl,hNext); + } + } +} + +void CDlgMapHistory::SearchByName(CString SearchName) +{ + GetDlgItem(IDC_MAP_NAME_EDIT)->SetWindowText(SearchName); + OnBnClickedSearchByName(); +} + diff --git a/LaipuDrawing/DlgMapHistory.h b/LaipuDrawing/DlgMapHistory.h new file mode 100644 index 0000000..d62fe5a --- /dev/null +++ b/LaipuDrawing/DlgMapHistory.h @@ -0,0 +1,38 @@ +#pragma once + +class CDlgMapHistory : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgMapHistory) + +public: + CDlgMapHistory(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgMapHistory(); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_MAP_HISTORY_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + DECLARE_MESSAGE_MAP() +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CString m_CurSelPath;//еǰѡеļļ· + + HTREEITEM m_hChild2;//Ӽڵ + bool m_bFirstDir;//һĿ¼ +protected: + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth = false); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + void SearchByName(CString SearchName); + void GetDriveDir_ByPath(HTREEITEM hParent,CString FindPath,CString SearchName); + void ExpandTree(CTreeCtrl* pTreeCtrl,HTREEITEM hItem); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedSearchByName(); +}; diff --git a/LaipuDrawing/DlgOffsetTable.cpp b/LaipuDrawing/DlgOffsetTable.cpp new file mode 100644 index 0000000..e31cae5 --- /dev/null +++ b/LaipuDrawing/DlgOffsetTable.cpp @@ -0,0 +1,511 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgOffsetTable.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "CStringFuc.h" +#include "WorkFileMgr.h" +#include "RecipeMgr.h" +#include "WaferRecipeDataMgr.h" +#include "MsgBox.h" +#include "DlgCreatOffsetTable.h" +#include "AuthorityMgr.h" + + + + +#define Data_List_Item_Cnt 4 + +IMPLEMENT_DYNAMIC(CDlgOffsetTable, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgOffsetTable, CDialogEx) + ON_NOTIFY(TVN_ITEMEXPANDED, IDC_DATA_FOLDE_TREE, &CDlgOffsetTable::OnTvnItemexpandedDataFoldeTree) + ON_NOTIFY(TVN_SELCHANGED, IDC_DATA_FOLDE_TREE, &CDlgOffsetTable::OnTvnSelchangedDataFoldeTree) + ON_BN_CLICKED(IDC_SEARCH_TAB_BY_NAME, &CDlgOffsetTable::OnBnClickedSearchByName) + ON_BN_CLICKED(IDC_UPDATE_TAB_LIST, &CDlgOffsetTable::OnBnClickedUpdateTabList) + ON_BN_CLICKED(IDC_SAVE_CUR_OFFSET_TAB, &CDlgOffsetTable::OnBnClickedSaveCurOffsetTab) + ON_BN_CLICKED(IDC_DEL_OFFSET_TAB, &CDlgOffsetTable::OnBnClickedDelOffsetTab) + ON_BN_CLICKED(IDC_CREAT_OFFSET_TAB, &CDlgOffsetTable::OnBnClickedCreatOffsetTab) + + ON_NOTIFY(NM_CLICK, NEW_EDIT_INFO_LIST, &CDlgOffsetTable::OnNMClickEditInfoList) + ON_EN_KILLFOCUS(IDC_EDIT_PAR_DOUBLE, &CDlgOffsetTable::OnEnKillfocusDoubleEdit) +END_MESSAGE_MAP() + + +CDlgOffsetTable::CDlgOffsetTable(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgOffsetTable::IDD, pParent) +{ + m_EditDoubleParVal = 0; +} + +CDlgOffsetTable::~CDlgOffsetTable() +{ +} + +void CDlgOffsetTable::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Control(pDX, IDC_DATA_FOLDE_TREE, m_MonitorDataTree); + DDX_Control(pDX, NEW_HISTORY_LIST, m_OffsetTableHistoryList); + DDX_Control(pDX, NEW_EDIT_INFO_LIST, m_OffsetList); + DDX_Control(pDX, IDC_EDIT_PAR_DOUBLE, m_DoubleParEdit); + DDX_Text(pDX,IDC_EDIT_PAR_DOUBLE,m_EditDoubleParVal); +} + +BOOL CDlgOffsetTable::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.ModifyStyle(NULL,TVS_HASBUTTONS|TVS_HASLINES|TVS_LINESATROOT|TVS_EDITLABELS); + + InitDataList(); + gWaferRecipeDataMgr->InitOffsetTableList(m_OffsetList); + OnBnClickedUpdateTabList(); + + UpdateData(FALSE); + return TRUE; +} +void CDlgOffsetTable::InitDataList() +{ + //÷ + m_OffsetTableHistoryList.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + CString s; + for(int k=0;k(pNMHDR); + CTreeCtrl &m_tree = m_MonitorDataTree; + TVITEM item = pNMTreeView->itemNew; //\ܹͼĿϢ + if(item.hItem == m_hRoot) + return; + + //ȡitem.hItem ĵһChildItem + HTREEITEM hChild = m_tree.GetChildItem(item.hItem); + //ɾǰӽڵ(ֵܱ㿪ʱ״̬) + if(m_tree.ItemHasChildren(hChild)) + return; + //ӽڵ + while(hChild) + { + AddSubDir(hChild); //Ŀ¼ + hChild = m_tree.GetNextItem(hChild,TVGN_NEXT); //ȡοؼTVGN_NEXTֵ + } + *pResult = 0; +} +// +void CDlgOffsetTable::UpdateOffsetTableTree() +{ + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root"); //ڵ + GetLogicalDrives(m_hRoot); //Զ庯 ȡ + GetDriveDir(m_hRoot); //Զ庯 ȡ + //m_tree.Expand(m_hRoot,TVE_EXPAND); //չ۵б TVE_EXPANDչб + + ExpandTree(&m_tree,m_hRoot);//չнڵ +} + +void CDlgOffsetTable::OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult) +{ + LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR); + // NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; + TVITEM item = pNMTreeView->itemNew; + if(item.hItem == m_hRoot) + return; + CString strPath = GetFullPath(item.hItem); + int len = strPath.GetLength(); + strPath.Delete(len-1,1);//ɾһ'\' + gLogMgr->WriteDebugLog(strPath); + m_CurSelPath = strPath; + if(strPath.Find(m_FindFileSuffix)!=-1) + { + if(m_bHistoryMode) + { + UpdateHistoryList(strPath); + } + else + { + CFileMgr FileMgr; + CString FileName = FileMgr.GetFileNameFromPath(strPath,true); + GetDlgItem(IDC_SEARCH_NAME_EDIT)->SetWindowText(FileName); + + gWaferRecipeDataMgr->UpdateOffsetTableList(m_OffsetList,strPath); + } + } + *pResult = 0; +} +//·µĽڵ,ݹ麯 +void CDlgOffsetTable::GetDriveDir_ByPath(HTREEITEM hParent,CString FindPath,CString SearchName) +{ + CFileMgr FileMgr; + vector DirPathVec;//Ŀ¼· + FileMgr.GetChildFileOrDirName(true,FindPath,DirPathVec,""); + //ûĿ¼ʾĿ¼ + if(DirPathVec.empty()) + { + CString DataPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(OFFSET_TAB_HISTORY_PATH); + int FindPathLen = FindPath.GetLength(); + int DataPathLen = DataPath.GetLength(); + if(DataPathLen>=FindPathLen) + return; + CString ChildDirName = FindPath.Right(FindPathLen-DataPathLen);//ӽڵ + + CTreeCtrl &m_tree = m_MonitorDataTree; + HTREEITEM hChild = m_tree.GetChildItem(hParent); //ȡָλе + + bool bChild2Creat = false; + vector FilePathVec;//ļ· + FileMgr.GetChildFileOrDirName(false,FindPath,FilePathVec,m_FindFileSuffix); + int size = FilePathVec.size(); + for(int k=0;kWriteDebugLog(FileName); + //SearchName ɸѡ + if(SearchName!="" && FileName.Find(SearchName)==-1) + continue; + if(!bChild2Creat)//Child2 ڵ + { + //ڵ + m_tree.InsertItem(ChildDirName, hChild); + if(m_bFirstDir) + { + m_hChild2 = m_tree.GetChildItem(hChild); + m_bFirstDir = false; + } + else + { + m_hChild2 = m_tree.GetNextItem(m_hChild2,TVGN_NEXT); + } + bChild2Creat = true; + } + // + m_tree.InsertItem(FileName,m_hChild2); + } + } + else//ݹ + { + int size = DirPathVec.size(); + for(int k=0;kExpand(hItem,TVE_EXPAND); + + hChild = pTreeCtrl->GetNextItem(hItem,TVGN_CHILD); + if(hChild) + {//ӽڵ㣬չӽڵ + ExpandTree(pTreeCtrl,hChild); + } + else + {//ûӽڵ㣬Ѱֵܽڵ + hNext = pTreeCtrl->GetNextItem(hItem,TVGN_NEXT); + if(hNext) + {//ֵܽڵ + ExpandTree(pTreeCtrl,hNext); + } + else + {//ֵܽڵ㣬Ҹڵ + hParent = pTreeCtrl->GetParentItem(hItem); + hNext = pTreeCtrl->GetNextItem(hParent,TVGN_NEXT); + if(hNext) + ExpandTree(pTreeCtrl,hNext); + } + } +} + +void CDlgOffsetTable::SearchByName(CString SearchName) +{ + GetDlgItem(IDC_SEARCH_NAME_EDIT)->SetWindowText(SearchName); + OnBnClickedSearchByName(); +} + +void CDlgOffsetTable::UpdateHistoryList(CString strPath) +{ + m_OffsetTableHistoryList.DeleteAllItems(); + vector> StrVec; + CString log("ReadFile : "); + log += strPath; + gLogMgr->WriteDebugLog(log); + + CFileMgr FileMgr; + FileMgr.ReadFileToStrVec(strPath,StrVec,true); + int size = StrVec.size(); + for(int k=0;k=Data_List_Item_Cnt) + break; + m_OffsetTableHistoryList.SetItemText(k,i,StrVec[k][i]);// + } + } +} + +//recipe б +void CDlgOffsetTable::OnNMClickEditInfoList(NMHDR *pNMHDR, LRESULT *pResult) +{ + *pResult = 0; + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",false)) + return; + NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; + int Row = pNMListView->iItem; + if(Row >= 0)//к + { + CListCtrl &ListCtrl = m_OffsetList; + int Col = pNMListView->iSubItem; + if(Col == OffsetTab_List_Val_Col) + { + //¼ǰк + m_row = Row; + m_col = Col; + + CRect rc; + ListCtrl.GetSubItemRect(Row,Col, LVIR_LABEL, rc);//ȡľ + ListCtrl.ClientToScreen(&rc); + ScreenToClient(&rc); + CString s = ListCtrl.GetItemText(Row,Col);//ȡ + { + CEdit &Edit = m_DoubleParEdit; + Edit.SetWindowText(s);//ʾ༭ + Edit.MoveWindow(&rc);//༭ƶ棬 + Edit.ShowWindow(SW_SHOW);//ʾ༭ + Edit.SetFocus();//ʹ༭ȡý + Edit.CreateSolidCaret(1, rc.Height() - 5);//һ + Edit.ShowCaret();//ʾ + Edit.SetSel(0, -1);//ʹƵ + } + } + } +} +//Edit 뽹ʱΪlist ֵ +void CDlgOffsetTable::OnEnKillfocusDoubleEdit() +{ + m_DoubleParEdit.ShowWindow(SW_HIDE); + if(m_col < 0 || m_row < 0) + return; + CString key; + m_DoubleParEdit.GetWindowText(key); + m_OffsetList.SetItemText(m_row, m_col, key); +} + +#if 1 +void CDlgOffsetTable::SetHistoryMode(bool bHistoryMode) +{ + m_bHistoryMode = bHistoryMode;//ǰDz鿴ʷ¼ģʽ + if(bHistoryMode) + { + m_FindFileSuffix = OFFSET_TAB_HISTORY_SUFFIX;//ļ׺ + m_FindFilePath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(OFFSET_TAB_HISTORY_PATH);//ļ׺ + + GetDlgItem(IDC_SAVE_CUR_OFFSET_TAB)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_DEL_OFFSET_TAB)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_CREAT_OFFSET_TAB)->ShowWindow(SW_HIDE); + GetDlgItem(NEW_EDIT_INFO_LIST)->ShowWindow(SW_HIDE); + GetDlgItem(NEW_HISTORY_LIST)->ShowWindow(SW_SHOW); + } + else + { + m_FindFileSuffix = OFFSET_TAB_FILE_SUFFIX;//ļ׺ + m_FindFilePath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(OFFSET_TAB_PATH);//ļ׺ + + GetDlgItem(IDC_SAVE_CUR_OFFSET_TAB)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_DEL_OFFSET_TAB)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_CREAT_OFFSET_TAB)->ShowWindow(SW_SHOW); + GetDlgItem(NEW_EDIT_INFO_LIST)->ShowWindow(SW_SHOW); + GetDlgItem(NEW_HISTORY_LIST)->ShowWindow(SW_HIDE); + } +} +void CDlgOffsetTable::OnBnClickedUpdateTabList() +{ + SetHistoryMode(false); + UpdateOffsetTableTree(); +} +void CDlgOffsetTable::OnBnClickedSearchByName() +{ + gLogMgr->WriteDebugLog("Func-->OnBnClickedSearchByName"); + + SetHistoryMode(true); + + CString SearchName; + GetDlgItem(IDC_SEARCH_NAME_EDIT)->GetWindowText(SearchName); + if(SearchName=="") + { + UpdateOffsetTableTree(); + return; + } + + CTreeCtrl &m_tree = m_MonitorDataTree; + m_tree.DeleteItem(m_hRoot);//ȫɾ + m_hRoot = m_tree.InsertItem("root");//ڵ + CString path = m_FindFilePath; + m_tree.InsertItem(path, m_hRoot);//ڸڵhParent̷ + + m_bFirstDir = true;//һĿ¼ + GetDriveDir_ByPath(m_hRoot,path,SearchName);//Զ庯 ȡ + ExpandTree(&m_tree,m_hRoot);//չнڵ +} + +void CDlgOffsetTable::OnBnClickedSaveCurOffsetTab() +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + if(!UpdateData(TRUE)) + return; + gWaferRecipeDataMgr->SaveRcpOffsetTable(m_OffsetList,m_CurSelPath); +} +void CDlgOffsetTable::OnBnClickedDelOffsetTab() +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + gWaferRecipeDataMgr->DelOffsetTable(m_CurSelPath); + OnBnClickedUpdateTabList(); +} +void CDlgOffsetTable::OnBnClickedCreatOffsetTab() +{ + if(!gAuthorityMgr->CheckAuthorityByName("AUTHORITY_EditRecipe",true)) + return; + CString SearchName; + GetDlgItem(IDC_SEARCH_NAME_EDIT)->GetWindowText(SearchName); + + CDlgCreatOffsetTable dlg; + dlg.SetEditName(SearchName);//һĬϵ + if(dlg.DoModal() == IDOK) + { + CString Name = dlg.GetEditName(); + gWaferRecipeDataMgr->CreateNewOffsetTable(Name); + OnBnClickedUpdateTabList(); + } +} +#endif diff --git a/LaipuDrawing/DlgOffsetTable.h b/LaipuDrawing/DlgOffsetTable.h new file mode 100644 index 0000000..d9a8875 --- /dev/null +++ b/LaipuDrawing/DlgOffsetTable.h @@ -0,0 +1,60 @@ +#pragma once + +class CDlgOffsetTable : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgOffsetTable) + +public: + CDlgOffsetTable(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgOffsetTable(); + void DelAllChildOfItem(HTREEITEM hItem); +// Ի + enum { IDD = IDD_OFFSET_TABLE_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + + void GetLogicalDrives(HTREEITEM hParent); + void GetLogicalDrives(HTREEITEM hParent, COleDateTime SelDate,bool bByMonth = false); + void GetDriveDir(HTREEITEM hParent); + CString GetFullPath(HTREEITEM hCurrent); + void AddSubDir(HTREEITEM hParent); + void SearchByName(CString SearchName); + void GetDriveDir_ByPath(HTREEITEM hParent,CString FindPath,CString SearchName); + void ExpandTree(CTreeCtrl* pTreeCtrl,HTREEITEM hItem); + void SetHistoryMode(bool bHistoryMode); + void InitDataList(); + void UpdateHistoryList(CString strPath); + afx_msg void UpdateOffsetTableTree(); + afx_msg void OnTvnItemexpandedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnTvnSelchangedDataFoldeTree(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedSearchByName(); + afx_msg void OnNMClickEditInfoList(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnEnKillfocusDoubleEdit(); + DECLARE_MESSAGE_MAP() +private: + CTreeCtrl m_MonitorDataTree; + HTREEITEM m_hRoot; // CTreeCtrlĸ + + CString m_CurSelPath;//еǰѡеļļ· + + HTREEITEM m_hChild2;//Ӽڵ + bool m_bFirstDir;//һĿ¼ + + bool m_bHistoryMode;//ǰDz鿴ʷ¼ģʽ + CString m_FindFileSuffix;//ļ׺ + CString m_FindFilePath;//ļ׺ + + CListCtrl m_OffsetTableHistoryList; + CListCtrl m_OffsetList; + + CEdit m_DoubleParEdit;//ڱ༭doubleı༭ + double m_EditDoubleParVal; + int m_row;//ѡ + int m_col;//ѡ +public: + afx_msg void OnBnClickedUpdateTabList(); + afx_msg void OnBnClickedSaveCurOffsetTab(); + afx_msg void OnBnClickedDelOffsetTab(); + afx_msg void OnBnClickedCreatOffsetTab(); +}; diff --git a/LaipuDrawing/DlgRecipeCompare.cpp b/LaipuDrawing/DlgRecipeCompare.cpp new file mode 100644 index 0000000..edc47dc --- /dev/null +++ b/LaipuDrawing/DlgRecipeCompare.cpp @@ -0,0 +1,309 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgRecipeCompare.h" +#include "GlobalFunction.h" + + +IMPLEMENT_DYNAMIC(CDlgRecipeCompare, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgRecipeCompare, CDialogEx) + ON_CBN_SELCHANGE(NEW_RECIPE_GROUP_COMBO, &CDlgRecipeCompare::OnCbnSelchangeSelGroupCombo) + ON_CBN_SELCHANGE(NEW_RECIPE_NAME_COMBO, &CDlgRecipeCompare::OnCbnSelchangeSelRecipeCombo) + ON_NOTIFY(NM_CLICK, NEW_SUB_RECIPE_LIST, &CDlgRecipeCompare::OnNMClickEditSubRecipeList) + + ON_CBN_SELCHANGE(NEW_RECIPE_GROUP_COMBO2, &CDlgRecipeCompare::OnCbnSelchangeSelGroupCombo2) + ON_CBN_SELCHANGE(NEW_RECIPE_NAME_COMBO2, &CDlgRecipeCompare::OnCbnSelchangeSelRecipeCombo2) + ON_NOTIFY(NM_CLICK, NEW_SUB_RECIPE_LIST2, &CDlgRecipeCompare::OnNMClickEditSubRecipeList2) + + ON_NOTIFY(NM_CUSTOMDRAW, NEW_EDIT_RECIPE_LIST, &CDlgRecipeCompare::OnDrawRecipeList) + ON_NOTIFY(NM_CUSTOMDRAW, NEW_EDIT_RECIPE_INFO_LIST, &CDlgRecipeCompare::OnDrawRecipeInfoList) + ON_NOTIFY(NM_CUSTOMDRAW, NEW_EDIT_RECIPE_LIST2, &CDlgRecipeCompare::OnDrawRecipeList2) + ON_NOTIFY(NM_CUSTOMDRAW, NEW_EDIT_RECIPE_INFO_LIST2, &CDlgRecipeCompare::OnDrawRecipeInfoList2) +END_MESSAGE_MAP() + + +CDlgRecipeCompare::CDlgRecipeCompare(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgRecipeCompare::IDD, pParent) +{ +} + +CDlgRecipeCompare::~CDlgRecipeCompare() +{ +} + +void CDlgRecipeCompare::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Control(pDX, NEW_RECIPE_GROUP_COMBO, m_SelRecipeGroupComb); + DDX_Control(pDX, NEW_RECIPE_NAME_COMBO, m_SelRecipeComb); + DDX_Control(pDX, NEW_EDIT_RECIPE_LIST, m_EditRecipeList); + DDX_Control(pDX, NEW_SUB_RECIPE_LIST, m_EditSubRecipeList); + DDX_Control(pDX, NEW_EDIT_RECIPE_INFO_LIST, m_EditRecipeInfoList); + + DDX_Control(pDX, NEW_RECIPE_GROUP_COMBO2, m_SelRecipeGroupComb2); + DDX_Control(pDX, NEW_RECIPE_NAME_COMBO2, m_SelRecipeComb2); + DDX_Control(pDX, NEW_EDIT_RECIPE_LIST2, m_EditRecipeList2); + DDX_Control(pDX, NEW_SUB_RECIPE_LIST2, m_EditSubRecipeList2); + DDX_Control(pDX, NEW_EDIT_RECIPE_INFO_LIST2, m_EditRecipeInfoList2); +} + +BOOL CDlgRecipeCompare::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + //recipe Ϣ + gRecipeMgr->UpdateRecipeGroupVec(); + //Recipe1 + gRecipeMgr->UpdateRecipeGroupComb(&m_SelRecipeGroupComb); + m_SelRecipeGroupComb.SetCurSel(-1); + gRecipeMgr->InitEditRecipeList(m_EditRecipeList,false); + gRecipeMgr->InitEditRecipeList(m_EditRecipeInfoList,false); + gRecipeMgr->InitEditSubRecipeList(m_EditSubRecipeList); + //Recipe2 + gRecipeMgr->UpdateRecipeGroupComb(&m_SelRecipeGroupComb2); + m_SelRecipeGroupComb2.SetCurSel(-1); + gRecipeMgr->InitEditRecipeList(m_EditRecipeList2,false); + gRecipeMgr->InitEditRecipeList(m_EditRecipeInfoList2,false); + gRecipeMgr->InitEditSubRecipeList(m_EditSubRecipeList2); + UpdateData(FALSE); + return TRUE; +} +#if 1 +void CDlgRecipeCompare::OnDrawRecipeList( NMHDR* pNMHDR, LRESULT* pResult ) +{ + NMLVCUSTOMDRAW* pLVCD = reinterpret_cast( pNMHDR ); + *pResult = CDRF_DODEFAULT; + if( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYITEMDRAW; + } + else if( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYSUBITEMDRAW; + } + else if((CDDS_ITEMPREPAINT | CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage ) + { + COLORREF crText, crBkgnd; + crText = RGB_BLACK; + crBkgnd = RGB_WHITE; + int iRow = pLVCD->nmcd.dwItemSpec;//к + int iCol = 4; + if(iCol == pLVCD->iSubItem)//к + { + CString Text1 = m_EditRecipeList.GetItemText(iRow,iCol); + CString Text2 = m_EditRecipeList2.GetItemText(iRow,iCol); + if(m_CurRecipe.IsValid()&&m_CurRecipe2.IsValid()&&Text1!=Text2) + crBkgnd = RGB_BLUE2; + } + pLVCD->clrText = crText; + pLVCD->clrTextBk = crBkgnd; + + *pResult = CDRF_DODEFAULT; + } +} + +void CDlgRecipeCompare::OnDrawRecipeInfoList( NMHDR* pNMHDR, LRESULT* pResult) +{ + NMLVCUSTOMDRAW* pLVCD = reinterpret_cast( pNMHDR ); + *pResult = CDRF_DODEFAULT; + if( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYITEMDRAW; + } + else if( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYSUBITEMDRAW; + } + else if((CDDS_ITEMPREPAINT | CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage ) + { + COLORREF crText, crBkgnd; + crText = RGB_BLACK; + crBkgnd = RGB_WHITE; + int iRow = pLVCD->nmcd.dwItemSpec;//к + int iCol = 4; + if(iCol == pLVCD->iSubItem)//к + { + CString Text1 = m_EditRecipeInfoList.GetItemText(iRow,iCol); + CString Text2 = m_EditRecipeInfoList2.GetItemText(iRow,iCol); + if(m_CurRecipe.IsValid()&&m_CurRecipe2.IsValid()&&Text1!=Text2) + crBkgnd = RGB_BLUE2; + } + pLVCD->clrText = crText; + pLVCD->clrTextBk = crBkgnd; + + *pResult = CDRF_DODEFAULT; + } +} +void CDlgRecipeCompare::OnDrawRecipeList2( NMHDR* pNMHDR, LRESULT* pResult ) +{ + NMLVCUSTOMDRAW* pLVCD = reinterpret_cast( pNMHDR ); + *pResult = CDRF_DODEFAULT; + if( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYITEMDRAW; + } + else if( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYSUBITEMDRAW; + } + else if((CDDS_ITEMPREPAINT | CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage ) + { + COLORREF crText, crBkgnd; + crText = RGB_BLACK; + crBkgnd = RGB_WHITE; + int iRow = pLVCD->nmcd.dwItemSpec;//к + int iCol = 4; + if(iCol == pLVCD->iSubItem)//к + { + CString Text1 = m_EditRecipeList.GetItemText(iRow,iCol); + CString Text2 = m_EditRecipeList2.GetItemText(iRow,iCol); + if(m_CurRecipe.IsValid()&&m_CurRecipe2.IsValid()&&Text1!=Text2) + crBkgnd = RGB_YELLOW; + } + pLVCD->clrText = crText; + pLVCD->clrTextBk = crBkgnd; + + *pResult = CDRF_DODEFAULT; + } +} + +void CDlgRecipeCompare::OnDrawRecipeInfoList2( NMHDR* pNMHDR, LRESULT* pResult) +{ + NMLVCUSTOMDRAW* pLVCD = reinterpret_cast( pNMHDR ); + *pResult = CDRF_DODEFAULT; + if( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYITEMDRAW; + } + else if( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage ) + { + *pResult = CDRF_NOTIFYSUBITEMDRAW; + } + else if((CDDS_ITEMPREPAINT | CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage ) + { + COLORREF crText, crBkgnd; + crText = RGB_BLACK; + crBkgnd = RGB_WHITE; + int iRow = pLVCD->nmcd.dwItemSpec;//к + int iCol = 4; + if(iCol == pLVCD->iSubItem)//к + { + CString Text1 = m_EditRecipeInfoList.GetItemText(iRow,iCol); + CString Text2 = m_EditRecipeInfoList2.GetItemText(iRow,iCol); + if(m_CurRecipe.IsValid()&&m_CurRecipe2.IsValid()&&Text1!=Text2) + crBkgnd = RGB_YELLOW; + } + pLVCD->clrText = crText; + pLVCD->clrTextBk = crBkgnd; + + *pResult = CDRF_DODEFAULT; + } +} +#endif +#if 1 +void CDlgRecipeCompare::OnCbnSelchangeSelGroupCombo() +{ + int SelGroupIdx = m_SelRecipeGroupComb.GetCurSel(); + + gRecipeMgr->SetCurSelGourpIdx(SelGroupIdx); + gRecipeMgr->UpdateSelRecipeComb(m_SelRecipeComb,m_SelGroupRecipeNameVec); + m_CurSelRecipeName = ""; +} +void CDlgRecipeCompare::OnCbnSelchangeSelRecipeCombo() +{ + int SelGroupIdx = m_SelRecipeGroupComb.GetCurSel(); + CString GroupName; + GetDlgItem(NEW_RECIPE_GROUP_COMBO)->GetWindowText(GroupName); + int SelRecipeIdx = m_SelRecipeComb.GetCurSel(); + + int size = m_SelGroupRecipeNameVec.size(); + if(SelRecipeIdx>=0 && SelRecipeIdxReadEditRecipeFromFile(Recipe,SelGroupIdx,m_CurSelRecipeName)) + { + Recipe.SetCurSubRecipeIdx(0);//Ĭϵһsub recipe + m_CurRecipe = Recipe; + gRecipeMgr->UpdateEditSubRecipeListExt(Recipe,m_EditSubRecipeList); + gRecipeMgr->UpdateEditRecipeListExt(Recipe,m_EditRecipeList,m_EditRecipeInfoList); + + //ˢһ + gRecipeMgr->UpdateEditRecipeListExt(m_CurRecipe2,m_EditRecipeList2,m_EditRecipeInfoList2); + } + } + //ĬѡԼ + { + int SelGroupIdx = m_SelRecipeGroupComb2.GetCurSel(); + if(SelGroupIdx<0) + { + SelGroupIdx = m_SelRecipeGroupComb.GetCurSel(); + m_SelRecipeGroupComb2.SetCurSel(SelGroupIdx); + OnCbnSelchangeSelGroupCombo2(); + int SelRecipeIdx = m_SelRecipeComb.GetCurSel(); + m_SelRecipeComb2.SetCurSel(SelRecipeIdx); + OnCbnSelchangeSelRecipeCombo2(); + } + } +} +void CDlgRecipeCompare::OnNMClickEditSubRecipeList(NMHDR *pNMHDR, LRESULT *pResult) +{ + *pResult = 0; + int Idx = GetCurListIdx(m_EditSubRecipeList); + + if(Idx>=0 && m_CurRecipe.IsValid()) + { + m_CurRecipe.SetCurSubRecipeIdx(Idx); + gRecipeMgr->UpdateEditRecipeListExt(m_CurRecipe,m_EditRecipeList,m_EditRecipeInfoList); + + //ˢһ + gRecipeMgr->UpdateEditRecipeListExt(m_CurRecipe2,m_EditRecipeList2,m_EditRecipeInfoList2); + } +} +#endif +#if 1 +void CDlgRecipeCompare::OnCbnSelchangeSelGroupCombo2() +{ + int SelGroupIdx = m_SelRecipeGroupComb2.GetCurSel(); + + gRecipeMgr->SetCurSelGourpIdx(SelGroupIdx); + gRecipeMgr->UpdateSelRecipeComb(m_SelRecipeComb2,m_SelGroupRecipeNameVec2); + m_CurSelRecipeName2 = ""; +} +void CDlgRecipeCompare::OnCbnSelchangeSelRecipeCombo2() +{ + int SelGroupIdx = m_SelRecipeGroupComb2.GetCurSel(); + CString GroupName; + GetDlgItem(NEW_RECIPE_GROUP_COMBO2)->GetWindowText(GroupName); + int SelRecipeIdx = m_SelRecipeComb2.GetCurSel(); + + int size = m_SelGroupRecipeNameVec2.size(); + if(SelRecipeIdx>=0 && SelRecipeIdxReadEditRecipeFromFile(Recipe,SelGroupIdx,m_CurSelRecipeName2)) + { + Recipe.SetCurSubRecipeIdx(0);//Ĭϵһsub recipe + m_CurRecipe2 = Recipe; + gRecipeMgr->UpdateEditSubRecipeListExt(Recipe,m_EditSubRecipeList2); + gRecipeMgr->UpdateEditRecipeListExt(Recipe,m_EditRecipeList2,m_EditRecipeInfoList2); + + gRecipeMgr->UpdateEditRecipeListExt(m_CurRecipe,m_EditRecipeList,m_EditRecipeInfoList); + } + } +} +void CDlgRecipeCompare::OnNMClickEditSubRecipeList2(NMHDR *pNMHDR, LRESULT *pResult) +{ + *pResult = 0; + int Idx = GetCurListIdx(m_EditSubRecipeList2); + + if(Idx>=0 && m_CurRecipe2.IsValid()) + { + m_CurRecipe2.SetCurSubRecipeIdx(Idx); + gRecipeMgr->UpdateEditRecipeListExt(m_CurRecipe2,m_EditRecipeList2,m_EditRecipeInfoList2); + + gRecipeMgr->UpdateEditRecipeListExt(m_CurRecipe,m_EditRecipeList,m_EditRecipeInfoList); + } +} +#endif \ No newline at end of file diff --git a/LaipuDrawing/DlgRecipeCompare.h b/LaipuDrawing/DlgRecipeCompare.h new file mode 100644 index 0000000..339cbc3 --- /dev/null +++ b/LaipuDrawing/DlgRecipeCompare.h @@ -0,0 +1,49 @@ +#pragma once +#include "RecipeMgr.h" + +class CDlgRecipeCompare : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgRecipeCompare) + +public: + CDlgRecipeCompare(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgRecipeCompare(); + +// Ի + enum { IDD = IDD_CHILD_RECIPE_COMPARE }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + afx_msg void OnCbnSelchangeSelRecipeCombo(); + afx_msg void OnCbnSelchangeSelGroupCombo(); + afx_msg void OnNMClickEditSubRecipeList(NMHDR *pNMHDR, LRESULT *pResult); + + afx_msg void OnCbnSelchangeSelRecipeCombo2(); + afx_msg void OnCbnSelchangeSelGroupCombo2(); + afx_msg void OnNMClickEditSubRecipeList2(NMHDR *pNMHDR, LRESULT *pResult); + + void OnDrawRecipeList( NMHDR* pNMHDR, LRESULT* pResult ); + void OnDrawRecipeInfoList( NMHDR* pNMHDR, LRESULT* pResult ); + void OnDrawRecipeList2( NMHDR* pNMHDR, LRESULT* pResult ); + void OnDrawRecipeInfoList2( NMHDR* pNMHDR, LRESULT* pResult ); + DECLARE_MESSAGE_MAP() +private: + //recipe1 + CComboBox m_SelRecipeGroupComb; + CComboBox m_SelRecipeComb; + vector m_SelGroupRecipeNameVec; + CString m_CurSelRecipeName; + CRecipe m_CurRecipe; + CListCtrl m_EditRecipeList;//Edit recipe list + CListCtrl m_EditRecipeInfoList;//ʾlist + CListCtrl m_EditSubRecipeList;//Edit Sub recipe list + //recipe2 + CComboBox m_SelRecipeGroupComb2; + CComboBox m_SelRecipeComb2; + vector m_SelGroupRecipeNameVec2; + CString m_CurSelRecipeName2; + CRecipe m_CurRecipe2; + CListCtrl m_EditRecipeList2;//Edit recipe list + CListCtrl m_EditRecipeInfoList2;//ʾlist + CListCtrl m_EditSubRecipeList2;//Edit Sub recipe list +}; diff --git a/LaipuDrawing/DlgRecipeCtrl.cpp b/LaipuDrawing/DlgRecipeCtrl.cpp new file mode 100644 index 0000000..855bee9 --- /dev/null +++ b/LaipuDrawing/DlgRecipeCtrl.cpp @@ -0,0 +1,161 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "DlgRecipeCtrl.h" +#include "RecipeMgr.h" +#include "MsgBox.h" + + +IMPLEMENT_DYNAMIC(CDlgRecipeCtrl, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgRecipeCtrl, CDialogEx) + ON_BN_CLICKED(IDOK,OnBnClickedOk) +END_MESSAGE_MAP() + + +CDlgRecipeCtrl::CDlgRecipeCtrl(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgRecipeCtrl::IDD, pParent) +{ +} +CDlgRecipeCtrl::~CDlgRecipeCtrl() +{ +} + +void CDlgRecipeCtrl::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Text(pDX, IDC_NAME_EDIT1, m_EditName1); + DDX_Text(pDX, IDC_NAME_EDIT2, m_EditName2); + DDX_Text(pDX, IDC_STATIC_EDIT1, m_StaticName1); + DDX_Text(pDX, IDC_STATIC_EDIT2, m_StaticName2); + DDX_Control(pDX, IDC_SEL_GROUP_COMBO, m_RecipeCtrlGroupComb); +} + +BOOL CDlgRecipeCtrl::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + CRecipeCtrlItem CtrlItem; + CtrlItem.m_EditName1 = &m_EditName1; + CtrlItem.m_EditName2 = &m_EditName2; + CtrlItem.m_RecipeCtrlGroupComb = &m_RecipeCtrlGroupComb; + gRecipeMgr->RecipeCtrlInit(CtrlItem); + //öԻı + this->SetWindowText(CtrlItem.m_DlgTitle); + + ERecipeCtrlType RecipeCtrlType = gRecipeMgr->GetCurRecipeCtrlType(); + switch(RecipeCtrlType) + { + case _RecipeCtrl_AddGroup: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_NAME_EDIT1)->EnableWindow(true); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(true); + m_StaticName2 = "Add Group Name"; + break; + case _RecipeCtrl_DelGroup: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_NAME_EDIT1)->EnableWindow(false); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(false); + m_StaticName2 = "Delete Group Name"; + break; + case _RecipeCtrl_GroupName: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(true); + m_StaticName1 = "Old Group Name"; + m_StaticName2 = "New Group Name"; + break; + case _RecipeCtrl_AddRecipe: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_SEL_GROUP_COMBO)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_SEL_GROUP_COMBO)->EnableWindow(true); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(true); + m_StaticName1 = "Add to Group"; + m_StaticName2 = "Recipe Name"; + break; + case _RecipeCtrl_DelRecipe: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow((SW_SHOW)); + GetDlgItem(IDC_NAME_EDIT1)->EnableWindow(false); + GetDlgItem(IDC_SEL_GROUP_COMBO)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(false); + m_StaticName1 = "Group Name"; + m_StaticName2 = "Delete Recipe Name"; + break; + case _RecipeCtrl_CopyRecipe: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow((SW_SHOW)); + GetDlgItem(IDC_NAME_EDIT1)->EnableWindow(false); + GetDlgItem(IDC_SEL_GROUP_COMBO)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(true); + m_StaticName1 = "Copy Recipe Name"; + m_StaticName2 = "New Recipe Name"; + break; + case _RecipeCtrl_MoveRecipe: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_SEL_GROUP_COMBO)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_SEL_GROUP_COMBO)->EnableWindow(true); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(false); + m_StaticName1 = "Move to Group"; + m_StaticName2 = "Recipe Name"; + break; + case _RecipeCtrl_RecipeName: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(true); + m_StaticName1 = "Old Recipe Name"; + m_StaticName2 = "New Recipe Name"; + break; + case _RecipeCtrl_AddSubRecipe: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT1)->EnableWindow(false); + GetDlgItem(IDC_SEL_GROUP_COMBO)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(true); + m_StaticName1 = "Add to Recipe"; + m_StaticName2 = "Sub Recipe Name"; + break; + case _RecipeCtrl_DelSubRecipe: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT1)->EnableWindow(false); + GetDlgItem(IDC_SEL_GROUP_COMBO)->ShowWindow(SW_HIDE); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(false); + m_StaticName1 = "From Recipe"; + m_StaticName2 = "Sub Recipe Name"; + break; + case _RecipeCtrl_SubRecipeName: + GetDlgItem(IDC_NAME_EDIT1)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->ShowWindow(SW_SHOW); + GetDlgItem(IDC_NAME_EDIT2)->EnableWindow(true); + m_StaticName1 = "Old SubRecipe Name"; + m_StaticName2 = "New SubRecipe Name"; + break; + default: + break; + } + + + UpdateData(FALSE); + return TRUE; +} + +void CDlgRecipeCtrl::OnBnClickedOk() +{ + UpdateData(TRUE); + CRecipeCtrlItem CtrlItem; + CtrlItem.m_EditName1 = &m_EditName1; + CtrlItem.m_EditName2 = &m_EditName2; + GetDlgItem(IDC_SEL_GROUP_COMBO)->GetWindowText(CtrlItem.m_SelGroupName); + CString Msg = gRecipeMgr->RecipeCtrlExcute(CtrlItem); + if(Msg != "") + { + CMsgBox MsgBox; + MsgBox.Show(Msg); + return; + } + OnOK(); +} \ No newline at end of file diff --git a/LaipuDrawing/DlgRecipeCtrl.h b/LaipuDrawing/DlgRecipeCtrl.h new file mode 100644 index 0000000..8651727 --- /dev/null +++ b/LaipuDrawing/DlgRecipeCtrl.h @@ -0,0 +1,23 @@ +#pragma once + +class CDlgRecipeCtrl : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgRecipeCtrl) + +public: + CDlgRecipeCtrl(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgRecipeCtrl(); + // Ի + enum { IDD = IDD_RECIPE_CTRL_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + afx_msg void OnBnClickedOk(); + DECLARE_MESSAGE_MAP() +private: + CString m_EditName1; + CString m_EditName2; + CString m_StaticName1; + CString m_StaticName2; + CComboBox m_RecipeCtrlGroupComb; +}; diff --git a/LaipuDrawing/DlgTimingProgress.cpp b/LaipuDrawing/DlgTimingProgress.cpp new file mode 100644 index 0000000..0274022 --- /dev/null +++ b/LaipuDrawing/DlgTimingProgress.cpp @@ -0,0 +1,143 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "DlgTimingProgress.h" +#include "afxdialogex.h" +#include "TimingProgressMgr.h" +#include "LaiPuLaserView.h" +#include "AllThreadMgr.h" +#include "GlobalFunction.h" +#include "WorkCmdInvoker.h" +#include "ProgramLaserTuiHuo.h" +#include "CommonFlowMgr.h" + + + +#define UPDATE_INFO_TIMER 1 +#define UPDATE_INFO_TIMER_DELAY 100 + +IMPLEMENT_DYNAMIC(CDlgTimingProgress, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgTimingProgress, CDialogEx) + ON_WM_TIMER() + ON_BN_CLICKED(NEW_STOP_BTN, &CDlgTimingProgress::OnBnClickedStopBtn) +END_MESSAGE_MAP() + +CDlgTimingProgress::CDlgTimingProgress(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgTimingProgress::IDD, pParent) +{ +} +CDlgTimingProgress::~CDlgTimingProgress() +{ +} +void CDlgTimingProgress::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Control(pDX, IDC_WORK_PROGRESS, m_WorkProgress); + DDX_Control(pDX, NEW_STOP_BTN, m_StopBtn); +} +//μ̲ +BOOL CDlgTimingProgress::PreTranslateMessage(MSG* pMsg) +{ + if(pMsg->message==WM_KEYDOWN) + { + char c = pMsg->wParam; + if(c==VK_RETURN || c==VK_ESCAPE) + { + return TRUE; + } + } + return CDialogEx::PreTranslateMessage(pMsg); +} +BOOL CDlgTimingProgress::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + if(gTimingProgressMgr.IsbCloseApp()) + { + Sleep(1000); + + gAllThreadMgr.StopAllThread(); + } + gTimingProgressMgr.SetbExecuting(true); + SetTimer(UPDATE_INFO_TIMER,UPDATE_INFO_TIMER_DELAY,NULL); + + if(gProgramLaserTuiHuo->IsbAutoWorking() + || gCommonFlowMgr->IsbXyMoveTesting() + || gTimingProgressMgr.IsbStopBtn() + ) + { + GetDlgItem(NEW_STOP_BTN)->ShowWindow(SW_SHOW); + } + gTimingProgressMgr.SetbStopBtn(false); + //öԻϲʾ + CRect rect; + GetClientRect(&rect); + ::SetWindowPos(m_hWnd, HWND_TOPMOST, 0, 0, rect.Width(), rect.Height(), SWP_NOMOVE); + + UpdateData(FALSE); + return TRUE; +} +//ֹEsc رնԻ +void CDlgTimingProgress::OnCancel() +{ + return; +} +void CDlgTimingProgress::OnTimer(UINT nIDEvent) +{ + if(nIDEvent == UPDATE_INFO_TIMER) + { + KillTimer(UPDATE_INFO_TIMER); + if(!gExitApp) + { + UpdateInfo(); + SetTimer(UPDATE_INFO_TIMER,UPDATE_INFO_TIMER_DELAY,NULL); + } + } + CDialog::OnTimer(nIDEvent); +} +void CDlgTimingProgress::UpdateInfo() +{ + //ִʱʱms + gTimingProgressMgr.AddCurExecuteTime(UPDATE_INFO_TIMER_DELAY); + //ʱ䵽ˣǿֹͣ(ǹرʱ) + //if(!gTimingProgressMgr.IsbCloseApp() && (gTimingProgressMgr.CheckCurExecuteTime(-1)||gTimingProgressMgr.IsbStopExecute())) + //ʱ䵽˲ҪԶر + if(!gTimingProgressMgr.IsbCloseApp() && (gTimingProgressMgr.IsbStopExecute())) + { + gTimingProgressMgr.SetShowInfo(""); + gTimingProgressMgr.SetbExecuting(false); + OnOK(); + } + //رʱ(5)ȴ̹߳رղŽ + if(gTimingProgressMgr.IsbCloseApp() && gTimingProgressMgr.CheckCurExecuteTime(5000)) + { + //ʱ߳Dz,ʾ̵߳ + if(gAllThreadMgr.HasThreadRunning()) + { + gAllThreadMgr.ShowRunningThreadName(); + } + else + { + OnOK(); + } + } + //ʾûйر̵߳ + if(gTimingProgressMgr.IsbCloseApp() && (!gAllThreadMgr.HasThreadRunning()) && gTimingProgressMgr.CheckCurExecuteTime(5000)) + { + OnOK(); + } + CString NewShowInfo = gTimingProgressMgr.GetShowInfo(); + if(NewShowInfo != m_ShowInfo)//仯ʱˢ + { + m_ShowInfo = NewShowInfo; + GetDlgItem(IDC_STATIC_EXECUTE_INFO)->SetWindowText(m_ShowInfo); + } + double progress = gTimingProgressMgr.GetProgressVal(); + m_WorkProgress.SetPos((int)progress); +} +//ֹͣ +void CDlgTimingProgress::OnBnClickedStopBtn() +{ + gLogMgr->WriteDebugLog("Func---->OnBnClickedTimingProgressStopBtn"); + gStopAllWrokCmd = true; + GetDlgItem(NEW_STOP_BTN)->EnableWindow(false); +} diff --git a/LaipuDrawing/DlgTimingProgress.h b/LaipuDrawing/DlgTimingProgress.h new file mode 100644 index 0000000..5a53c42 --- /dev/null +++ b/LaipuDrawing/DlgTimingProgress.h @@ -0,0 +1,29 @@ +#pragma once +#include "MyPictrueBttom.h" + + +//ʱdlg +class CDlgTimingProgress : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgTimingProgress) +public: + CDlgTimingProgress(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgTimingProgress(); + virtual void OnCancel(); + enum { IDD = IDD_TIMING_PROGRESS_DLG }; +private: + void UpdateInfo(); +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + afx_msg BOOL PreTranslateMessage(MSG* pMsg); + afx_msg void OnTimer(UINT nIDEvent); + + DECLARE_MESSAGE_MAP() +private: + CString m_ShowInfo;//ʾϢ + CProgressCtrl m_WorkProgress;// + CMyPictrueBttom m_StopBtn; +public: + afx_msg void OnBnClickedStopBtn(); +}; diff --git a/LaipuDrawing/DlgWorkRecord.cpp b/LaipuDrawing/DlgWorkRecord.cpp new file mode 100644 index 0000000..6f4b324 --- /dev/null +++ b/LaipuDrawing/DlgWorkRecord.cpp @@ -0,0 +1,103 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "DlgWorkRecord.h" +#include "afxdialogex.h" +#include "WorkRecord.h" +#include "ProgramLaserTuiHuo.h" +#include "PenParMgr.h" +#include "LogMgr.h" +#include "MsgBox.h" +#include "GlobalFunction.h" + + + +IMPLEMENT_DYNAMIC(CDlgWorkRecord, CDialogEx) + +CDlgWorkRecord::CDlgWorkRecord(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgWorkRecord::IDD, pParent) +{ + m_CurSelIdx = -1;//ǰѡеֵ +} +CDlgWorkRecord::~CDlgWorkRecord() +{ +} +void CDlgWorkRecord::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + DDX_Control(pDX, IDC_SEARCH_BTN, m_SearchBtn); + DDX_Control(pDX, IDC_RECORD_LIST, m_RecordList); + DDX_Control(pDX, IDC_RECORD_INFO_LIST, m_RecordInfoList); + DDX_Control(pDX, IDC_MONTHCALENDAR1, m_montCtrl); + DDX_Text(pDX, IDC_LOT_NUMBER, m_SearchNumber); +} + + +BEGIN_MESSAGE_MAP(CDlgWorkRecord, CDialogEx) + ON_NOTIFY(MCN_SELCHANGE, IDC_MONTHCALENDAR1, OnMcnSelchangecalendar) + ON_BN_CLICKED(IDC_SEARCH_BTN, &CDlgWorkRecord::OnBnClickedSearchBtn) + ON_NOTIFY(NM_CLICK, IDC_RECORD_LIST, &CDlgWorkRecord::OnNMClickList) + ON_BN_CLICKED(IDC_TO_EXCEL_BTN, &CDlgWorkRecord::OnBnClickedToExcelBtn) +END_MESSAGE_MAP() + +BOOL CDlgWorkRecord::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + m_SearchBtn.SetUpColor(RGB_GREEN); + + UpdateData(FALSE); + return TRUE; +} +//Ӧڱ仯 +void CDlgWorkRecord::OnMcnSelchangecalendar(NMHDR *pNMHDR, LRESULT *pResult) +{ + + m_CurSelIdx = -1; + *pResult = 0; +} +CString CDlgWorkRecord::GetSelDate() +{ + CTime month; + m_montCtrl.GetCurSel(month); //ȡǰϢ + CWorkTime WorkTime; + CString SelDate = WorkTime.GetDateStr(month,"_"); + return SelDate; +} +//б +void CDlgWorkRecord::OnNMClickList(NMHDR *pNMHDR, LRESULT *pResult) +{ + *pResult = 0; + int idx = GetCurListIdx(m_RecordList); + if(idx>=0) + { + //ѡidx Ϊǰ¼ + m_CurSelIdx = idx; + } +} +//ѡк +bool CDlgWorkRecord::CheckCurSelIdx() +{ + if(m_CurSelIdx<0) + { + CMsgBox MsgBox; + MsgBox.Show("ѡҪļ¼!"); + return false; + } + return true; +} +//ͨID ŲҼ¼ +void CDlgWorkRecord::OnBnClickedSearchBtn() +{ + if(!UpdateData(TRUE)) + return; + m_CurSelIdx = -1; +} + +//ѡеļ¼excel +void CDlgWorkRecord::OnBnClickedToExcelBtn() +{ + //ѡк + if(!CheckCurSelIdx()) + return; + +} diff --git a/LaipuDrawing/DlgWorkRecord.h b/LaipuDrawing/DlgWorkRecord.h new file mode 100644 index 0000000..e3bf727 --- /dev/null +++ b/LaipuDrawing/DlgWorkRecord.h @@ -0,0 +1,33 @@ +#pragma once +#include "MyBttom.h" + +class CDlgWorkRecord : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgWorkRecord) + +public: + CDlgWorkRecord(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgWorkRecord(); + CString GetSelDate(); + bool CheckCurSelIdx(); + enum { IDD = IDD_WORK_RECORD_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + afx_msg void OnMcnSelchangecalendar(NMHDR *pNMHDR, LRESULT *pResult); + afx_msg void OnBnClickedSearchBtn(); + afx_msg void OnNMClickList(NMHDR *pNMHDR, LRESULT *pResult); + DECLARE_MESSAGE_MAP() +private: + CMyBottom m_SearchBtn; + CMyBottom m_ToExcelBtn; + CMyBottom m_RecoverScanParBtn; + + CMonthCalCtrl m_montCtrl; + CListCtrl m_RecordList; + CListCtrl m_RecordInfoList; + CString m_SearchNumber; + int m_CurSelIdx;//ǰѡеֵ +public: + afx_msg void OnBnClickedToExcelBtn(); +}; diff --git a/LaipuDrawing/DrawSimpleShape.h b/LaipuDrawing/DrawSimpleShape.h new file mode 100644 index 0000000..513e0f4 --- /dev/null +++ b/LaipuDrawing/DrawSimpleShape.h @@ -0,0 +1,177 @@ +#pragma once +#include "GlobalDrawMgr.h" +#include "SequentialPoint.h" +#include "ObjCircle.h" +#include "DrawSimpleShape.h" + +//һЩ򵥵ͼ +inline void DrawRect(CDC* pDC,CPen&Pen,Dbxy pt1,Dbxy pt2,bool bXor = true) +{ + CSequentialPoint PtContainer; + PtContainer.AddDataPoint(Dbxy(pt1.x,pt1.y)); + PtContainer.AddDataPoint(Dbxy(pt1.x,pt2.y)); + PtContainer.AddDataPoint(Dbxy(pt2.x,pt2.y)); + PtContainer.AddDataPoint(Dbxy(pt2.x,pt1.y)); + PtContainer.AddDataPoint(Dbxy(pt1.x,pt1.y)); + + if(bXor) + { + int old_rop = pDC->SetROP2(R2_XORPEN); + PtContainer.Draw( pDC, Pen); + pDC->SetROP2(old_rop); + } + else + { + PtContainer.Draw( pDC, Pen); + } +} +inline void DrawRect(CDC* pDC,CPen&Pen,DbRect rect,bool bXor = true) +{ + Dbxy pt1(rect.L,rect.T); + Dbxy pt2(rect.R,rect.B); + DrawRect(pDC,Pen,pt1,pt2,bXor); +} +//һ +inline void DrawRect(CDC* pDC,CPen&Pen,Dbxy pt,double size,bool bXor = true) +{ + Dbxy pt1(pt.x-size,pt.y+size); + Dbxy pt2(pt.x+size,pt.y-size); + DrawRect(pDC,Pen,pt1,pt2,bXor); +} +//һX ʮ +inline void XorDrawCrossX(CDC* pDC,CPen&Pen,Dbxy pt1,Dbxy pt2) +{ + CSequentialPoint PtContainer1,PtContainer2; + PtContainer1.AddDataPoint(Dbxy(pt1.x,pt1.y)); + PtContainer1.AddDataPoint(Dbxy(pt2.x,pt2.y)); + PtContainer2.AddDataPoint(Dbxy(pt2.x,pt1.y)); + PtContainer2.AddDataPoint(Dbxy(pt1.x,pt2.y)); + + int old_rop = pDC->SetROP2(R2_XORPEN); + PtContainer1.Draw( pDC, Pen); + PtContainer2.Draw( pDC, Pen); + pDC->SetROP2(old_rop); +} +inline void XorDrawCrossX(CDC* pDC,CPen&Pen,DbRect rect) +{ + Dbxy pt1(rect.L,rect.T); + Dbxy pt2(rect.R,rect.B); + XorDrawCrossX(pDC,Pen,pt1,pt2); +} +inline void DrawCrossX(CDC* pDC,CPen&Pen,Dbxy pt1,Dbxy pt2) +{ + CSequentialPoint PtContainer1,PtContainer2; + PtContainer1.AddDataPoint(Dbxy(pt1.x,pt1.y)); + PtContainer1.AddDataPoint(Dbxy(pt2.x,pt2.y)); + PtContainer2.AddDataPoint(Dbxy(pt2.x,pt1.y)); + PtContainer2.AddDataPoint(Dbxy(pt1.x,pt2.y)); + + PtContainer1.Draw( pDC, Pen); + PtContainer2.Draw( pDC, Pen); +} +inline void DrawCrossX(CDC* pDC,CPen&Pen,DbRect rect) +{ + Dbxy pt1(rect.L,rect.T); + Dbxy pt2(rect.R,rect.B); + DrawCrossX(pDC,Pen,pt1,pt2); +} +inline void XorDrawCross(CDC* pDC,bool bXor,CPen&Pen,Dbxy pt,double size) +{ + CSequentialPoint PtContainer1,PtContainer2; + PtContainer1.AddDataPoint(Dbxy(pt.x,pt.y+size)); + PtContainer1.AddDataPoint(Dbxy(pt.x,pt.y-size)); + PtContainer2.AddDataPoint(Dbxy(pt.x-size,pt.y)); + PtContainer2.AddDataPoint(Dbxy(pt.x+size,pt.y)); + + int old_rop; + if(bXor) + old_rop = pDC->SetROP2(R2_XORPEN); + PtContainer1.Draw( pDC, Pen); + PtContainer2.Draw( pDC, Pen); + if(bXor) + pDC->SetROP2(old_rop); +} +//һʵľ +inline void DrawSolidRect(CDC* pDC,COLORREF color,DbRect rect) +{ + CBrush brush,*pOldBrush; + brush.CreateSolidBrush(color); + pOldBrush=pDC->SelectObject(&brush); + pDC->Rectangle(&gDraw->DbRect2CRect(rect)); + pDC->SelectObject(pOldBrush); +} +inline void XorDrawLine(CDC* pDC,CPen&Pen,Dbxy pt1,Dbxy pt2) +{ + CSequentialPoint PtContainer; + PtContainer.AddDataPoint(Dbxy(pt1.x,pt1.y)); + PtContainer.AddDataPoint(Dbxy(pt2.x,pt2.y)); + + int old_rop = pDC->SetROP2(R2_XORPEN); + PtContainer.Draw( pDC, Pen); + pDC->SetROP2(old_rop); +} +inline void DrawLine(CDC* pDC,CPen&Pen,Dbxy pt1,Dbxy pt2) +{ + CSequentialPoint PtContainer; + PtContainer.AddDataPoint(Dbxy(pt1.x,pt1.y)); + PtContainer.AddDataPoint(Dbxy(pt2.x,pt2.y)); + PtContainer.Draw( pDC, Pen); +} + +//ȡתɫ +inline COLORREF GetXorColor(COLORREF color) +{ + BYTE r = GetRValue(color); + BYTE g = GetGValue(color); + BYTE b = GetBValue(color); + + COLORREF clr = RGB(255-r,255-g,255-b); + return clr; +} +inline void DrawCircle(CDC* pDC,CPen&Pen,Dbxy pt,double R,int DEdgeCnt) +{ + CObjCircle ObjCircle; + CCirclePar par; + par.CenterPt = pt; + par.Radius = R; + par.DEdgeCnt = DEdgeCnt; + ObjCircle.Creat(par); + ObjCircle.Draw(pDC,Pen); +} +inline void DrawSolidCircle(CDC* pDC,COLORREF color,Dbxy pt,double R) +{ + CBrush brush,*pOldBrush; + brush.CreateSolidBrush(color); + pOldBrush=pDC->SelectObject(&brush); + pDC->Ellipse(&gDraw->DbRect2CRect(DbRect(pt,R))); + pDC->SelectObject(pOldBrush); +} +//ھηΧڻ(gap ߵļ) +inline void Drawgridding(CDC* pDC,CPen&Pen,DbRect rect,double gap) +{ + // + { + Dbxy pt1(rect.L,rect.B); + Dbxy pt2(rect.R,rect.B); + double CurY = rect.B; + while(CurYGetCurrScaleVal(m_Gap); + rect.L -= Gap; + rect.R += Gap; + rect.B -= Gap; + rect.T += Gap; + return rect; +} +//ò׼ +Dbxy CEasyOperationMgr::GetBasePt() +{ + Dbxy pt; + switch(m_OprDir) + { + case _DIR_U: + case _DIR_R: + case _DIR_RT: + pt.x = m_OperatRect.L; + pt.y = m_OperatRect.B; + break; + case _DIR_D: + case _DIR_RB: + pt.x = m_OperatRect.L; + pt.y = m_OperatRect.T; + break; + case _DIR_L: + case _DIR_LT: + pt.x = m_OperatRect.R; + pt.y = m_OperatRect.B; + break; + case _DIR_LB: + pt.x = m_OperatRect.R; + pt.y = m_OperatRect.T; + break; + default: + break; + } + return pt; +} +double CEasyOperationMgr::GetSize(X_OR_Y xy) +{ + double size = 0; + if(xy = _X) + size = m_OperatRect.Width(); + else + size = m_OperatRect.Height(); + return size; +} +Dbxy CEasyOperationMgr::GetDiff(Dbxy StartPt,Dbxy EndPt) +{ + Dbxy diff; + switch(m_OprDir) + { + case _DIR_R: + case _DIR_RT: + case _DIR_RB: + diff.x = EndPt.x - StartPt.x; + break; + case _DIR_L: + case _DIR_LT: + case _DIR_LB: + diff.x = StartPt.x - EndPt.x; + break; + default: + break; + } + switch(m_OprDir) + { + + case _DIR_LT: + case _DIR_U: + case _DIR_RT: + diff.y = EndPt.y - StartPt.y; + break; + case _DIR_LB: + case _DIR_D: + case _DIR_RB: + diff.y = StartPt.y - EndPt.y; + break; + default: + break; + } + return diff; +} +void CEasyOperationMgr::Draw(CDC* pDC) +{ + if(m_bShow) + { + DbRect rect = GetDrawRect(); + COLORREF color = gDraw->GetEasyOperationColor(); + { + Dbxy pt(rect.L,rect.T); + DrawSolidRect(pDC,color,gDraw->GetCurPointRect(pt)); + } + { + Dbxy pt(rect.L,rect.B); + DrawSolidRect(pDC,color,gDraw->GetCurPointRect(pt)); + } + { + Dbxy pt(rect.R,rect.B); + DrawSolidRect(pDC,color,gDraw->GetCurPointRect(pt)); + } + { + Dbxy pt(rect.R,rect.T); + DrawSolidRect(pDC,color,gDraw->GetCurPointRect(pt)); + } + { + Dbxy pt((rect.R+rect.L)/2,rect.T); + DrawSolidRect(pDC,color,gDraw->GetCurPointRect(pt)); + } + { + Dbxy pt((rect.R+rect.L)/2,rect.B); + DrawSolidRect(pDC,color,gDraw->GetCurPointRect(pt)); + } + { + Dbxy pt(rect.L,(rect.T+rect.B)/2); + DrawSolidRect(pDC,color,gDraw->GetCurPointRect(pt)); + } + { + Dbxy pt(rect.R,(rect.T+rect.B)/2); + DrawSolidRect(pDC,color,gDraw->GetCurPointRect(pt)); + } + } +} +void CEasyOperationMgr::Refresh() +{ + if(gDraw->IsbUseEasyOperation()) + { + CLayer &layer = gLayer; + if(layer.HasObjSel()) + { + m_bShow = true; + SetRect(layer.GetSelObjRect()); + } + else + { + m_bShow = false; + } + } +} +//ж깤 +MOUSE_TOOL CEasyOperationMgr::JudgeMouseToolType(Dbxy MousePt) +{ + MOUSE_TOOL type = _TOOL_POINT; + if(!m_bShow) + return type; + + DbRect rect = GetDrawRect(); + if(JudgeMouseToolTypeExt(MousePt,Dbxy(rect.L,rect.T),type) != _TOOL_POINT) + { + m_OprDir = _DIR_LT; + } + else if(JudgeMouseToolTypeExt(MousePt,Dbxy(rect.L,rect.B),type) != _TOOL_POINT) + { + m_OprDir = _DIR_LB; + } + else if(JudgeMouseToolTypeExt(MousePt,Dbxy(rect.R,rect.B),type) != _TOOL_POINT) + { + m_OprDir = _DIR_RB; + } + else if(JudgeMouseToolTypeExt(MousePt,Dbxy(rect.R,rect.T),type) != _TOOL_POINT) + { + m_OprDir = _DIR_RT; + } + else if(JudgeMouseToolTypeExt(MousePt,Dbxy((rect.R+rect.L)/2,rect.T),type) != _TOOL_POINT) + { + m_OprDir = _DIR_U; + } + else if(JudgeMouseToolTypeExt(MousePt,Dbxy((rect.R+rect.L)/2,rect.B),type) != _TOOL_POINT) + { + m_OprDir = _DIR_D; + } + else if(JudgeMouseToolTypeExt(MousePt,Dbxy(rect.L,(rect.T+rect.B)/2),type) != _TOOL_POINT) + { + m_OprDir = _DIR_L; + } + else if(JudgeMouseToolTypeExt(MousePt,Dbxy(rect.R,(rect.T+rect.B)/2),type) != _TOOL_POINT) + { + m_OprDir = _DIR_R; + } + return type; +} +MOUSE_TOOL CEasyOperationMgr::JudgeMouseToolTypeExt(Dbxy MousePt,Dbxy pt,MOUSE_TOOL &type) +{ + DbRect rect = gDraw->GetCurPointRect(pt); + if(IsPointInRect(MousePt,rect)) + { + type = _TOOL_STRETCH; + } + return type; +} \ No newline at end of file diff --git a/LaipuDrawing/EasyOperationMgr.h b/LaipuDrawing/EasyOperationMgr.h new file mode 100644 index 0000000..ed9abee --- /dev/null +++ b/LaipuDrawing/EasyOperationMgr.h @@ -0,0 +1,35 @@ +#pragma once +#include "module.h" +#include "GlobalDefine.h" +#include "EnumDirection.h" + +//obj ݲ +class CEasyOperationMgr :public CModule +{ +public: + CEasyOperationMgr(void); + ~CEasyOperationMgr(void); + virtual void Draw(CDC* pDC); + virtual MODULE GetModuleType(){return _EASY_OPERATION_PROP;}; + + + void SetShow(bool b){m_bShow = b;}; + void Refresh(); + MOUSE_TOOL JudgeMouseToolType(Dbxy pt); + DIRECTION GetOprDir(){return m_OprDir;};//ȡ + Dbxy GetBasePt(); + double GetSize(X_OR_Y xy); + Dbxy GetDiff(Dbxy StartPt,Dbxy EndPt); +private: + void SetRect(DbRect rect); + DbRect GetDrawRect(); + MOUSE_TOOL JudgeMouseToolTypeExt(Dbxy MousePt,Dbxy pt,MOUSE_TOOL &type); +private: + bool m_bShow;//Ƿʾ + DbRect m_OperatRect;//Χľ + double m_Gap;//ѡobj ļ + + DIRECTION m_OprDir;//ķ +}; + +extern CEasyOperationMgr *gEasyOperationMgr; \ No newline at end of file diff --git a/LaipuDrawing/EncryptionMgr.cpp b/LaipuDrawing/EncryptionMgr.cpp new file mode 100644 index 0000000..ddcb33f --- /dev/null +++ b/LaipuDrawing/EncryptionMgr.cpp @@ -0,0 +1,108 @@ +#include "StdAfx.h" +#include "EncryptionMgr.h" +#include "LogMgr.h" +#include "MsgBox.h" +#include "winioctl.h" +#include "WarningMgr.h" + + + +#pragma comment( lib, "KernelMode.lib") +CKernelMode gKernelMode; + + +#define LEFT_DAYS_ALAM 10 //ʣ༸ʾ + +CEncryptionMgr *gEncryptionMgr = new CEncryptionMgr; +CEncryptionMgr::CEncryptionMgr(void) +{ + m_LeftDays = 0;//ʣ + m_bRunAtNoteBook = false;//ǷڱʼDZ +} +CEncryptionMgr::~CEncryptionMgr(void) +{ +} +void CEncryptionMgr::OnAppInitialize() +{ + m_CurHardDiskSerialNum = GetHardDiskSerialNum(); + set NoteBookHardDiskSerialSet; + NoteBookHardDiskSerialSet.insert("2cc413dd");//k2450 ʼDZ + NoteBookHardDiskSerialSet.insert("4a410fe7");//t420 ʼDZ + NoteBookHardDiskSerialSet.insert("ebfac14d");//T460S ʼDZ + NoteBookHardDiskSerialSet.insert("d8affd1b");//ʵƽ̨ + NoteBookHardDiskSerialSet.insert("6c83a0a8");//Сnotebook + //NoteBookHardDiskSerialSet.insert("600451aa");//ʵƽ̨ + //ʼDZ + if(NoteBookHardDiskSerialSet.count(m_CurHardDiskSerialNum)) + { + m_bRunAtNoteBook = true; + } +} +//ȡӲк(CӲ) +CString CEncryptionMgr::GetHardDiskSerialNum() +{ + CString id; + char Name[MAX_PATH]; + DWORD serno; + DWORD length; + DWORD FileFlag; + char FileName[MAX_PATH]; + BOOL Ret; + Ret = GetVolumeInformation("c:\\", Name, MAX_PATH, &serno, &length, &FileFlag, FileName, MAX_PATH); + if (Ret) + id.Format( "%x", serno); + return id; +} +#if 1 +/* +code:530001 豸ûзּܹ +code:530002 ȡBinaryļ +code:530003 BinaryļIDͼܹIDƥ +code:530004 ݹ +code:530005 ·ݹ +code:530006 +code:530007 кŲƥ +*/ +//״̬(false) +bool CEncryptionMgr::CheckLockState() +{ + return true; + #ifndef __USE_SUPER_DOG__ + return true; + #endif + //ʼDZ + if(m_bRunAtNoteBook) + { + return true; + } + + int code = gKernelMode.CheckState(); + //ʱ仹ʣn + if(code>100 && code<=(100+LEFT_DAYS_ALAM)) + { + m_LeftDays = code-100; + } + else if(code==0 || code>(100+LEFT_DAYS_ALAM)) + { + m_LeftDays = 0;//ʣ + } + else if(code>0 && code!=7)//(Ҫк) + { + m_LeftDays = 0;//ʣ + + CString AddInfo; + AddInfo.Format(_T("ʹȨ쳣(code :53000%d)"),code); + gWarningMgr->SendWarningMsg(_Warning_Code_14,AddInfo); + return false; + } + //ʣ(10 ʾ) + CheckLeftDays(); + return true; +} +//ʣ(10 ʾ) +void CEncryptionMgr::CheckLeftDays() +{ + +} +#endif + diff --git a/LaipuDrawing/EncryptionMgr.h b/LaipuDrawing/EncryptionMgr.h new file mode 100644 index 0000000..7b9500c --- /dev/null +++ b/LaipuDrawing/EncryptionMgr.h @@ -0,0 +1,26 @@ +#pragma once +#include "module.h" + +#include "KernelMode.h" +extern CKernelMode gKernelMode; + +//豸ܹ +class CEncryptionMgr :public CModule +{ +public: + CEncryptionMgr(void); + ~CEncryptionMgr(void); + virtual void OnAppInitialize(); + bool CheckLockState(); + void CheckLeftDays(); + bool IsbRunAtNoteBook(){return m_bRunAtNoteBook;}; + CString GetCurHardDiskSerialNum(){return m_CurHardDiskSerialNum;}; +private: + CString GetHardDiskSerialNum(); +private: + int m_LeftDays;//ʣ + bool m_bFirstExt;//һִ + bool m_bRunAtNoteBook;//ǷڱʼDZ + CString m_CurHardDiskSerialNum;//ǰӲк +}; +extern CEncryptionMgr *gEncryptionMgr; diff --git a/LaipuDrawing/EnumDirection.h b/LaipuDrawing/EnumDirection.h new file mode 100644 index 0000000..26c8dca --- /dev/null +++ b/LaipuDrawing/EnumDirection.h @@ -0,0 +1,14 @@ +#pragma once + +enum DIRECTION// +{ + _DIR_M = 0,// + _DIR_R, + _DIR_L, + _DIR_U, + _DIR_D, + _DIR_LT,// + _DIR_LB, + _DIR_RB, + _DIR_RT, +}; diff --git a/LaipuDrawing/EnumPropertieType.h b/LaipuDrawing/EnumPropertieType.h new file mode 100644 index 0000000..c2c6f0b --- /dev/null +++ b/LaipuDrawing/EnumPropertieType.h @@ -0,0 +1,127 @@ +#pragma once + +//Ե +enum PROPERTIE_TYPE +{ + _PROP_TYPE_INT=0, + _PROP_TYPE_DOUBLE, + _PROP_TYPE_STRING, + _PROP_TYPE_BOOL, + _PROP_TYPE_COLOR, +}; +//ʶģid +enum MODULE +{ + _MODULE_NULL = 0,//ʾʱҪ + _DRAW_PROP,//ͬ + _LOG_PROP,//־ + _OBJ_PROP,//ͼ + _PLT_PROP,//plt + _PCI365_PORT_PROP,//pci 365 ˿ + _MOTION_CTRL_PROP,//˶ + _MODULE_PCI365,//pci 365 + _MOTOR_PROP,// + _TOOL_CUT_PROP,//и + _APP_PRIORITY_PROP,//ȼ + _WORK_AREA_PROP,//⹤Χ + _DAHEN_CCD_PROP,//CCD + _GRATING_RULER_PROP,//դ + _RULER_PROP,// + _SIMULATE_PROP,//ģ켣 + _REAL_DATA_PROP,//ʵݹ + _MIRROR_PROP,// + _SINGLE_CHIP_CARD,//ϻ + _KEYENCE_CCD_PROP,//ʿCCD + _TEMPLATE_PROP,//ģ + _SOCKET_PROP,//socket ͨŹ + _OBJ_COMPONENT_PROP,//Ԫ + _LASER_PROP,// + _LAIPU_VB_DLL_PROP,//dll + _EASY_OPERATION_PROP,//ͼαݲ + _COMPENSATE_AREA_PROP,// + _AUTHORITY_PROP,//Ȩ޹ + _MARK_AREA_PROP,//markarea + _PRODUCT_PROP,//Ʒ + _PLATFORM_XY_DRAW_PROP,//ƽ̨λû + _SPECTRA_PHYSICS_LASER_PROP,// + _PEN_PAR_PROP,//ʲ + _TUI_HUO_MGR,//˻ + _OPTO_WAVE_LASER_PROP,//Ⲩ + _UPK_CO2_PROP,//ɿCO2 ׻ + _UPK_CCD_PROP,//ɿ˵CCD + _UPK_PLC_PROP,//ɿPLC + _MARK_DATA_PROP,//ӹݹ + _BASLER_CCD_PROP,//¹BASLER CCD + _LPS_IS3000_PROP,//LPS + _LPS_IS3000_PLC_PROP, + _LPS_IS3000_CUT_TEMP, + _COMMON_FLOW_PROP,// + _HAWKVIS_CCD_PROP,//ӾCAMERA + _WORK_RECORD_PROP,//ӹ¼ + _COMB_DRAW_PROP,//ͨ + _DXF_FILE_READ_PROP,//dxf ļȡ + _MOTION_CARD_PCI1245L,//лPCI1245L ˶ƿ + _WORK_FILE_PROP,//ļ + _PLC_IO_PROP, + _WORK_DATA_PROP, + _RFP_EXCELLENT_532_PORP, + _PGM_SZ_HJ_PROP, + _IO_CTRL_PROP, + _DEVICE_PAR_PORP, + _MEASURE_TEMP_PROP, + _INNOLAS_LASER_PROP, + _PROGRAM_LASER_ANEAL_PROP, + _SIMPLE_CTRL_DLG_PROP, + _THORLABS_PROP, + _DISTANCE_METER_PROP, + _WAFER_SCAN_INFO,//Ԫɨ¼ + _LASER_POW_DEVICE_PROP, + + _THERMORACK_401_PROP, + _DEVICE_STATE_PROP, + _DEVICE_WARNING_PROP, + + _PHOTONICS_LASER_PROP,//PI + _MOTOR_SPEED_PROP,//ٶ + _BEAMTECH_LASER_PROP,//ر缤 + _WAFER_ADJUST_PROP,//Բ׼ֱ + + _LASER_SPOT_METER_PROP,// + _TEK_OSCILLOSCOPE_PROP,//TEK ʾ + _MANUAL_TEST_PROP, + _WAFER_RECIPE_DATA_PROP, + _LASER_RED_DEVICE_PROP,// + _WAVE_FORM_CHANNEL_PROP,//ο + _TRANSFER_ARM_PORP, + _REMOTE_CTRL_PROP, + _JOB_QUEUE_PROP, + _SEMI_SECS_PORP, + _LANGUAGE_PORP, + _SCANLAB_RTC5_PORP, + _OXYGEN_CHECK_PROP,//Ũȼ + _ANNEAL_MONITORING_PROP,//˻صļع + _SPECIAL_POS_PORP, + _ROBOT_CTRL_DYH_PORP, + _ALIGNER_CTRL_DYH_PORP, + _ROTATO_DIMMER_PORP, + _FOUP_LOAD_PORT_PORP, + _NEW_JOB_QUEUE_PROP, + _MACHINE_GATE_PROP, +}; + +//comb +enum DRAW_PROP_COMB_TYPE +{ + _COMB_OBJ_PROP = 0,//obj +}; +//豸comb +enum DEVICE_PROP_COMB_TYPE +{ + _COMB_SHOW_PROP=0,//ʾ + _COMB_IO_CTRL_PROP,//IO + _COMB_MOTOR_PROP,// + _COMB_PROCESS_FLOW_PROP,// + _COMB_SPECIAL_DEVICE_PROP,//Ӳģ + _COMB_SPECAIL_POS_PROP,//λ + _COMB_OTHER_PROP,// +}; \ No newline at end of file diff --git a/LaipuDrawing/EnumValStrType.h b/LaipuDrawing/EnumValStrType.h new file mode 100644 index 0000000..e968737 --- /dev/null +++ b/LaipuDrawing/EnumValStrType.h @@ -0,0 +1,33 @@ +#pragma once + +//ɱı +enum VAL_STR_TYPR +{ + _STR_FIXED = 0,//̶ı + _STR_SN,//к + _STR_DATE,// + _STR_TIME,//ʱ + _STR_ERROR,// +}; +//ɱڵ +enum VAL_DATE_TYPR +{ + _DATE_YEAR_FOUR = 0,//2014 + _DATE_YEAR_TWO,//14 + _DATE_MONTH,//05 + _DATE_DAY,//16 + _DATE_DAY_IN_YEAR,//136 + _DATE_WEEK,//05 + _DATE_WEEK_IN_YEAR,//20 + _DATE_MAX, +}; +enum VAL_TIME_TYPR +{ + _TIME_HOUR_24 = 0,//Сʱ24 + _TIME_HOUR_12,//Сʱ12 + _TIME_MINUTE,// + _TIME_SECOND,// + _TIME_AM_OR_PM_1,//ʱAM,PM + _TIME_AM_OR_PM_2,//ʱam,pm + _TIME_MAX, +}; \ No newline at end of file diff --git a/LaipuDrawing/ExcelMgr.cpp b/LaipuDrawing/ExcelMgr.cpp new file mode 100644 index 0000000..38e0695 --- /dev/null +++ b/LaipuDrawing/ExcelMgr.cpp @@ -0,0 +1,114 @@ +#include "StdAfx.h" +#include "ExcelMgr.h" +#include "MsgBox.h" +#include "LogMgr.h" + +//һ㰲װWPS2019 Ϳʹ +CExcelMgr::CExcelMgr(void) +{ +} +CExcelMgr::~CExcelMgr(void) +{ + m_bCreateOk = false;//ǷɹExcel ļ +} +bool CExcelMgr::CreatExcelFile() +{ + /* COleVariantΪVARIANT͵İװ + ԶУͨʹARIANTͽвݡ + гУͨCOleVariantת˵ġ + */ + //covOptional ѡVARIANT + COleVariant covOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR); + + if(!m_app.CreateDispatch("Excel.Application") ) + { + //ʱװWPS ﻹǻᱨ,ԺԵ + CMsgBox MsgBox; + MsgBox.Show("޷ExcellentӦ,Ҫ°װExcel");// + return false; + } + //ȡ + m_books=m_app.GetWorkbooks(); + //һ + m_book=m_books.Add(covOptional); + //ȡ + m_sheets=m_book.GetSheets(); + //ȡһ + m_sheet=m_sheets.GetItem(COleVariant((short)1)); + + m_bCreateOk = true;//ǷɹExcel ļ + return m_bCreateOk; +} +//ʾExcel +void CExcelMgr::ShowExcelFile() +{ + if(!m_bCreateOk) + return; + //ʾExcel񣬲״̬Ϊûɿ + m_app.SetVisible(TRUE); + m_app.SetUserControl(TRUE); +} +//ȡԪ(A1,D4) +CString CExcelMgr::GetCellIdxStr(int Row,int Col) +{ + Col -= 1; + CString IdxStr; + int num = 65;// AUnicode + CString colName = ""; + do + { + if(colName.GetLength() > 0) + { + Col--; + } + int remainder = Col % 26; + colName = ((char) (remainder + num)) + colName; + Col = (int) ((Col - remainder) / 26); + } while (Col > 0); + + IdxStr.Format(_T("%d"),Row); + IdxStr = colName+IdxStr; + //gLogMgr->WriteDebugLog(IdxStr); + return IdxStr; +} +//õԪı(Row еCol )(bBold Ƿ) +void CExcelMgr::SetCellTxt(int Row,int Col,CString txt,bool bBold) +{ + if(!m_bCreateOk) + return; + + Range range; //Ԫ + MyFont font; + Range cols; + //ѡеRowеColеĵԪ + CString IdxStr = GetCellIdxStr(Row,Col); + range=m_sheet.GetRange(COleVariant(IdxStr),COleVariant(IdxStr)); + + //A1="HELLO EXCEL" + range.SetValue2(COleVariant(txt)); //range.SetValue()Ϊrange.SetValue2() + + //ʽô + if(bBold) + { + font=range.GetFont(); + font.SetBold(COleVariant((short)TRUE)); + } + //ѡAAУÿΪԶӦ + cols=range.GetEntireColumn(); + cols.AutoFit(); +} +//һͼƬ(Row1,Col1,Row2,Col2 ָͼƬʾΧ)FilePath ͼƬļ· +void CExcelMgr::InsertPicture(int Row1,int Col1,int Row2,int Col2,CString FilePath) +{ + //SheetϻһShapes + Range range; //Ԫ + Shapes shapes=m_sheet.GetShapes(); + //RangeͼƬ + range=m_sheet.GetRange(COleVariant(GetCellIdxStr(Row1,Col1)),COleVariant(GetCellIdxStr(Row2,Col2)));//ͼƬijߴ + //ӱһͼƬ + shapes.AddPicture(FilePath,false,true,(float)range.GetLeft().dblVal,(float)range.GetTop().dblVal,(float)range.GetWidth().dblVal,(float)range.GetHeight().dblVal); + //ÿ + ShapeRange sRange=shapes.GetRange(_variant_t(long(1))); + sRange.SetHeight(float(400)); + sRange.SetWidth(float(550)); +} \ No newline at end of file diff --git a/LaipuDrawing/ExcelMgr.h b/LaipuDrawing/ExcelMgr.h new file mode 100644 index 0000000..355851e --- /dev/null +++ b/LaipuDrawing/ExcelMgr.h @@ -0,0 +1,27 @@ +#pragma once +#include "GlobalDefine.h" +#include "excel.h" + + +class CExcelMgr +{ +public: + CExcelMgr(void); + ~CExcelMgr(void); + bool CreatExcelFile(); + void ShowExcelFile(); + void SetCellTxt(int Row,int Col,CString txt,bool bBold = false); + void InsertPicture(int Row1,int Col1,int Row2,int Col2,CString FilePath); + + CString GetCellIdxStr(int Row,int Col); +private: + +private: + bool m_bCreateOk;//ǷɹExcel ļ + _Application m_app; //ȴһ_Application࣬_ApplicationһExcelӦóӿ + Workbooks m_books; // + _Workbook m_book; //ǰĹ + Worksheets m_sheets; // + _Worksheet m_sheet; //ǰĹ +}; + diff --git a/LaipuDrawing/ExceptionMsg.cpp b/LaipuDrawing/ExceptionMsg.cpp new file mode 100644 index 0000000..515daee --- /dev/null +++ b/LaipuDrawing/ExceptionMsg.cpp @@ -0,0 +1,10 @@ +#include "StdAfx.h" +#include "ExceptionMsg.h" + + +CExceptionMsg::CExceptionMsg(void) +{ +} +CExceptionMsg::~CExceptionMsg(void) +{ +} diff --git a/LaipuDrawing/ExceptionMsg.h b/LaipuDrawing/ExceptionMsg.h new file mode 100644 index 0000000..c826a61 --- /dev/null +++ b/LaipuDrawing/ExceptionMsg.h @@ -0,0 +1,14 @@ +#pragma once + +//Զ쳣 +class CExceptionMsg +{ +public: + CExceptionMsg(void); + ~CExceptionMsg(void); + void SetMsg(CString &str){m_MsgStr = str;}; + CString GetMsgStr(){return m_MsgStr;}; +private: + CString m_MsgStr;//쳣Ϣ +}; + diff --git a/LaipuDrawing/FileMgr.cpp b/LaipuDrawing/FileMgr.cpp new file mode 100644 index 0000000..1ba7e6c --- /dev/null +++ b/LaipuDrawing/FileMgr.cpp @@ -0,0 +1,531 @@ +#include "StdAfx.h" +#include "FileMgr.h" +#include "LogMgr.h" +#include "GlobalDefine.h" +#include "GlobalFunction.h" + + + +#if 1 +void CCsvData::AddData(CString Str,bool bLineEnd) +{ + m_StrVecTemp.push_back(Str); + if(bLineEnd) + { + m_DataVec.push_back(m_StrVecTemp); + m_StrVecTemp.clear(); + } +} +#endif + + +CFileMgr::CFileMgr(void) +{ +} +CFileMgr::~CFileMgr(void) +{ +} +//ԵǰĿ¼Ϊȡļ·(FilePath ) +void CFileMgr::GetFullFilePath(char *FilePath,CString FileName) +{ + CString str; + GetFullFilePath(str,FileName); + strcpy(FilePath,(LPSTR)(LPCTSTR)str); +} +//ԵǰĿ¼Ϊȡļ·(FileName ʽ\\Debug.txt) +void CFileMgr::GetFullFilePath(CString &FilePath,CString FileName) +{ + CString sPath; + GetModuleFileName(NULL,sPath.GetBufferSetLength(1023),1024); + sPath.ReleaseBuffer(); + int nPos; + nPos = sPath.ReverseFind('\\'); + sPath = sPath.Left(nPos); + FilePath = sPath + FileName; +} +//ȡǰĿ¼ +CString CFileMgr::GetWorkPath() +{ + CString sPath; + GetModuleFileName(NULL,sPath.GetBufferSetLength(1023),1024); + sPath.ReleaseBuffer(); + int nPos; + nPos = sPath.ReverseFind('\\'); + sPath = sPath.Left(nPos); + return sPath; +} +#if 1 +#define Max_ReadFile_Times 5 //ԶȡļĴʱļ +//жȡFilePath ָļ浽vec (FilePath dzĿ¼µļ·) +void CFileMgr::ReadFileToStringVec(const CString &FilePath,vector &vec) +{ + for(int k=0;kWriteDebugLog(Log); + Sleep(1000); + } + } +} + +//ȡļÿһ,Զŷֵ +void CFileMgr::ReadFileToDoubleVec(const CString &FilePath,vector> &Vec) +{ + //ȡÿһַ + vector StrVec; + ReadFileToStringVec(FilePath,StrVec); + vector::iterator iter = StrVec.begin(); + vector::iterator iter_end = StrVec.end(); + for(;iter!=iter_end;iter++) + { + vector VecTmp; + //str ȡdouble ֵ,ԶΪָ + GetDoubleVal((*iter),VecTmp); + if(VecTmp.empty()==false) + Vec.push_back(VecTmp); + } +} +//str ȡdouble ֵ,ԶΪָ +void CFileMgr::GetDoubleVal(CString Str,vector &Vec) +{ + int CommaPosPer;//һŵλ + CommaPosPer = Str.Find(",",0); + if(CommaPosPer == -1)//ûҵֱӷ + { + return; + } + char *recvBuf = CStringToLPCSTR(Str); + //һֵ + double val = 0; + CString Str1(recvBuf,CommaPosPer); + val= atof(Str1); + Vec.push_back(val); + + int idx = 0; + int CommaPosNext = CommaPosPer; + do + { + CommaPosNext = Str.Find(",",CommaPosPer+1);//һŵλ + if(CommaPosNext==-1)//һ + { + CString Str1(recvBuf+CommaPosPer+1); + val= atof(Str1); + } + else + { + CString Str1(recvBuf+CommaPosPer+1,CommaPosNext-CommaPosPer); + val= atof(Str1); + } + + Vec.push_back(val); + + CommaPosPer = CommaPosNext; + idx++; + }while(CommaPosNext!=-1); +} +//һд뵽ıļ +void CFileMgr::WriteDbxyVecToFile(vector &vec,CString Path) +{ + ofstream file; + file.open(Path); + vector::iterator iter = vec.begin(); + vector::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + file<<(*iter).x<<","<<(*iter).y<> &Vec,bool bGapTab) +{ + int EmptyLine = -1; + //ȡÿһַ + vector StrVec; + ReadFileToStringVec(FilePath,StrVec); + vector::iterator iter = StrVec.begin(); + vector::iterator iter_end = StrVec.end(); + for(int k=1;iter!=iter_end;iter++,k++) + { + vector VecTmp; + //str ȡdouble ֵ,ԶΪָ + GetStringVal((*iter),VecTmp,bGapTab); + if(VecTmp.empty()==false) + { + Vec.push_back(VecTmp); + } + else + { + EmptyLine = k; + } + } + return EmptyLine; +} +//str ȡval ֵ,ԶΪָ +void CFileMgr::GetStringVal(CString Str,vector &Vec,bool bGapTab) +{ + int CommaPosPer;//һŵλ + if(bGapTab) + CommaPosPer = Str.Find(" ",0); + else + CommaPosPer = Str.Find(",",0); + + + if(CommaPosPer == -1)//ûҵֱӷ + { + return; + } + char *recvBuf = CStringToLPCSTR(Str); + //һֵ + char gap = ','; + if(bGapTab) + gap = '\t'; + CString Str1(recvBuf,CommaPosPer); + Str1.Remove(gap);//ɾ + Vec.push_back(Str1); + + int idx = 0; + int CommaPosNext = CommaPosPer; + do + { + CString val; + CommaPosNext = Str.Find(gap,CommaPosPer+1);//һŵλ + if(CommaPosNext==-1)//һ + { + CString Str1(recvBuf+CommaPosPer+1); + val = (Str1); + } + else + { + CString Str1(recvBuf+CommaPosPer+1,CommaPosNext-CommaPosPer); + val = (Str1); + } + val.Remove(gap);//ɾ + Vec.push_back(val); + + CommaPosPer = CommaPosNext; + idx++; + }while(CommaPosNext!=-1); +} +#endif +//ļǷ(·) +bool CFileMgr::IsFileExist(CString FilePath) +{ + CFileFind finder; + bool bResult = finder.FindFile(FilePath); + finder.Close(); + return bResult; +} +//Ŀ¼Ƿ +bool CFileMgr::IsDirectoryExists(CString const& path) +{ + //жǷ + if(!PathFileExists(path)) + return false; + + //жǷΪĿ¼ + DWORD attributes = ::GetFileAttributes(path); + attributes &= FILE_ATTRIBUTE_DIRECTORY; + return attributes == FILE_ATTRIBUTE_DIRECTORY; +} +//ȡļļ/ļ·(Suffix Ϊָĺ׺) +void CFileMgr::GetChildFileOrDirName(bool bDir,CString strPath,vector & Vec,CString Suffix) +{ + CString strFilePath; + int dwDirSize = 0; + strFilePath += strPath; + strFilePath += "//*.*"; + CFileFind finder; + BOOL bFind = finder.FindFile(strFilePath); + while (bFind) + { + bFind = finder.FindNextFile(); + if (!finder.IsDots()) + { + CString strTempPath = finder.GetFilePath(); + if(bDir && finder.IsDirectory()) + { + Vec.push_back(strTempPath); + } + else if(!bDir) + { + if(Suffix != "")//ָ˺׺ + { + if(strTempPath.Find(Suffix)!=-1) + Vec.push_back(strTempPath); + } + else + { + Vec.push_back(strTempPath); + } + } + } + } + finder.Close(); +} +//ɾָĿ¼µļ +void CFileMgr::DeleteDirFile(CString FilePath) +{ + CString DelStr("del /s/q "); + DelStr += FilePath; + system(DelStr); +} +//ɾĿ¼ +void CFileMgr::DeleteDir(CString DirPath) +{ + CString DelStr("rmdir "); + DelStr += DirPath; + system(DelStr); +} +//Ŀ¼(ֻøһĿ¼һϵĿ¼) +void CFileMgr::CreatDir(CString DirPath) +{ + if(!IsDirectoryExists(DirPath)) + { + //CString MkdirCmd("mkdir "); + //MkdirCmd += DirPath; + //system(MkdirCmd); + + CreateMultipleDirectory(DirPath); + } +} +//༶Ŀ¼ +bool CFileMgr::CreateMultipleDirectory(const CString& szPath) +{ + CString log="CreateMultipleDirectory->"; + log += szPath; + gLogMgr->WriteDebugLog(log); + + CString strDir(szPath);//ҪĿ¼ַ + //ȷ'\'βԴһĿ¼ + if (strDir.GetAt(strDir.GetLength()-1)!=_T('\\')) + { + strDir.AppendChar(_T('\\')); + } + std::vector vPath;//ÿһĿ¼ַ + CString strTemp;//һʱ,Ŀ¼ַ + bool bSuccess = false;//ɹ־ + //Ҫַ + for (int i=0;i::const_iterator vIter; + for (vIter = vPath.begin(); vIter != vPath.end(); vIter++) + { + //CreateDirectoryִгɹ,true,򷵻false + bSuccess = CreateDirectory(*vIter, NULL) ? true : false; + } + + log = (bSuccess)?("Success"):("Error"); + gLogMgr->WriteDebugLog(log); + return bSuccess; +} +//Path1 ļcopy Path2 (Ҳǵļ) +void CFileMgr::CopyFile(CString Path1,CString Path2) +{ + CString MoveFileCmd("copy "); + MoveFileCmd += Path1+" "+Path2; + //system(MoveFileCmd); + + CopyFolder(Path1,Path2); +} +//ļ(޸ĺļ·) +//FilePathļ·,NewName,׺ +CString CFileMgr::FileReName(CString FilePath,CString NewName) +{ + CString OldFilePath = FilePath; + + CString Suffix = GetFileNameFromPath(FilePath,false);//к׺ + CString FileName = GetFileNameFromPath(FilePath,true);//޺׺ + + FilePath.Replace(Suffix,"");//õ· + Suffix.Replace(FileName,"");//õ׺ + CString NewFilePath = FilePath + NewName + Suffix; + //CFile::Rename(OldFilePath, NewFilePath); + + ReNameFolder(OldFilePath,NewFilePath); + + return NewFilePath; +} +//Ŀ¼ +void CFileMgr::OpenDir(CString DirPath) +{ + if(IsDirectoryExists(DirPath)) + { + ShellExecute(0,"open",DirPath,"","",SW_SHOWNORMAL); + } +} +//·ȡļ(bDelSuffix ȥ׺) +CString CFileMgr::GetFileNameFromPath(CString Path,bool bDelSuffix) +{ + CString name = Path; + int idx = name.ReverseFind('\\'); + if(idx != -1) + { + int len = name.GetLength(); + name = name.Right(len - idx -1); + } + if(bDelSuffix) + { + idx = name.ReverseFind('.'); + if(idx != -1) + { + int len = name.GetLength(); + name = name.Left(len - (len-idx)); + } + } + return name; +} +//޸ļ/ ļ +BOOL CFileMgr::ReNameFolder(LPCTSTR lpszFromPath,LPCTSTR lpszToPath) +{ + int nLengthFrm = strlen(lpszFromPath); + char *NewPathFrm = new char[nLengthFrm+2]; + strcpy(NewPathFrm,lpszFromPath); + NewPathFrm[nLengthFrm] = '\0'; + NewPathFrm[nLengthFrm+1] = '\0'; + SHFILEOPSTRUCT FileOp; + ZeroMemory((void*)&FileOp,sizeof(SHFILEOPSTRUCT)); + FileOp.fFlags = FOF_NOCONFIRMATION ; + FileOp.hNameMappings = NULL; + FileOp.hwnd = NULL; + FileOp.lpszProgressTitle = NULL; + FileOp.pFrom = NewPathFrm; + FileOp.pTo = lpszToPath; + FileOp.wFunc = FO_RENAME; + return SHFileOperation(&FileOp) == 0; +} +//ƶļ/Ŀ¼ +BOOL CFileMgr::MoveFolder(LPCTSTR lpszFromPath,LPCTSTR lpszToPath) +{ + int nLengthFrm = strlen(lpszFromPath); + char *NewPathFrm = new char[nLengthFrm+2]; + strcpy(NewPathFrm,lpszFromPath); + NewPathFrm[nLengthFrm] = '\0'; + NewPathFrm[nLengthFrm+1] = '\0'; + SHFILEOPSTRUCT FileOp; + ZeroMemory((void*)&FileOp,sizeof(SHFILEOPSTRUCT)); + FileOp.fFlags = FOF_NOCONFIRMATION ; + FileOp.hNameMappings = NULL; + FileOp.hwnd = NULL; + FileOp.lpszProgressTitle = NULL; + FileOp.pFrom = NewPathFrm; + FileOp.pTo = lpszToPath; + FileOp.wFunc = FO_MOVE; + return SHFileOperation(&FileOp) == 0; +} +//ļ/Ŀ¼ +BOOL CFileMgr::CopyFolder(LPCTSTR lpszFromPath,LPCTSTR lpszToPath) +{ + int nLengthFrm = strlen(lpszFromPath); + char *NewPathFrm = new char[nLengthFrm+2]; + strcpy(NewPathFrm,lpszFromPath); + NewPathFrm[nLengthFrm] = '\0'; + NewPathFrm[nLengthFrm+1] = '\0'; + SHFILEOPSTRUCT FileOp; + ZeroMemory((void*)&FileOp,sizeof(SHFILEOPSTRUCT)); + FileOp.fFlags = FOF_NOCONFIRMATION ; + FileOp.hNameMappings = NULL; + FileOp.hwnd = NULL; + FileOp.lpszProgressTitle = NULL; + FileOp.pFrom = NewPathFrm; + FileOp.pTo = lpszToPath; + FileOp.wFunc = FO_COPY; + return SHFileOperation(&FileOp) == 0; +} +//ɾļ/Ŀ¼ +BOOL CFileMgr::DeleteFolder(LPCTSTR lpszPath) +{ + int nLength = strlen(lpszPath); + char *NewPath = new char[nLength+2]; + strcpy(NewPath,lpszPath); + NewPath[nLength] = '\0'; + NewPath[nLength+1] = '\0'; + SHFILEOPSTRUCT FileOp; + ZeroMemory((void*)&FileOp,sizeof(SHFILEOPSTRUCT)); + FileOp.fFlags = FOF_NOCONFIRMATION; + FileOp.hNameMappings = NULL; + FileOp.hwnd = NULL; + FileOp.lpszProgressTitle = NULL; + FileOp.pFrom = NewPath; + FileOp.pTo = NULL; + FileOp.wFunc = FO_DELETE; + return SHFileOperation(&FileOp) == 0; +} + +BOOL CFileMgr::CopyDirOrFile(CString src,CString dest) //ļļ +{ + char pFrom[256]{}; + char pTo[256]{}; + strcpy(pFrom, src); // һļ + strcpy(pTo, dest); // һļ + + SHFILEOPSTRUCT sfo; + sfo.hwnd = NULL; + sfo.wFunc = FO_COPY; + sfo.pFrom = src; + sfo.pTo = dest; + sfo.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOCONFIRMMKDIR; + + return (SHFileOperation(&sfo)==0);//ִгɹ0 +} +#if 1 +//ݵCSVļ +//DirPath "E:\LaipuLaserData\MonitoringData\WaferProcessData\2021\05\174357_FP03563_Port1_Slot3\" +//FileNameûк׺,bAppend ׷ӷʽд +void CFileMgr::WriteDataToExcel(CString DirPath,CString FileName,CCsvData &CsvData,bool bAppend) +{ + CString FilePath = DirPath; + FilePath += FileName; + FilePath += ".xlsx"; + + ofstream fstream; + if(bAppend)//׷д + fstream.open(FilePath, ios::app); + else + fstream.open(FilePath); + + vector> &DataVec = CsvData.m_DataVec; + int size = DataVec.size(); + for(int k=0;k&StrVec = DataVec[k]; + int size1 = StrVec.size(); + for(int i=0;i m_StrVecTemp; + vector> m_DataVec; +}; + + +class CPropertie; +//ļĹ +class CFileMgr +{ +public: + CFileMgr(void); + ~CFileMgr(void); + void GetFullFilePath(char *FilePath,CString FileName); + void GetFullFilePath(CString &FilePath,CString FileName); + void ReadFileToStringVec(const CString &FileName,vector &vec); + void ReadFileToDoubleVec(const CString &FilePath,vector> &Vec); + bool IsFileExist(CString FilePath); + void GetChildFileOrDirName(bool bDir,CString strPath,vector & Vec,CString Suffix); + void DeleteDirFile(CString FilePath); + void DeleteDir(CString DirPath); + void CreatDir(CString DirPath); + bool CreateMultipleDirectory(const CString& szPath); + void OpenDir(CString DirPath); + void CopyFile(CString Path1,CString Path2); + CString FileReName(CString FilePath,CString NewName); + CString GetFileNameFromPath(CString Path,bool bDelSuffix); + void WriteDbxyVecToFile(vector &vec,CString Path); + CString GetWorkPath(); + bool IsDirectoryExists(CString const& path); + int ReadFileToStrVec(const CString &FilePath,vector> &Vec,bool bGapTab = false); + void GetStringVal(CString Str,vector &Vec,bool bGapTab); + void GetDoubleVal(CString Str,vector &Vec); + BOOL ReNameFolder(LPCTSTR lpszFromPath,LPCTSTR lpszToPath); + BOOL MoveFolder(LPCTSTR lpszFromPath,LPCTSTR lpszToPath); + BOOL CopyFolder(LPCTSTR lpszFromPath,LPCTSTR lpszToPath); + BOOL DeleteFolder(LPCTSTR lpszPath); + BOOL CopyDirOrFile(CString src,CString dest); + void WriteDataToExcel(CString DirPath,CString FileName,CCsvData &CsvData,bool bAppend); +private: + +}; + diff --git a/LaipuDrawing/FontBarcode.cpp b/LaipuDrawing/FontBarcode.cpp new file mode 100644 index 0000000..7427d5b --- /dev/null +++ b/LaipuDrawing/FontBarcode.cpp @@ -0,0 +1,38 @@ +#include "StdAfx.h" +#include "FontBarcode.h" + + +CFontBarcode::CFontBarcode(void) +{ +} +CFontBarcode::~CFontBarcode(void) +{ +} +//ʼҪͣm_BarcodeTypeVec ֺCTbarcode51 ؼӦöٵӳ +void CFontBarcode::IniBarcodeTypeVec() +{ + m_BarcodeTypeVec.push_back(make_pair("DataMatrix",71)); + m_BarcodeTypeVec.push_back(make_pair("QRCode",58)); + m_BarcodeTypeVec.push_back(make_pair("MAXICODE",57)); +} +void CFontBarcode::Initialize() +{ + IniBarcodeTypeVec(); + + vector::iterator iter = m_BarcodeTypeVec.begin(); + vector::iterator iter_end = m_BarcodeTypeVec.end(); + for(;iter!=iter_end;iter++) + { + AddTypeName((*iter).first); + } +} +//תΪCTbarcode51 Ӧֵ +int CFontBarcode::GetCurFontNameIdx() +{ + int size = m_BarcodeTypeVec.size(); + if(m_CurFontNameIdx>=0 && m_CurFontNameIdx BarcodeType; +class CFontBarcode :public CFontType +{ +public: + CFontBarcode(void); + ~CFontBarcode(void); + virtual CString GetFontType(){return "FontBarcode";}; + virtual void Initialize(); + virtual int GetCurFontNameIdx(); +private: + void IniBarcodeTypeVec(); +private: + vector m_BarcodeTypeVec;//ʹõ,ֵtag_BarCType жӦ +}; + diff --git a/LaipuDrawing/FontLaipu.cpp b/LaipuDrawing/FontLaipu.cpp new file mode 100644 index 0000000..948e295 --- /dev/null +++ b/LaipuDrawing/FontLaipu.cpp @@ -0,0 +1,153 @@ +#include "StdAfx.h" +#include "FontLaipu.h" +#include "FontTypeMgr.h" + + +CFontLaipu::CFontLaipu(void) +{ +} +CFontLaipu::~CFontLaipu(void) +{ +} +void CFontLaipu::Initialize() +{ + //ȻFONT ļеĿ¼-------------------------------------------------------- + CString sPath; + GetModuleFileName(NULL,sPath.GetBufferSetLength(1023),1024); //ȡǰĿ¼ + sPath.ReleaseBuffer(); + int nPos; + nPos = sPath.ReverseFind('\\'); + sPath = sPath.Left(nPos); + CString str = sPath + "\\font"; + //font ļвsl ׺ļ------------------------------------------------- + int idx = 0; + CFileFind finder; + BOOL bWorking = finder.FindFile(str + "/*.*");//m_pathΪָļ + while (bWorking)//ļ + { + bWorking = finder.FindNextFile(); + CString name = finder.GetFileName(); + CString extend = name.Right(name.GetLength() - name.ReverseFind('.') - 1);//ȡչ + if(!finder.IsDots()) + { + if(extend == "SL" || extend == "sl") + { + AddTypeName(name); + } + } + } +} +void CFontLaipu::CreatCharVec(char *pChar,vector &PonitVec) +{ + CreatCharVecExt(*pChar,PonitVec); +} +//յֿȡAsciiCode Ӧ(Offsetַ֮ļ) +void CFontLaipu::CreatCharVecExt(unsigned char AsciiCode,vector &PonitVec) +{ + CFontTypeMgr &pFontTypeMgr = CFontTypeMgr::Instance(); + //ȡǰļ· + CString str = pFontTypeMgr.GetFontPath(GetCurFontName()); + char filepath[1024]; + strcpy(filepath,(LPSTR)(LPCTSTR)str); + //ֿļ + CFile file; + if(file.Open(filepath,CFile::modeRead|CFile::typeBinary)) + { + int FileLen = file.GetLength()+1; + char *pBuf=new char[FileLen]; + memset(pBuf,0,FileLen*sizeof(char)); + file.SeekToBegin();//ָƵļͷ + file.Read(pBuf, FileLen*sizeof(char));//ȡڴ + + //ҵ洢ַĿʼλ + unsigned long AddrOffset = AsciiCode*3; + unsigned long AddrStart = 0;//ݵʼλ + unsigned char ch; + ch = pBuf[AddrOffset]; + AddrStart = ch; + ch = pBuf[AddrOffset+1]; + AddrStart += ch*256; + ch = pBuf[AddrOffset+2]; + AddrStart += ((long)ch*256*256); + //±0 ʼ + AddrStart --; + BOOL flg = TRUE; + BOOL bUpOrDown = FALSE;//̧ʻ + //ϵ + double DirStepX[16] = {1, 1, 1, 0.5, 0, -0.5, -1, -1, -1, -1, -1, -0.5, 0, 0.5, 1, 1}; + double DirStepY[16] = {0, 0.5, 1, 1, 1, 1, 1, 0.5, 0, -0.5, -1, -1, -1, -1, -1, -0.5}; + + int idx = 0; + PointType PointData; + // + PointData.first.x = 0; + PointData.first.y = 0; + + while(flg) + { + ch = pBuf[AddrStart+idx]; + switch(ch) + { + case 0: + flg = FALSE; + break; + case 1://pen down + bUpOrDown = FALSE; + break; + case 2://pen up + bUpOrDown = TRUE; + break; + case 8://ƫ + { + idx++; + int XOffset = pBuf[AddrStart+idx]; + idx++; + int YOffset = pBuf[AddrStart+idx]; + PointData.first.x += XOffset; + PointData.first.y += YOffset; + PointData.second = bUpOrDown; + PonitVec.push_back(PointData); + } + break; + case 9://ƫ + { + idx++; + int XOffset = pBuf[AddrStart+idx]; + idx++; + int YOffset = pBuf[AddrStart+idx]; + while(XOffset != 0 || YOffset != 0) + { + PointData.first.x += XOffset; + PointData.first.y += YOffset; + PointData.second = bUpOrDown; + PonitVec.push_back(PointData); + + idx++; + XOffset = pBuf[AddrStart+idx]; + idx++; + YOffset = pBuf[AddrStart+idx]; + } + } + break; + default://СΧƫ + { + int Low4Bit,High4Bit; + High4Bit = (unsigned char)ch/16;// + Low4Bit = (unsigned char)ch - High4Bit*16;// + + int XOffset = DirStepX[Low4Bit]*High4Bit; + int YOffset = DirStepY[Low4Bit]*High4Bit; + PointData.first.x += XOffset; + PointData.first.y += YOffset; + PointData.second = bUpOrDown; + PonitVec.push_back(PointData); + } + break; + } + idx++; + } + //ͷļ + delete []pBuf; + file.Close(); + } +} \ No newline at end of file diff --git a/LaipuDrawing/FontLaipu.h b/LaipuDrawing/FontLaipu.h new file mode 100644 index 0000000..a5e7bc3 --- /dev/null +++ b/LaipuDrawing/FontLaipu.h @@ -0,0 +1,14 @@ +#pragma once +#include "fonttype.h" +class CFontLaipu :public CFontType +{ +public: + CFontLaipu(void); + ~CFontLaipu(void); + virtual CString GetFontType(){return "FontLaipu";}; + virtual void Initialize(); + virtual void CreatCharVec(char *pChar,vector &PonitVec); +private: + void CreatCharVecExt(unsigned char AsciiCode,vector &PonitVec); +}; + diff --git a/LaipuDrawing/FontTrueType.cpp b/LaipuDrawing/FontTrueType.cpp new file mode 100644 index 0000000..46c0f5a --- /dev/null +++ b/LaipuDrawing/FontTrueType.cpp @@ -0,0 +1,126 @@ +#include "StdAfx.h" +#include "FontTrueType.h" +#include "LogMgr.h" + +vector TrueTypeVec;//ȡ +/*صöϵͳѾװ*/ +BOOL CALLBACK EnumWinFontCallBackEx(ENUMLOGFONTEX* pelf, NEWTEXTMETRICEX* lpntm, int FontType, LPVOID pThis) +{ + if(FontType&RASTER_FONTTYPE) + { + return TRUE; + } + CString str; + if (FontType&TRUETYPE_FONTTYPE) + { + str=((pelf)->elfLogFont.lfFaceName); + } + TrueTypeVec.push_back(str); + return TRUE; +} + +CFontTrueType::CFontTrueType(void) +{ +} +CFontTrueType::~CFontTrueType(void) +{ +} +void CFontTrueType::Initialize() +{ + HDC hDC; + hDC=::GetWindowDC(NULL); + LOGFONT lf; + + memset(&lf,0,sizeof(LOGFONT)); + lf.lfCharSet=GB2312_CHARSET; + ::EnumFontFamiliesEx(hDC, &lf,(FONTENUMPROC)EnumWinFontCallBackEx,(LPARAM)this,(DWORD) 0); + ::ReleaseDC(NULL,hDC); + //ʱ + int size = TrueTypeVec.size(); + for(int i=0;i &PonitVec) +{ + CClientDC dc(NULL); + CDC *pDC = &dc; + + LOGFONT lf; + memset(&lf, 0, sizeof(lf)); + lf.lfHeight = 1000;//ߴԽƽԽ + lf.lfWeight = FW_NORMAL; + lf.lfOutPrecision = OUT_TT_ONLY_PRECIS; + lf.lfCharSet = GB2312_CHARSET; + // + _tcscpy(lf.lfFaceName, _T(GetCurFontName())); + + // create and select it + CFont newFont; + if (!newFont.CreateFontIndirect(&lf)) + return; + CFont* pOldFont = pDC->SelectObject(&newFont); + + pDC->SetBkMode(TRANSPARENT);//͸ + //ʼһ· + pDC->BeginPath(); + pDC->TextOut(0, 0, pChar); + pDC->EndPath();//· + + //תΪ߶ + pDC->FlattenPath();//һ·е߶ת߶ + int Count=pDC->GetPath(NULL,NULL,0);//ȡ· + CPoint* pPoin=new CPoint[Count]; + BYTE* pByte=new BYTE[Count]; + CPoint endpoint; + pDC->GetPath(pPoin,pByte,Count); + + PointType PointData; + for(int i=0;iSelectObject(pOldFont); + //ֱ + Mirror(PonitVec); +} +//ֱ +void CFontTrueType::Mirror(vector &PonitVec) +{ + int size = PonitVec.size(); + for(int i=0;i &PonitVec); +private: + void Mirror(vector &PonitVec); +}; + diff --git a/LaipuDrawing/FontType.cpp b/LaipuDrawing/FontType.cpp new file mode 100644 index 0000000..5a9d49c --- /dev/null +++ b/LaipuDrawing/FontType.cpp @@ -0,0 +1,47 @@ +#include "StdAfx.h" +#include "FontType.h" + + +CFontType::CFontType(void) +{ + m_CurFontNameIdx = 0;//ǰѡֵ +} +CFontType::~CFontType(void) +{ +} + +void CFontType::UpdateFontNameComb(CComboBox &Comb) +{ + vector::iterator iter = m_FontNameVec.begin(); + vector::iterator iter_end = m_FontNameVec.end(); + for(int i=0;iter!=iter_end;iter++,i++) + { + Comb.InsertString(i,m_FontNameVec[i]); + } + Comb.SetCurSel(m_CurFontNameIdx); +} +CString CFontType::GetCurFontName() +{ + CString name; + int size = m_FontNameVec.size(); + if(m_CurFontNameIdx>=0 && m_CurFontNameIdx::iterator iter = m_FontNameVec.begin(); + vector::iterator iter_end = m_FontNameVec.end(); + for(int i=0;iter!=iter_end;iter++,i++) + { + if((*iter) == FontName)//ҵƥ + { + m_CurFontNameIdx = i;//Ϊǰѡ + return true; + } + } + return false; +} \ No newline at end of file diff --git a/LaipuDrawing/FontType.h b/LaipuDrawing/FontType.h new file mode 100644 index 0000000..3f68acb --- /dev/null +++ b/LaipuDrawing/FontType.h @@ -0,0 +1,24 @@ +#pragma once +#include "GlobalDefine.h" + +class CFontType +{ +public: + CFontType(void); + virtual ~CFontType(void); + virtual void Initialize(){}; + virtual void CreatCharVec(char *pChar,vector &m_PonitVec){}; + virtual int GetCurFontNameIdx(){return m_CurFontNameIdx;}; +public: + virtual CString GetFontType(){return "";}; + void UpdateFontNameComb(CComboBox &Comb); + void SetCurFontNameIdx(int idx){m_CurFontNameIdx = idx;}; + CString GetCurFontName(); + bool SetCurFontByName(CString FontName); +protected: + void AddTypeName(CString s){m_FontNameVec.push_back(s);}; +protected: + int m_CurFontNameIdx;//ǰѡֵ + vector m_FontNameVec;//ֵ +}; + diff --git a/LaipuDrawing/FontTypeMgr.cpp b/LaipuDrawing/FontTypeMgr.cpp new file mode 100644 index 0000000..3da065b --- /dev/null +++ b/LaipuDrawing/FontTypeMgr.cpp @@ -0,0 +1,154 @@ +#include "StdAfx.h" +#include "FontTypeMgr.h" +#include "LogMgr.h" +#include "FontLaipu.h" +#include "FontTrueType.h" +#include "FontBarcode.h" + + +CFontTypeMgr CFontTypeMgr::m_Instance; + +CFontTypeMgr::CFontTypeMgr(void) +{ +} +CFontTypeMgr::~CFontTypeMgr(void) +{ +} +CFontTypeMgr &CFontTypeMgr::Instance() +{ + return m_Instance; +} + +//ʼ +void CFontTypeMgr::Initialize() +{ + + //windows TrueType ֿ + CFontType *p1 = new CFontTrueType; + p1->Initialize(); + AddFontType(p1); + //յֿ + CFontType *p2 = new CFontLaipu; + p2->Initialize(); + AddFontType(p2); + //ֿ + CFontType *p3 = new CFontBarcode; + p3->Initialize(); + AddFontType(p3); + + m_CurFontTypeIdx = 0;//ǰѡֿ +} +bool CFontTypeMgr::CheckIdx(int idx) +{ + int size = m_FontTypeVec.size(); + if(idx>=0 && idx sPtr(p); + m_FontTypeVec.push_back(sPtr); +} +//ֲֿ뵽comb +void CFontTypeMgr::FontTypeNameInsertToComb(CComboBox &Comb) +{ + // + Comb.ResetContent(); + + vector>::iterator iter = m_FontTypeVec.begin(); + vector>::iterator iter_end = m_FontTypeVec.end(); + for(int i=0;iter!=iter_end;iter++,i++) + { + Comb.InsertString(i,(*iter)->GetFontType()); + } + Comb.SetCurSel(m_CurFontTypeIdx); +} +//ˢбCComboBox +void CFontTypeMgr::UpdateFontNameComb(CComboBox &Comb) +{ + // + Comb.ResetContent(); + if(CheckIdx(m_CurFontTypeIdx)) + { + m_FontTypeVec[m_CurFontTypeIdx]->UpdateFontNameComb(Comb); + } +} +//ȡǰѡ· +CString CFontTypeMgr::GetFontPath(CString FontName) +{ + //ȻFONT ļеĿ¼-------------------------------------------------------- + CString sPath; + GetModuleFileName(NULL,sPath.GetBufferSetLength(1023),1024); //ȡǰĿ¼ + sPath.ReleaseBuffer(); + int nPos; + nPos = sPath.ReverseFind('\\'); + sPath = sPath.Left(nPos); + sPath = sPath + "\\font\\"; + return sPath+FontName; +} +//õǰѡ +void CFontTypeMgr::SetCurFontType(int idx) +{ + m_CurFontTypeIdx = idx; +} +void CFontTypeMgr::GetCurFontName(int idx) +{ + if(CheckIdx(m_CurFontTypeIdx)) + { + m_FontTypeVec[m_CurFontTypeIdx]->SetCurFontNameIdx(idx); + } +} +//ȡǰѡֵ +int CFontTypeMgr::GetCurFontTypeIdx() +{ + if(CheckIdx(m_CurFontTypeIdx)) + return m_FontTypeVec[m_CurFontTypeIdx]->GetCurFontNameIdx(); + else + return -1; +} +//õǰַ +void CFontTypeMgr::CreatCharVec(char *pChar,vector &m_PonitVec) +{ + if(CheckIdx(m_CurFontTypeIdx)) + { + m_FontTypeVec[m_CurFontTypeIdx]->CreatCharVec(pChar,m_PonitVec); + } +} +CString CFontTypeMgr::GetCurFontTypeName() +{ + CString str; + if(CheckIdx(m_CurFontTypeIdx)) + { + str = m_FontTypeVec[m_CurFontTypeIdx]->GetFontType(); + } + return str; +} +CString CFontTypeMgr::GetCurFontName() +{ + CString str; + if(CheckIdx(m_CurFontTypeIdx)) + { + str = m_FontTypeVec[m_CurFontTypeIdx]->GetCurFontName(); + } + return str; +} +//ͨı䵱ǰѡ +void CFontTypeMgr::SetCurFontByName(CString FontTypeName,CString FontName) +{ + vector>::iterator iter = m_FontTypeVec.begin(); + vector>::iterator iter_end = m_FontTypeVec.end(); + for(int i=0;iter!=iter_end;iter++,i++) + { + if((*iter)->GetFontType() == FontTypeName)//ƥ + { + if((*iter)->SetCurFontByName(FontName))//ͬʱҪƥɹ + { + m_CurFontTypeIdx = i; + break; + } + } + } +} \ No newline at end of file diff --git a/LaipuDrawing/FontTypeMgr.h b/LaipuDrawing/FontTypeMgr.h new file mode 100644 index 0000000..13cb4ed --- /dev/null +++ b/LaipuDrawing/FontTypeMgr.h @@ -0,0 +1,35 @@ +#pragma once +#include "GlobalDefine.h" +#include "FontType.h" +#include "SmartPtr.h" + +typedef pair NamePath;//ļ· + +class CFontTypeMgr +{ +public: + ~CFontTypeMgr(void); + static CFontTypeMgr &Instance();//ģʽ + + void Initialize(); + void UpdateFontNameComb(CComboBox &Comb); + void FontTypeNameInsertToComb(CComboBox &Comb); + CString GetFontPath(CString FontName); + void SetCurFontType(int idx); + void GetCurFontName(int idx); + void CreatCharVec(char *pChar,vector &m_PonitVec); + CString GetCurFontTypeName(); + CString GetCurFontName(); + void SetCurFontByName(CString FontTypeName,CString FontName); + int GetCurFontTypeIdx(); +private: + CFontTypeMgr(void); + + void AddFontType(CFontType *); + bool CheckIdx(int idx); +private: + static CFontTypeMgr m_Instance;//ģʽ + + int m_CurFontTypeIdx;//ǰѡֿ + vector> m_FontTypeVec;// +}; diff --git a/LaipuDrawing/GlobalDefine.h b/LaipuDrawing/GlobalDefine.h new file mode 100644 index 0000000..0bcac4a --- /dev/null +++ b/LaipuDrawing/GlobalDefine.h @@ -0,0 +1,700 @@ +#pragma once +//ȫͶ + +using namespace std;/*ʹñ׼ֿռ*/ +//STL ׼ͷļ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//α뾯 +#pragma warning(disable : 4800) +#pragma warning(disable : 4244) +#pragma warning(disable : 4996) +#pragma warning(disable : 4018) +#pragma warning(disable : 4477) +#pragma warning(disable : 4005) + + +#define PI 3.14159265358979323846 +#define EE 2.71828 + +//#define COORD_EPS 0.001 //(0.001 ʾȽ,ľС1um Ϊ) +#define COORD_EPS 0.00001 + +#define VAR_PAR_CNT 20//ɱ + +//еʱʱ +#define FIRST_OPEN_DELAY 5000 //ȴʱٿʼ״̬ +#define READ_INFO_FAST_DELAY 300 //ȡϢʱms () +#define READ_INFO_SLOW_DELAY 2000 //ȡϢʱms () +#define READ_PLC_INFO_DELAY 300 //ȡPlc Ϣʱms +#define READ_ROBOT_STATE_DELAY 3000 //ȡƬ״̬ Ϣʱms +#define READ_TEK_INFO_DELAY 500 //ȡTEK ʾϢʱms +#define READ_LASER_POWER_TIMER_DELAY 600 // ȡ⹦ʵtimer ʱ +#define READ_LASER_DIS_METER_TIMER_DELAY 800 // ȡǵtimer ʱ +#define READ_LASER_STATE_DELAY 2000 //ȡϢʱms +#define READ_SECS_VAR_DELAY 200 //secs ʱms +#define CTRL_HOST_JOB_DELAY 500 //Ʒjob ʱms +#define CTRL_CYCLIC_RUN_DELAY 3000 //Ʒjob ʱms + +#define RGB_WHITE RGB(255,255,255) //ɫ +#define RGB_BLACK RGB(0,0,0) //ɫ +#define RGB_GREEN RGB(0,255,0) //ɫ +#define RGB_GREEN1 RGB(29,241,135) //ɫ +#define RGB_GREEN2 RGB(228,249,157) //dzɫ + +#define RGB_RED RGB(255,0,0) //ɫ +#define RGB_PINK RGB(255,55,120) //ۺɫ +#define RGB_PINK1 RGB(231,61,175) //ۺɫ + +#define RGB_YELLOW RGB(255,255,0) //ɫ +#define RGB_BLUE RGB(0,0,255) //ɫ +#define RGB_BLUE1 RGB(153,217,234) //ɫ +#define RGB_BLUE2 RGB(49,240,243) //ɫ2 + + +#define RGB_NODE_BLUE RGB(0,63,255) //ڵɫ +#define RGB_PURPLE RGB(163,73,164) //ɫ +#define RGB_GRAY RGB(240,240,240) //ɫ +#define RGB_GRAY1 RGB(160,160,160) //ɫ +#define RGB_GRAY2 RGB(217,217,217) //dzɫ + +#define STR_NULL "" +#define STR_INPUT_ERROR "Чָ: " +#define STR_INPUT_SYMBOL '>' + +#define OK_STATE_STR "" +#define WARNING_STATE_STR "" + +#define WARNING_STR "" +#define STATE_STR_D "״̬D"//ҪʹõŽ״̬ +#define NO_USE_STR "ʹ" + +#define SEL_ALL_STR "ALL" + +#define COMMUNICATION_ERR "Communication Error" +#define DEVICE_NOT_CONNECT "Device Not Conect" + +#define SP_POWER_NAME "ڲ" +#define LIGHT_PATH_POWER_NAME "⹦" +#define PRODUCT_SUFACE_POWER_NAME "Ч" + + +//ڲѯͱrecipe +#define RECIPE_PAR_NAME_LASER_FRE "RECIPE_PAR_NAME_LASER_FRE" +#define RECIPE_PAR_NAME_LASER2_FRE "RECIPE_PAR_NAME_LASER2_FRE" + +#define RECIPE_PAR_NAME_LASER_CURR_1 "RECIPE_PAR_NAME_LASER_CURR_1" +#define RECIPE_PAR_NAME_LASER_CURR_2 "RECIPE_PAR_NAME_LASER_CURR_2" +#define RECIPE_PAR_NAME_LASER_EDI_1 "RECIPE_PAR_NAME_LASER_EDI_1" +#define RECIPE_PAR_NAME_LASER_EDI_2 "RECIPE_PAR_NAME_LASER_EDI_2" + +#define RECIPE_PAR_NAME_PRF2_DELAY "RECIPE_PAR_NAME_PRF2_DELAY" + +#define RECIPE_PAR_NAME_SCAN_SPEED "RECIPE_PAR_NAME_SCAN_SPEED" +#define RECIPE_PAR_NAME_OVERLAP_RATIO_X "RECIPE_PAR_NAME_OVERLAP_RATIO_X" +#define RECIPE_PAR_NAME_OVERLAP_RATIO_Y "RECIPE_PAR_NAME_OVERLAP_RATIO_Y" +#define RECIPE_PAR_NAME_FOCUS_ADJUST_VAL "RECIPE_PAR_NAME_FOCUS_ADJUST_VAL" + +#define RECIPE_PAR_NAME_SCAN_AREA "RECIPE_PAR_NAME_SCAN_AREA" +#define RECIPE_PAR_NAME_AREA_IDX "RECIPE_PAR_NAME_AREA_IDX" + +#define RECIPE_PAR_NAME_N2_STATE "RECIPE_PAR_NAME_N2_STATE" //Ƿ񿪹N2 +#define RECIPE_PAR_NAME_OFFSET_TAB "RECIPE_PAR_NAME_OFFSET_TAB" // + +#define RECIPE_PAR_NAME_N2_VAL "RECIPE_PAR_NAME_N2_VAL"//N2С +#define RECIPE_PAR_NAME_USE_CUR_N2VAL "RECIPE_PAR_NAME_USE_CUR_N2VAL"//ʹõǰRecipeN2ֵ + + + +#define RECIPE_PAR_NAME_LASER1_POW "RECIPE_PAR_NAME_LASER1_POW" +#define RECIPE_PAR_NAME_LASER2_POW "RECIPE_PAR_NAME_LASER2_POW" + + +#define RECIPE_PAR_NAME_ROTATO_DIMMER_ANG "RECIPE_PAR_NAME_ROTATO_DIMMER_ANG" //ת˥1ĽǶ +#define RECIPE_PAR_NAME_ROTATO_DIMMER_ANG2 "RECIPE_PAR_NAME_ROTATO_DIMMER_ANG2" //ת˥2ĽǶ + + +#define RECIPE_PAR_NAME_FIX_SCAN_SPEED "RECIPE_PAR_NAME_FIX_SCAN_SPEED"//̶ɨٶ +#define RECIPE_PAR_NAME_FIX_SCAN_LINE_GAP "RECIPE_PAR_NAME_FIX_SCAN_LINE_GAP"//̶ɨ߼ + +#define RECIPE_PAR_NAME_EDI_CHECK_SCOPE "RECIPE_PAR_NAME_EDI_CHECK_SCOPE"//ܶȿؾ + +#define RECIPE_PAR_NAME_SCAN_LINE_START_IDX "RECIPE_PAR_NAME_SCAN_LINE_START_IDX"//ʼɨߵֵ +#define RECIPE_PAR_NAME_LASER_EDI_OFFSET_1 "RECIPE_PAR_NAME_LASER_EDI_OFFSET_1" +#define RECIPE_PAR_NAME_LASER_EDI_OFFSET_2 "RECIPE_PAR_NAME_LASER_EDI_OFFSET_2" +#define RECIPE_PAR_NAME_ALIGNER_ANG "RECIPE_PAR_NAME_ALIGNER_ANG"//׼ֱǶ + +#define RECIPE_PAR_NAME_RUNTIMES "RECIPE_PAR_NAME_RUNTIMES" //ִд + + + + +#define LASER_DEVICE_PI_CLOSE_POW_VOL "LASER_DEVICE_PI_CLOSE_POW_VOL" +#define LASER_DEVICE_PI_CLOSE_POW_CURR "LASER_DEVICE_PI_CLOSE_POW_CURR" + + +#define RECIPE_PAR_MAX_LASER_CURR_1 "RECIPE_PAR_MAX_LASER_CURR_1" +#define RECIPE_PAR_MAX_LASER_CURR_2 "RECIPE_PAR_MAX_LASER_CURR_2" +#define RECIPE_PAR_MAX_LASER_EDI_1 "RECIPE_PAR_MAX_LASER_EDI_1" +#define RECIPE_PAR_MAX_LASER_EDI_2 "RECIPE_PAR_MAX_LASER_EDI_2" + +#define RECIPE_PAR_MAX_LASER_FRE "RECIPE_PAR_MAX_LASER_FRE" +#define RECIPE_PAR_MAX_LASER_PULSE_DELAY "RECIPE_PAR_MAX_LASER_PULSE_DELAY" +#define RECIPE_PAR_MIN_FOCUS_ADJUST "RECIPE_PAR_MIN_FOCUS_ADJUST" +#define RECIPE_PAR_MAX_FOCUS_ADJUST "RECIPE_PAR_MAX_FOCUS_ADJUST" +#define RECIPE_PAR_MIN_SCAN_SPEED "RECIPE_PAR_MIN_SCAN_SPEED" +#define RECIPE_PAR_MAX_SCAN_SPEED "RECIPE_PAR_MAX_SCAN_SPEED" +#define RECIPE_PAR_MAX_FIX_SCAN_LINE_GAP "RECIPE_PAR_MAX_FIX_SCAN_LINE_GAP" +#define RECIPE_PAR_MAX_LASER_POW_1 "RECIPE_PAR_MAX_LASER_POW_1" +#define RECIPE_PAR_MAX_LASER_POW_2 "RECIPE_PAR_MAX_LASER_POW_2" +#define RECIPE_PAR_MAX_DIMMER_ANG_1 "RECIPE_PAR_MAX_DIMMER_ANG_1" +#define RECIPE_PAR_MAX_DIMMER_ANG_2 "RECIPE_PAR_MAX_DIMMER_ANG_2" + + + +#define LAIPU_LASER_DATA_PATH _T("E:\\LaipuLaserData") +#define RECIPE_OFFSET_TBL_NULL "Empty" + +#define RECIPE_OFFSET_PAR_LASER1_EDI "LASER1_EDI_OFFSET" +#define RECIPE_OFFSET_PAR_LASER2_EDI "LASER2_EDI_OFFSET" + +#define RECIPE_OFFSET_PAR_LASER1_CURR "LASER1_CURR_OFFSET" +#define RECIPE_OFFSET_PAR_LASER2_CURR "LASER2_CURR_OFFSET" + + + +#define bOPEN true +#define bCLOSE false +#define THOW_EXCEPTION true //׳쳣 +#define COMM_BAUD_RATE_115200 115200 //ڲ115200 +#define COMM_BAUD_RATE_9600 9600 //ڲ9600 + + +#define ON_TERMINAL 5001 + + +#define BOOL_STR_TRUE "TRUE" +#define BOOL_STR_FALSE "FALSE" + +#define BOOL_STR_YES "YES" +#define BOOL_STR_NO "NO" + +#define STR_LASER_1 "Laser1" +#define STR_LASER_2 "Laser2" + +#define BOOL_STR_ON "ON" +#define BOOL_STR_OFF "OFF" + +//깤ߵ +enum MOUSE_TOOL +{ + _TOOL_POINT=0, + _TOOL_RECT, + _TOOL_LINE, + _TOOL_PLINE,//߶ + _TOOL_CIRCLE, + _TOOL_MOVE, + _TOOL_MOVE2,//ָƶ + _TOOL_ROTATO, + _TOOL_COPY, + _TOOL_MEASURE,// + _TOOL_ZOOM,// + _TOOL_CUT,//޼ + _TOOL_ADD_NODE,//ӽڵ + _TOOL_DEL_NODE,//ɾڵ + _TOOL_BREAK_NODE,//Ͻڵ + _TOOL_MOVE_NODE,//ƶڵ + _TOOL_TEXT,// + _TOOL_BARCODE,// + _TOOL_ONE_POINT,//һ + _TOOL_STRETCH,//칤 + _TOOL_PT_MOVE_TO_CCD,//ض;ĵ + _TOOL_SET_MARK_PT,//ֶָλ + _TOOL_LASER_COORD,//üλ +}; +enum OBJ_TYPE +{ + _TYPE_BASE = 0, + _TYPE_PLINE,//߶1 + _TYPE_POINT,//2 + _TYPE_CIRCLE,//Բ3 + _TYPE_COMPOSITE,//һ4 + _TYPE_TXT,//ַ5 + _TYPE_BARCODE,//6 + _TYPE_STR,//string 7 + _TYPE_CHAR,//ַ8 + _TYPE_ARC,//Բ +}; +enum X_OR_Y +{ + _X=0, + _Y, + _XY, +}; +enum CATCH_PT_TYPE//ץȡ +{ + _CATCH_NODE = 0,// + _CATCH_INTERSECT,//߶εĽ + _CATCH_ORTHO,// + _CATCH_CUT_TRACK,//Ԫи +}; +enum STATUS//깤ߵ״ֵ̬,ȷÿһʲô +{ + _STATUS_1 = 0, + _STATUS_2, + _STATUS_3, + _STATUS_4, + _STATUS_5, + _STATUS_6, + _STATUS_END +}; +enum OBJ_OP_TYPR +{ + _OP_MOVE = 0, + _OP_ROTATO, + _OP_MIRROR, + _OP_STRETCH,// + _OP_REVERSE,//תݵ + _OP_SCALE,// +}; + +inline bool IsDbEqual(double a,double b) +{ + if((abs(a-b))=B) + { + pt.y = (T+B)/2; + } + return pt; +} +inline DbSize DbRect::GetSize() +{ + DbSize size; + size.w = R - L; + size.h = T - B; + if(size.w<0) + size.w = 0; + if(size.h<0) + size.h = 0; + return size; +} +//ײĵ +inline Dbxy DbRect::GetBottomCenterPt() +{ + Dbxy pt; + pt.x = (L+R)/2; + pt.y = B; + return pt; +} +inline double DbRect::Width() +{ + return R-L; +} +inline double DbRect::Height() +{ + return T-B; +} +#endif + +//װжIJ,ͳһ͸ʽ +struct SObjOperatePar{ +SObjOperatePar() +{ + MoveX = MoveY = 0; + Angle = 0; + OldSize = NewSize = Diff = 0; + Scale = 1; +} +OBJ_OP_TYPR OpType;// +X_OR_Y xy;//ʶxy +Dbxy BasePt;//׼ +double MoveX;//ƶ +double MoveY; +double Angle;//360 Ƚ +double OldSize; +double NewSize; +double Diff; +double Scale;//ű +}; + +typedef pair PointType; + +//ԲIJ +class CCirclePar +{ +public: + CCirclePar(void) + { + Radius = 1; + DEdgeCnt = 32; + bMerge = true; + StartAng = 0; + EndAng = 360; + bReverse = false; + } +public: + Dbxy CenterPt;//Բ + double Radius;//뾶 + int DEdgeCnt;// + bool bMerge;//Ƿϲ + bool bReverse;//Ƿ + double StartAng;//ʼǶ360 Ƚ + double EndAng;//Ƕ +}; + +//״̬ +enum EModuleStateType +{ + _ModuleStateType_OK,// + _ModuleStateType_Warning,// + _ModuleStateType_ERR,//쳣 +}; + +class CDlgItemStr +{ +public: + CDlgItemStr(void) + { + m_ID = 0; + }; +public: + int m_ID;// + CString m_Str;//ʾ +}; +//ƫת +class COffsetRotatoPar +{ +public: + COffsetRotatoPar() + { + Reset(); + }; + void Reset() + { + m_Offset.x = 0; + m_Offset.y = 0; + m_RotatoAng = 0;//תǶ(30Ƚ) + m_bValid = false;//ǷЧ + }; +public: + bool m_bValid;//ǷЧ + Dbxy m_Offset;//ƫ + double m_RotatoAng;//תǶ(30Ƚ) +}; + +enum CAlamLightStateType +{ + _AlamLightStateType_NULL=0, + _AlamLightStateType_Off,//ر + _AlamLightStateType_On,// + _AlamLightStateType_Flash,//˸ +}; + +//ʾ״̬ +class CAlamLightState +{ +public: + CAlamLightState(void) + { + m_LightRedState = _AlamLightStateType_NULL;//״̬ + m_LightYellowState = _AlamLightStateType_NULL;//Ƶ״̬ + m_LightGreenState = _AlamLightStateType_NULL;//̵״̬ + m_LightAlamState = _AlamLightStateType_NULL;//״̬ + }; +public: + CAlamLightStateType m_LightRedState;//״̬ + CAlamLightStateType m_LightYellowState;//Ƶ״̬ + CAlamLightStateType m_LightGreenState;//̵״̬ + CAlamLightStateType m_LightBlueState;//״̬ + CAlamLightStateType m_LightAlamState;//״̬ +}; + +//öȡĵλź(ӺÿĿInitCommReadBitVec ҪӦ,±) +//ıΪ˿ǿõ +enum eCommReadSignalType +{ + _ReadSignalType_Null = 0, + _ReadSignalType_MachineGate1,//բź1 + _ReadSignalType_MachineGate2,//բź2 + _ReadSignalType_PlateVacuum,//ƽ̨wafer ź + _ReadSignalType_LaserDimmer1,//˥ź1 + _ReadSignalType_LaserDimmer2,//˥ź2 + _ReadSignalType_RedLight,// + _ReadSignalType_AlamState,//״̬ + _ReadSignalType_ArmProduct,//еֲƷź + _ReadSignalType_ArmReady,//е׼ź + _ReadSignalType_ArmTrasmitting,//еִź + _ReadSignalType_LaserPowLock,//Դť + _ReadSignalType_ThimbleSignal1,//ź1 + _ReadSignalType_ThimbleSignal2,//ź2 + _ReadSignalType_ArmAutoState,//еԶ״̬[14] + _ReadSignalType_Smif1Working,//SMIFæź1 + _ReadSignalType_Smif2Working,//SMIFæź1 + _ReadSignalType_ArmWorking,//еæź + _ReadSignalType_Port1MappingEnd,//Port1 mappingź + _ReadSignalType_Port2MappingEnd,//Port2 mappingź + _ReadSignalType_Pod1Signal_1,//Ϻ1 ź1 [20] + _ReadSignalType_Pod2Signal_1,//Ϻ2 ź1 [21] + _ReadSignalType_WaferPosAligner,//׼ֱwafer ź + _ReadSignalType_WaferPosArm,//еwafer ź1 (load arm) + _ReadSignalType_Port1MappingCommit,//Port1 Mapping ȷ + _ReadSignalType_Port2MappingCommit,//Port2 Mapping ȷ + _ReadSignalType_ArmAutoTransfer,//ԶƬ + _ReadSignalType_CassetteDoorSignal_1,//Ϻź1 [27] + + _ReadSignalType_CassetteDoorSignal_2,//Ϻź2 [28] + _ReadSignalType_Pod1Signal_2,//Ϻ1 ź2 (е豸Sensor) [29] + _ReadSignalType_Pod2Signal_2,//Ϻ2 ź2 (е豸Sensor) [30] + _ReadSignalType_Pod1WaferOutSensor,//Ϻ1 wafer [31] + _ReadSignalType_Pod2WaferOutSensor,//Ϻ2 wafer [32] + + _ReadSignalType_Pod1PushInSignal,//Ϻ1 ̨λź(Ϻ,wafer ʱŻON) + _ReadSignalType_Pod2PushInSignal,//Ϻ2 ̨λź + _ReadSignalType_Pod1PushOutSignal,//Ϻ1 ˳̨λź + _ReadSignalType_Pod2PushOutSignal,//Ϻ2 ˳̨λź + + _ReadSignalType_WaferPosArm2,//еwafer ź2 (˫ۻеUnloadõarm) + _ReadSignalType_OxygenCheckSignal,//Ũȼź(OnΪ<100ppm) + + + _ReadSignalType_Pod1Signal_3,//Ϻ1 ź3 (8Ϻ) + _ReadSignalType_Pod2Signal_3,//Ϻ2ź3 (8Ϻ) + _ReadSignalType_Pod1Signal_4,//Ϻ1 ź4 (8Ϻ) + _ReadSignalType_Pod2Signal_4,//Ϻ2ź4 (8Ϻ) + + _ReadSignalType_Pod1WaferSensor,//Ϻ1 wafer (ϺǷwafer) + _ReadSignalType_Pod2WaferSensor,//Ϻ2 wafer (ϺǷwafer) + _ReadSignalType_Pod1WaferAdjustSensor1,////Ϻ1 wafer ϴ1 (wafer Ū) + _ReadSignalType_Pod1WaferAdjustSensor2,////Ϻ1 wafer ϴ2 (wafer Ū) + _ReadSignalType_Pod2WaferAdjustSensor1,////Ϻ1 wafer ϴ1 (wafer Ū) + _ReadSignalType_Pod2WaferAdjustSensor2,////Ϻ1 wafer ϴ2 (wafer Ū) + + _ReadSignalType_Max,//ֵ +}; + +enum eLaserDeviceType +{ + _LaserDeviceType_MainLaser1=0,//̹1 + _LaserDeviceType_MainLaser2,//̹2 + _LaserDeviceType_RedLaser,// +}; +//load port +enum eWaferLoadPortType +{ + _LoadPortType_Null = 0, + _LoadPortType_Port1, + _LoadPortType_Port2, +}; + +//Ϻе +enum eCassetteType +{ + _CassetteType_Slot13 = 0,//13Ϻ + _CassetteType_Slot25,//25Ϻ +}; +//λƵĿ״̬ +enum eTwoIOPtCtrlState +{ + _TwoIOPtCtrlState_Null = 0, //λûж + _TwoIOPtCtrlState_Off,//ر + _TwoIOPtCtrlState_On,// +}; + + + diff --git a/LaipuDrawing/GlobalDrawMgr.cpp b/LaipuDrawing/GlobalDrawMgr.cpp new file mode 100644 index 0000000..a609fac --- /dev/null +++ b/LaipuDrawing/GlobalDrawMgr.cpp @@ -0,0 +1,1195 @@ +#include "StdAfx.h" +#include "GlobalDrawMgr.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "LaiPuLaserView.h" +#include "GlobalFunction.h" +#include "SequentialPoint.h" +#include "DrawSimpleShape.h" +#include "MouseToolmgr.h" +#include "AuthorityMgr.h" +#include "ObjComponentMgr.h" +#include "WorkAreaMgr.h" +#include "EncryptionMgr.h" + + +CGlobalDrawMgr *gDraw = new CGlobalDrawMgr; +CGlobalDrawMgr::CGlobalDrawMgr(void) +{ + ResetView(); + + m_SelObjRectGap = 20/m_ViewScale;//ѡobj Χļ + m_RotatoPtDis = 30/m_ViewScale;//תľ + m_MousePointRectSize = 5/m_ViewScale;//ѡǷεijߴ + m_MouseCatchRectSize = 10/m_ViewScale;//겶ľηΧ + m_CatchNodeSize = 6/m_ViewScale;//Ʋnode 㷽ijߴ + m_MouseCursorSize = 32/m_ViewScale;//ijߴ + m_MouseCursorRectSize = 4/m_ViewScale;//м䷽ijߴ + m_PenWidth = 0.5;//ʵĿ + + m_BkgndColor = RGB_WHITE; + m_AxisColor = RGB_GREEN; + + m_ObjectPen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_WHITE); + m_SelObjectPen.CreatePen(PS_DOT,m_PenWidth,RGB_RED);//ѡObject Ʊ + + LOGBRUSH LogBrush; + LogBrush.lbColor = RGB_YELLOW; + LogBrush.lbStyle = PS_SOLID; + m_MouseRectPen.CreatePen( PS_COSMETIC | PS_ALTERNATE , 1, &LogBrush, 0, NULL ); + + m_SelObjRectPen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_RED);//ѡobj + m_SelObjSmallRectPen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_YELLOW);//ѡobj С + m_CatchNodePen.CreatePen(PS_SOLID,3,RGB_YELLOW);//node ı + m_ObjFirstNodeColor = RGB_RED;//obj ׽ڵɫ + m_EasyOperationColor = RGB_YELLOW;//ݲɫ + m_ObjNodeColor = RGB_NODE_BLUE;//obj ڵɫ + m_MeasurePen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_RED);// + m_ObjComponentAreaPen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_BLUE);////ԪΧ + m_MarkPointPen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_RED);;//۶λ + m_TempRectPen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_RED);//ģ߿ + //m_ScanLinePen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_GRAY2);//ɨ + m_ScanLinePen.CreatePen(PS_INSIDEFRAME,m_PenWidth,RGB_RED);//ɨ + + m_ScrollViewSize.cx = SCROLL_SIZE_CX; + m_ScrollViewSize.cy = SCROLL_SIZE_CY; + + m_ScrollViewCenterPt.x = SCROLL_SIZE_CX/2; + m_ScrollViewCenterPt.y = SCROLL_SIZE_CY/2; + + m_bDrawAxis = true;//Ƿ + m_bCatchObjNode = true;//Ƿץȡobj Ľڵ + m_bCatchOrthoPoint = true;//Ƿץȡ + m_bCatchCutTrack = false;//ǷץȡԪиĽ + + m_KeyboardMoveDis = 1;//ƶѡĶһƶľ(λ:mm) + + m_DlgViewScale = 5;//Իͼ豸Ӧ߼ı + + m_WorkAreaViewScale = (0.000461);//۲ű + m_TempViewScale = -1;//ʱű + m_MouseWheelScale = 1.25; + + m_bRectSel = true;//ѡ + m_bPointSel = true;//ѡ + m_bMultipleSel = true;//Ƿѡ(false ʱȡ֮ǰѡ) + m_bMouseWheel = true;//Ƿ + m_bEditLayerObj = true;//ǷԱ༭layer obj + m_bUseEasyOperation = true;//Ƿʹſݲ + + m_CircleOneMMptCnt = 30;//Բʱ1mm ܳϰٸ + m_MinCircleOneMMptCnt = 100;//Сֵ(ԶĵСֵ) + + m_AreaGridGap = 10;//area ʾļmm + m_bShowObjNode = true;//Ƿobj Ľڵ + m_bDrawObjIdxCenter = true;//obj ֵʾ(false ڵһʾ) + m_bNeedRedraw = false;//ǷҪػ + + m_bObjEditMode = false;//ͼα༭ģʽ + m_DlgMainWidth = 1600;//Ŀ + m_DlgMainWidthNoteBook = 1200;//Ŀ(ʼDZ) + + m_EditTextColor = RGB_GREEN;//༭ɫ + m_EditBkColor = RGB_BLACK;//༭򱳾ɫ + m_EditFontSize = 120;//༭ĴС + + m_WaferSateColor1 = RGB_WHITE;//wafer ״̬ɫ_WaferState_NoWafer + m_WaferSateColor2 = RGB_GRAY2;//wafer ״̬ɫ_WaferState_NoSel + m_WaferSateColor3 = RGB_BLUE1;//wafer ״̬ɫ_WaferState_Untreated + m_WaferSateColor4 = RGB_PURPLE;//wafer ״̬ɫ_WaferState_Waiting + m_WaferSateColor5 = RGB_YELLOW;//wafer ״̬ɫ_WaferState_Processing + m_WaferSateColor6 = RGB_GREEN1;//wafer ״̬ɫ_WaferState_Finished + m_WaferSateColor7 = RGB_RED;//wafer ״̬ɫ_WaferState_NoFinished + + m_LCD_Txt_LineW = 2;//LCD ʾ߿ + + m_bDlgLayerViewShow = false;//ǷڶԻʾview +} +CGlobalDrawMgr::~CGlobalDrawMgr(void) +{ + m_ObjectPen.DeleteObject(); + m_SelObjectPen.DeleteObject(); + m_MouseRectPen.DeleteObject(); + m_SelObjRectPen.DeleteObject(); + m_SelObjSmallRectPen.DeleteObject(); + m_CatchNodePen.DeleteObject(); + m_MarkPointPen.DeleteObject(); + m_TempRectPen.DeleteObject(); +} +#if 1//ģԹ +void CGlobalDrawMgr::OnAppInitialize() +{ + gMouseToolMgr.SetMouseTool(_TOOL_POINT); + OnPropertyChanged(); + m_pView = GetCurViewPtr(); + m_pView->DoZoomFull(); +} +CMFCPropertyGridProperty * CGlobalDrawMgr::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = _T("ViewDraw");//洢· + CString Name; +//-------------------------------------------------------------------------------// + PropertyName = _T("ʾ"); + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); + +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_EditTextColor");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_EditTextColor); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Text ɫ"); + Description = _T("Text ɫ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_EditTextColor, NULL, Description); + p1->EnableOtherButton(_T("...")); + p1->EnableAutomaticButton(_T("Ĭ"),RGB_GREEN); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_EditBkColor");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_EditBkColor); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Text ɫ"); + Description = _T("Text ɫ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_EditBkColor, NULL, Description); + p1->EnableOtherButton(_T("...")); + p1->EnableAutomaticButton(_T("Ĭ"),RGB_BLACK); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_EditFontSize");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_EditFontSize); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Text С"); + Description = _T("Text С"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_EditFontSize, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_BkgndColor");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_BkgndColor); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ɫ"); + Description = _T("ͼɫ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_BkgndColor, NULL, Description); + p1->EnableOtherButton(_T("...")); + p1->EnableAutomaticButton(_T("Ĭ"),RGB_BLACK); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_ButtomDefaultColor");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_ButtomDefaultColor); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ťɫ"); + Description = _T("ťĬɫ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_ButtomDefaultColor, NULL, Description); + p1->EnableOtherButton(_T("...")); + p1->EnableAutomaticButton(_T("Ĭ"),RGB_BLUE); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_ScanLineColor");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_ScanLineColor); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ɨɫ"); + Description = _T("˻ɨߵɫ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_ScanLineColor, NULL, Description); + p1->EnableOtherButton(_T("...")); + p1->EnableAutomaticButton(_T("Ĭ"),RGB_YELLOW); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_WorkAreaViewScale");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WorkAreaViewScale); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ĬϹ۲"); + Description = _T("۲Ĭϱ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_WorkAreaViewScale, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_MouseWheelScale");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_MouseWheelScale); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T(""); + Description = _T("һα仯ı"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MouseWheelScale, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_AreaGridGap");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_AreaGridGap); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T(""); + Description = _T("ӹļmm"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_AreaGridGap, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_DlgMainWidth");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_DlgMainWidth); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("1"); + Description = _T(""); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_DlgMainWidth, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_DlgMainWidthNoteBook");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_DlgMainWidthNoteBook); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("2"); + Description = _T("(Note book)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_DlgMainWidthNoteBook, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_KeyboardMoveDis");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_KeyboardMoveDis); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ֶƶ"); + Description = _T("ƶѡͼζһεľ(λ:mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_KeyboardMoveDis, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_LCD_Txt_LineW");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_LCD_Txt_LineW); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("LCD߿"); + Description = _T("LCD ʾ߿"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LCD_Txt_LineW, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("Բ")); + { + //Աӳ + Name = _T("m_CircleOneMMptCnt");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_CircleOneMMptCnt); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Բ"); + Description = _T("1 mm ֱԲϵĸ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_CircleOneMMptCnt, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_MinCircleOneMMptCnt");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_MinCircleOneMMptCnt); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ԲСֵ"); + Description = _T("Сֵ(ԶĵСֵ,ƺСĻߵ)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MinCircleOneMMptCnt, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("Wafer ״̬ɫ")); + { + //Աӳ + Name = _T("m_WaferSateColor1");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WaferSateColor1); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("NoSelect"); + Description = _T("wafer ,ûѡ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_WaferSateColor1, NULL, Description); + p1->EnableOtherButton(_T("...")); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_WaferSateColor2");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WaferSateColor2); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Waiting"); + Description = _T("ȴӹ״̬"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_WaferSateColor2, NULL, Description); + p1->EnableOtherButton(_T("...")); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_WaferSateColor3");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WaferSateColor3); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Loading"); + Description = _T("״̬"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_WaferSateColor3, NULL, Description); + p1->EnableOtherButton(_T("...")); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_WaferSateColor4");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WaferSateColor4); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Proccess"); + Description = _T("ӹ״̬"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_WaferSateColor4, NULL, Description); + p1->EnableOtherButton(_T("...")); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_WaferSateColor5");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WaferSateColor5); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Unloading"); + Description = _T("״̬"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_WaferSateColor5, NULL, Description); + p1->EnableOtherButton(_T("...")); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_WaferSateColor6");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WaferSateColor6); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Finished"); + Description = _T("ӹ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_WaferSateColor6, NULL, Description); + p1->EnableOtherButton(_T("...")); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_WaferSateColor7");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WaferSateColor7); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Unfinished"); + Description = _T("wafer ˻ϺУδɼӹ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_WaferSateColor7, NULL, Description); + p1->EnableOtherButton(_T("...")); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("")); + { + //Աӳ + Name = _T("m_ProgressDlgPos_x");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_ProgressDlgPos.x); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("λX"); + Description = _T("Ի򵯳λX ()"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_ProgressDlgPos.x, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_ProgressDlgPos_y");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_ProgressDlgPos.y); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("λY"); + Description = _T("Ի򵯳λY ()"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_ProgressDlgPos.y, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("")); + { + //Աӳ + Name = _T("m_bDrawAxis");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bDrawAxis); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ʾ"); + Description = _T("Ƿʾ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bDrawAxis, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_AxisColor");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_AxisColor); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ɫ"); + Description = _T("ͼɫ"); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_AxisColor, NULL, Description); + p1->EnableOtherButton(_T("...")); + p1->EnableAutomaticButton(_T("Ĭ"),RGB_BLACK); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("Իview")); + { + //Աӳ + Name = _T("m_DlgLogicCenter_x");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_DlgLogicCenter.x); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("߼X"); + Description = _T("view ӳ䵽Ի߼X"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_DlgLogicCenter.x, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_DlgLogicCenter_y");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_DlgLogicCenter.y); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("߼Y"); + Description = _T("view ӳ䵽Ի߼Y"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_DlgLogicCenter.y, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_DlgViewScale");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_DlgViewScale); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Իͼ"); + Description = _T("view ӳ䵽Իͼ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_DlgViewScale, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + //-------------------------------------------------------------------------------// + //-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Engineer)) + { + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("׽")); + { + //Աӳ + Name = _T("m_bCatchObjNode");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bCatchObjNode); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ڵ㲶׽"); + Description = _T("Ƿ׽Ľڵ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCatchObjNode, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bCatchObjLine");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bCatchObjLine); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("߶β׽"); + Description = _T("Ƿ׽߶ϵĵ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCatchObjLine, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bCatchCrossPoint");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bCatchCrossPoint); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("㲶׽"); + Description = _T("Ƿ׽Ľ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCatchCrossPoint, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bCatchOrthoPoint");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bCatchOrthoPoint); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("׽"); + Description = _T("Ƿ׽"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCatchOrthoPoint, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bCatchCutTrack");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bCatchCutTrack); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ԭ׽"); + Description = _T("Ƿ׽Ԫĵ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCatchCutTrack, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Engineer)) + { + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(_T("")); + { + //Աӳ + Name = _T("m_bUseEasyOperation");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bUseEasyOperation); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ʾŵ"); + Description = _T("Ƿʾݵobj ŵ㹦"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bUseEasyOperation, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bEditLayerObj");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bEditLayerObj); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("༭"); + Description = _T("Ƿֶ༭ͼ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bEditLayerObj, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bRectSel");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bRectSel); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ѡ"); + Description = _T("Ƿʹѡ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bRectSel, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bPointSel");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bPointSel); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ѡ"); + Description = _T("Ƿʹѡ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bPointSel, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bMultipleSel");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bMultipleSel); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ѡ"); + Description = _T("false ʱȡ֮ǰѡ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bMultipleSel, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bMouseWheel");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bMouseWheel); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T(""); + Description = _T("Ƿ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bMouseWheel, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bShowObjNode");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bShowObjNode); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ڵ"); + Description = _T("ǷʾѡĽڵ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bShowObjNode, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bDrawObjIdxCenter");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bDrawObjIdxCenter); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("λ"); + Description = _T("TRUE : ʾ,FALSE : ڵһʾ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bDrawObjIdxCenter, Description); + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + return pGroup; +} +//ӦԵĸı +void CGlobalDrawMgr::OnPropertyChanged() +{ + //ˢ½ʾ + CLaiPuLaserView *pView = GetCurViewPtr(); + if(pView) + { + pView->RefreshView(); + } +} +#endif +#if 1 +//view ΪԻʾ +void CGlobalDrawMgr::SetViewToDlg() +{ + m_LogicCenter = m_DlgLogicCenter; + m_ViewScale = m_DlgViewScale; + + m_bDlgLayerViewShow = true;//ǷڶԻʾview +} +//ָview ʾ +void CGlobalDrawMgr::ResetView() +{ + m_bDlgLayerViewShow = false;//ǷڶԻʾview + CPoint pt(LOGIC_CENTER_X,LOGIC_CENTER_Y); + m_LogicCenter = pt; + m_ViewScale = 10000;//ͼ豸Ӧ߼ı(1׶Ӧ10000) +} +double CGlobalDrawMgr::GetWorkAreaViewScale() +{ + if(m_TempViewScale>0)//ʱű + { + return m_TempViewScale; + } + return m_WorkAreaViewScale; +} +//ȡ̶Ŀ +int CGlobalDrawMgr::GetDlgMainWidth() +{ + if(gEncryptionMgr->IsbRunAtNoteBook()) + return m_DlgMainWidthNoteBook; + return m_DlgMainWidth; +} +#endif +#if 1//ת +//߼תΪ豸 +int CGlobalDrawMgr::Logic2Divce(double LogicCoord,X_OR_Y xy) +{ + int rtn; + if(xy == _X) + { + rtn = LogicCoord*m_ViewScale + m_LogicCenter.x; + } + else + { + rtn = m_LogicCenter.y -LogicCoord*m_ViewScale; + } + return rtn; +} +double CGlobalDrawMgr::Divce2Logic(int DivceCoord,X_OR_Y xy) +{ + double rtn; + if(xy == _X) + { + rtn = (DivceCoord- m_LogicCenter.x)/m_ViewScale; + } + else + { + rtn = (m_LogicCenter.y - DivceCoord)/m_ViewScale; + } + return rtn; +} +CRect CGlobalDrawMgr::DbRect2CRect(DbRect dbRect) +{ + CRect rect; + rect.left = Logic2Divce(dbRect.L,_X); + rect.right = Logic2Divce(dbRect.R,_X); + rect.top = Logic2Divce(dbRect.T,_Y); + rect.bottom = Logic2Divce(dbRect.B,_Y); + + return rect; +} +Dbxy CGlobalDrawMgr::CPoint2Dbxy(CPoint point) +{ + Dbxy pt; + pt.x = Divce2Logic(point.x,_X); + pt.y = Divce2Logic(point.y,_Y); + return pt; +} +CPoint CGlobalDrawMgr::Dbxy2CPoint(Dbxy point) +{ + CPoint pt; + pt.x = Logic2Divce(point.x,_X); + pt.y = Logic2Divce(point.y,_Y); + return pt; +} +//豸ߴתΪ߼ߴ +double CGlobalDrawMgr::Int2Double(int size) +{ + return (double)size/m_ViewScale; +} +//߼ߴתΪ豸ߴ +int CGlobalDrawMgr::Double2Int(double d) +{ + return (int)(d*m_ViewScale); +} +#endif + +#if 1//ƹͨ +void CGlobalDrawMgr::Draw(CDC* pDC) +{ + DrawAxis(pDC); +} +// +void CGlobalDrawMgr::DrawAxis(CDC* pDC) +{ + if(!m_bDrawAxis) + return; + CPen Pen,*pOldPen; + Pen.CreatePen(PS_INSIDEFRAME,1,m_AxisColor); + pOldPen = pDC->SelectObject(&Pen); + + int CenterX = m_ScrollViewCenterPt.x; + int CenterY = m_ScrollViewCenterPt.y; + + pDC->MoveTo(0, CenterY); + pDC->LineTo(m_ScrollViewSize.cx+2000, CenterY); + pDC->MoveTo(CenterX,0); + pDC->LineTo(CenterX, m_ScrollViewSize.cy*2); + Pen.DeleteObject(); + pDC->SelectObject(pOldPen); +} +//Ĺ +void CGlobalDrawMgr::DrawMouseCross(CDC* pDC,Dbxy pt) +{ + double CorssSize = GetCurViewPtr()->GetCurrScaleVal(m_MouseCursorSize); + XorDrawCross(pDC,true,m_ObjectPen,pt,CorssSize); +} +//Ĺ +void CGlobalDrawMgr::DrawMouseRect(CDC* pDC,Dbxy pt) +{ + double rectSize = GetCurViewPtr()->GetCurrScaleVal(m_MouseCursorRectSize); + DrawRect(pDC,m_ObjectPen,pt,rectSize); +} +//ݵ +void CGlobalDrawMgr::DrawDbxyVec(CDC* pDC,vector> &vec) +{ + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + int size = vec.size(); + for(int i=0;iter!=iter_end;i++,iter++) + { + vector::iterator iter1 = (*iter).begin(); + vector::iterator iter1_end = (*iter).end(); + for(;iter1!=iter1_end;iter1++) + { + CPoint pt = Dbxy2CPoint(*iter1); + if(iter1 == (*iter).begin()) + { + pDC->MoveTo(pt.x,pt.y); + } + else + { + pDC->LineTo(pt.x,pt.y); + } + } + } +} +// +void CGlobalDrawMgr::DrawTxt(CDC *pDC,CString txt,Dbxy pt) +{ + CPoint Point = Dbxy2CPoint(pt); + //------------------------------------------------------ + pDC->TextOut(Point.x,Point.y,txt); +} +#endif +#if 1//ȡһЩֵ +double CGlobalDrawMgr::GetSelObjRectGap() +{ + return GetCurViewPtr()->GetCurrScaleVal(m_SelObjRectGap); +} +double CGlobalDrawMgr::GetRotatoPtDis() +{ + return GetCurViewPtr()->GetCurrScaleVal(m_RotatoPtDis); +} +double CGlobalDrawMgr::GetCatchNodeSize() +{ +return GetCurViewPtr()->GetCurrScaleVal(m_CatchNodeSize);; +} +#endif +#if 1// +//ȡǰ㷶Χ +DbRect CGlobalDrawMgr::GetCurPointRect(Dbxy pt,double Scale) +{ + return GetCurRect(pt,m_MousePointRectSize*Scale); +} +//ȡǰ겶rect Χ +DbRect CGlobalDrawMgr::GetCurCatchRect(Dbxy pt) +{ + return GetCurRect(pt,m_MouseCatchRectSize); +} +DbRect CGlobalDrawMgr::GetCurRect(Dbxy pt,double size) +{ + double DSize = GetCurViewPtr()->GetCurrScaleVal(size); + DbRect rect(Dbxy(pt.x-DSize,pt.y+DSize),Dbxy(pt.x+DSize,pt.y-DSize)); + return rect; +} +#endif +//ȡ뾶R Բĵ +int CGlobalDrawMgr::GetCirclePtCnt(double R) +{ + double Perimeter = 2*PI*R; + int cnt = Perimeter*m_CircleOneMMptCnt; + return (cnt > m_MinCircleOneMMptCnt)?cnt:m_MinCircleOneMMptCnt; +} +//ȡwafer ״̬ɫ +COLORREF CGlobalDrawMgr::GetWaferSateColor(int Idx) +{ + COLORREF c; + switch(Idx) + { + case 0://NoSelect + c = m_WaferSateColor1; + break; + case 1://Waiting + c = m_WaferSateColor2; + break; + case 2://Loading + c = m_WaferSateColor3; + break; + case 3://Proccess + c = m_WaferSateColor4; + break; + case 4://Unloading + c = m_WaferSateColor5; + break; + case 5://Finished + c = m_WaferSateColor6; + break; + case 6://Unfinished + c = m_WaferSateColor7; + break; + default: + break; + } + + return c; +} \ No newline at end of file diff --git a/LaipuDrawing/GlobalDrawMgr.h b/LaipuDrawing/GlobalDrawMgr.h new file mode 100644 index 0000000..b491277 --- /dev/null +++ b/LaipuDrawing/GlobalDrawMgr.h @@ -0,0 +1,192 @@ +#pragma once +#include "Module.h" +#include "DataPoint.h" +#include "EnumPropertieType.h" + +#define SCROLL_SIZE_CX (15000000) //x ķΧ--(λ:) +#define SCROLL_SIZE_CY (8000000) //y ķΧ--(λ:) + +#define LOGIC_CENTER_X (SCROLL_SIZE_CX/2) //߼ĵX --(λ:) +#define LOGIC_CENTER_Y (SCROLL_SIZE_CY/2) //߼ĵY --(λ:) + +class CGlobalDrawMgr:public CModule +{ +public: + CGlobalDrawMgr(void); + ~CGlobalDrawMgr(void); + virtual void OnAppInitialize(); + virtual CMFCPropertyGridProperty *CreatGridProperty(); + //ӦԵĸı + virtual void OnPropertyChanged(); + virtual MODULE GetModuleType(){return _DRAW_PROP;}; + virtual void Draw(CDC* pDC); +public: + void XorDrawLine(CDC* pDC,CPen&pen,Dbxy pt1,Dbxy pt2); + COLORREF GetBkgndColor(){return m_BkgndColor;}; + CSize GetScrollViewSize(){return m_ScrollViewSize;}; + Dbxy CPoint2Dbxy(CPoint point); + CPoint Dbxy2CPoint(Dbxy point); + CRect DbRect2CRect(DbRect dbRect); + double Int2Double(int size); + int Double2Int(double d); + CPen& GetObjectPen(){return m_ObjectPen;}; + CPen& GetSelObjectPen(){return m_SelObjectPen;}; + CPen& GetMouseRectPen(){return m_MouseRectPen;}; + CPen& GetSelObjRectPen(){return m_SelObjRectPen;}; + CPen& GetSelObjSmallRectPen(){return m_SelObjSmallRectPen;}; + CPen& GetCatchNodePen(){return m_CatchNodePen;}; + CPen& GetMeasurePen(){return m_MeasurePen;}; + CPen& GetObjComponentAreaPen(){return m_ObjComponentAreaPen;}; + CPen& GetMarkPointPen(){return m_MarkPointPen;}; + CPen& GetTempRectPen(){return m_TempRectPen;}; + CPen& GetScanLine(){return m_ScanLinePen;}; + + + double GetCatchNodeSize(); + COLORREF GetObjNodeColor(){return m_ObjNodeColor;}; + COLORREF GetObjFirstNodeColor(){return m_ObjFirstNodeColor;}; + COLORREF GetEasyOperationColor(){return m_EasyOperationColor;}; + COLORREF GetButtomDefaultColor(){return m_ButtomDefaultColor;}; + COLORREF GetScanLineColor(){return m_ScanLineColor;}; + + COLORREF GetEditTextColor(){return m_EditTextColor;}; + COLORREF GetEditBkColor(){return m_EditBkColor;}; + int GetEditFontSize(){return m_EditFontSize;}; + + double GetSelObjRectGap(); + double GetRotatoPtDis(); + DbRect GetCurPointRect(Dbxy pt,double Scale = 1); + DbRect GetCurCatchRect(Dbxy pt); + bool IsCatchObjNode(){return (m_bCatchObjNode||m_bObjEditMode);}; + bool IsCatchObjLine(){return (m_bCatchObjLine||m_bObjEditMode);}; + bool IsCatchCrossPoint(){return (m_bCatchCrossPoint||m_bObjEditMode);}; + bool IsCatchOrthoPoint(){return (m_bCatchOrthoPoint||m_bObjEditMode);}; + bool IsCatchCutTrack(){return (m_bCatchCutTrack||m_bObjEditMode);}; + void SetCurZoomPoint(CPoint point){m_CurZoomPoint = point;}; + CPoint GetCurZoomPoint(){return m_CurZoomPoint;}; + void DrawMouseCross(CDC* pDC,Dbxy pt); + void DrawMouseRect(CDC* pDC,Dbxy pt); + void DrawDbxyVec(CDC* pDC,vector> &vec); + double GetKeyboardMoveDis(){return m_KeyboardMoveDis;}; + void SetViewToDlg(); + void ResetView(); + double GetWorkAreaViewScale(); + double GetMouseWheelScale(){return m_MouseWheelScale;}; + bool IsbRectSel(){return (m_bRectSel||m_bObjEditMode);}; + bool IsbPointSel(){return (m_bPointSel||m_bObjEditMode);}; + bool IsEditLayerObj(){return (m_bEditLayerObj||m_bObjEditMode);}; + bool IsbMultipleSel(){return (m_bMultipleSel||m_bObjEditMode);}; + bool IsbMouseWheel(){return (m_bMouseWheel||m_bObjEditMode);}; + void SetTempViewScale(double val){m_TempViewScale = val;}; + int GetCirclePtCnt(double R); + CPoint GetProgressDlgPos(){return m_ProgressDlgPos;}; + void DrawTxt(CDC *pDC,CString txt,Dbxy pt); + bool IsbUseEasyOperation(){return m_bUseEasyOperation;}; + double GetAreaGridGap(){return m_AreaGridGap;}; + bool IsbShowObjNode(){return m_bShowObjNode;}; + bool IsbDrawObjIdxCenter(){return m_bDrawObjIdxCenter;}; + void SetbNeedRedraw(bool b){m_bNeedRedraw = b;}; + bool IsbNeedRedraw(){return m_bNeedRedraw;}; + void SetbObjEditMode(bool b){m_bObjEditMode = b;}; + bool IsbObjEditMode(){return m_bObjEditMode;}; + int GetDlgMainWidth(); + COLORREF GetWaferSateColor(int Idx); + double GetLCD_Txt_LineW(){return m_LCD_Txt_LineW;}; + bool IsbDlgLayerViewShow(){return m_bDlgLayerViewShow;}; +private: + DbRect GetCurRect(Dbxy pt,double size); + void DrawAxis(CDC* pDC); + int Logic2Divce(double LogicCoord,X_OR_Y xy); + double Divce2Logic(int DivceCoord,X_OR_Y xy); +private: + CPoint m_LogicCenter;//߼ĵ + CPoint m_DlgLogicCenter;//Ի߼ĵ + double m_ViewScale;//ͼ豸Ӧ߼ı + double m_DlgViewScale;//Իͼ豸Ӧ߼ı + double m_SelObjRectGap;//ѡobj Χļ + double m_RotatoPtDis;//תľ + double m_MousePointRectSize;//ѡľεijߴ + double m_MouseCatchRectSize;//겶ľηΧ + double m_CatchNodeSize;//Ʋnode 㷽ijߴ + double m_MouseCursorSize;//ijߴ + double m_MouseCursorRectSize;//м䷽ijߴ + CSize m_ScrollViewSize;//ͼķΧ + + CPoint m_ProgressDlgPos;//Իλ + + CPoint m_ScrollViewCenterPt;//ͼĵ + COLORREF m_BkgndColor; //viewɫ + bool m_bDrawAxis;//Ƿ + COLORREF m_AxisColor; //ɫ + + COLORREF m_EditTextColor;//༭ɫ + COLORREF m_EditBkColor;//༭򱳾ɫ + int m_EditFontSize;//༭ĴС + + int m_PenWidth;//ʵĿ + CPen m_ObjectPen;//Object Ʊ + CPen m_SelObjectPen;//ѡObject Ʊ + CPen m_MouseRectPen;//ѡı + CPen m_SelObjRectPen;//ѡobj + CPen m_SelObjSmallRectPen;//ѡobj С + CPen m_CatchNodePen;//node ı + CPen m_MeasurePen;// + CPen m_ObjComponentAreaPen;//ԪΧ + CPen m_MarkPointPen;//۶λ + CPen m_TempRectPen;//ģ߿ + CPen m_ScanLinePen;//ɨ + + COLORREF m_ObjNodeColor;//obj ڵɫ + COLORREF m_ObjFirstNodeColor;//obj ڵɫ + COLORREF m_EasyOperationColor;//ݲɫ + + bool m_bObjEditMode;//ͼα༭ģʽ + bool m_bCatchObjNode;//Ƿץȡobj Ľڵ + bool m_bCatchObjLine;//Ƿץȡobj ߶ϵĵ + bool m_bCatchCrossPoint;//Ƿץȡobj Ľ + bool m_bCatchOrthoPoint;//Ƿץȡ + bool m_bCatchCutTrack;//ǷץȡԪиĽ + + CPoint m_CurZoomPoint;//ǰŵ + + double m_KeyboardMoveDis;//ƶѡĶһƶľ(λ:mm) + double m_WorkAreaViewScale;//۲ű + double m_TempViewScale;//ʱű + double m_MouseWheelScale;//ı + bool m_bRectSel;//ѡ + bool m_bPointSel;//ѡ + bool m_bMultipleSel;//Ƿѡ(false ʱȡ֮ǰѡ) + bool m_bMouseWheel;//Ƿ + bool m_bEditLayerObj;//ǷԱ༭layer obj + bool m_bUseEasyOperation;//Ƿʹſݲ + + COLORREF m_ButtomDefaultColor;//ťĬɫ + COLORREF m_ScanLineColor;//ɨߵɫ + + int m_CircleOneMMptCnt;//Բʱ1mm ܳϰٸ + int m_MinCircleOneMMptCnt;//Сֵ(ԶĵСֵ) + + double m_AreaGridGap;//area ʾļmm + bool m_bShowObjNode;//Ƿobj Ľڵ + bool m_bDrawObjIdxCenter;//obj ֵʾ(false ڵһʾ) + + bool m_bNeedRedraw;//ǷҪػ + + int m_DlgMainWidth;//Ŀ + int m_DlgMainWidthNoteBook;//Ŀ(ʼDZ) + + COLORREF m_WaferSateColor1;//wafer ״̬ɫ + COLORREF m_WaferSateColor2;//wafer ״̬ɫ + COLORREF m_WaferSateColor3;//wafer ״̬ɫ + COLORREF m_WaferSateColor4;//wafer ״̬ɫ + COLORREF m_WaferSateColor5;//wafer ״̬ɫ + COLORREF m_WaferSateColor6;//wafer ״̬ɫ + COLORREF m_WaferSateColor7;//wafer ״̬ɫ + + + double m_LCD_Txt_LineW;//LCD ʾ߿ + + bool m_bDlgLayerViewShow;//ǷڶԻʾview +}; + +extern CGlobalDrawMgr *gDraw; \ No newline at end of file diff --git a/LaipuDrawing/GlobalFunction.cpp b/LaipuDrawing/GlobalFunction.cpp new file mode 100644 index 0000000..7b3f625 --- /dev/null +++ b/LaipuDrawing/GlobalFunction.cpp @@ -0,0 +1,1202 @@ +#include "StdAfx.h" +#include "GlobalFunction.h" +#include "PropertiesWnd.h" +#include "BitOperation.h" +#include "GlobalDrawMgr.h" +#include +#include "MsgBox.h" +#include "AllThreadMgr.h" +#include "WorkTime.h" +#include "FileMgr.h" +#include "WorkCmdInvoker.h" +#include "CStringFuc.h" + + +#if 1 +UINT RedrawViewByThread(LPVOID pParam) +{ + m_pView->RefreshView(); + return 0; +} +UINT NewMsgThread(LPVOID pParam) +{ + CMsgBox *pMsgBox = (CMsgBox *)pParam; + pMsgBox->ShowSetMsg(); + return 0; +} + + +//ȡǰָ +CLaiPuLaserView *GetCurViewPtr() +{ + CMainFrame *pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd(); + CChildFrame *pChild = (CChildFrame*)pFrame->GetActiveFrame(); + CLaiPuLaserView *pView = (CLaiPuLaserView*)pChild->GetActiveView(); + return pView; +} +//ȡǰļָ +CLaiPuLaserDoc *GetCurDocPtr() +{ + CLaiPuLaserView *pView = GetCurViewPtr(); + CLaiPuLaserDoc *pDoc = pView->GetDocument(); + return pDoc; +} +CMainFrame* GetFrame() +{ + CMainFrame* pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd(); + return pFrame; +} +//̵ͨ߳ķʽˢview +void RedrawViewByThread() +{ + AfxBeginThread(RedrawViewByThread,NULL); +} +#endif +#if 1//ηΧغ +//Ƿھ +bool IsPointInRect(Dbxy point,DbRect rect) +{ + if(point.x>= rect.L && point.x<=rect.R && point.y<= rect.T && point.y>=rect.B) + return true; + else + return false; +} +//Ƿཻ +bool IsTwoRectIntersect(DbRect &rect1,DbRect &rect2) +{ + if((((rect2.L>=rect1.L)&&(rect2.L<=rect1.R)) || ((rect2.R>=rect1.L)&&(rect2.R<=rect1.R))) && + (((rect2.T>=rect1.B)&&(rect2.T<=rect1.T)) || ((rect2.B>=rect1.B)&&(rect2.B<=rect1.T)))) + return true; + else + return false; +} +//жϵγɵֱǷܺrect ཻ +//Radius ֱߵһ볤mm +bool IsLineAndRectIntersect(Dbxy pt,DbRect rect,double Ang,double Radius) +{ + //ֱߵĶ˵ + Dbxy StartPt(Radius*(-1),pt.y); + Dbxy EndPt(Radius,pt.y); + StartPt = RotatoPt(StartPt,Ang,pt); + EndPt = RotatoPt(EndPt,Ang,pt); + + return IsLineInRect(StartPt,EndPt,rect); +} +//ж߶Ƿھ +bool IsLineInRect(Dbxy point1,Dbxy point2,DbRect rect) +{ + if(IsTwoLineIntersect(point1,point2,Dbxy(rect.R,rect.T),Dbxy(rect.L,rect.B))) + return true; + if(IsTwoLineIntersect(point1,point2,Dbxy(rect.L,rect.T),Dbxy(rect.R,rect.B))) + return true; + if(IsPointInRect(point1,rect) || IsPointInRect(point2,rect)) + return true; + return false; +} +void AdjustRange(double &min,double &max,double val) +{ + if(min>max)//һ + { + min = max = val; + } + else + { + if(min > val) + { + min = val; + } + if(max < val) + { + max = val; + } + } +} +//ȡݵı߽緶Χ +DbRect GetDbPointVecRect(vector &vec) +{ + DbRect rect; + vector::iterator iter = vec.begin(); + vector::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + AdjustRectByPoint(rect,(*iter)); + } + return rect; +} +DbRect GetDbPointVecRect(vector> &vec) +{ + DbRect rect; + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + vector::iterator iter1 = (*iter).begin(); + vector::iterator iter1_end = (*iter).end(); + for(;iter1!=iter1_end;iter1++) + { + AdjustRectByPoint(rect,(*iter1)); + } + } + return rect; +} +//һηΧ +void AdjustRectByPoint(DbRect &rect,Dbxy pt) +{ + AdjustRange(rect.L,rect.R,pt.x); + AdjustRange(rect.B,rect.T,pt.y); +} + +//һηΧ +void AdjustRectByRect(DbRect &rect1,DbRect rect2) +{ + Dbxy pt1(rect2.L,rect2.T); + Dbxy pt2(rect2.R,rect2.B); + AdjustRectByPoint(rect1,pt1); + AdjustRectByPoint(rect1,pt2); +} +#endif +#if 1//ж߶Ƿཻ +#define EPS 1e-8 +#define ZERO(x) (((x)>0?(x):-(x))EPS; +} + +//ֱƽ +int Parallel(Dbxy u1,Dbxy u2,Dbxy v1,Dbxy v2) +{ + return ZERO((u1.x-u2.x)*(v1.y-v2.y)-(v1.x-v2.x)*(u1.y-u2.y)); +} + +//㹲 +int dots_inline(Dbxy p1,Dbxy p2,Dbxy p3) +{ + return ZERO(xmult(p1,p2,p3)); +} +//߶Ƿཻ +int IsTwoLineIntersect(Dbxy u1,Dbxy u2,Dbxy v1,Dbxy v2) +{ + if (!dots_inline(u1,u2,v1)||!dots_inline(u1,u2,v2)) + return !same_side(u1,u2,v1,v2)&&!same_side(v1,v2,u1,u2); + return dot_online_in(u1,v1,v2)||dot_online_in(u2,v1,v2)||dot_online_in(v1,u1,u2)||dot_online_in(v2,u1,u2); +} +//߶εĽ +Dbxy CalIntersection(Dbxy u1,Dbxy u2,Dbxy v1,Dbxy v2) +{ + Dbxy ret=u1; + double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x))/((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x)); + ret.x+=(u2.x-u1.x)*t; + ret.y+=(u2.y-u1.y)*t; + return ret; +} +void IntersectionOfRectAndLineExt(bool &flg,Dbxy &pt1,Dbxy &pt2,Dbxy u1,Dbxy u2,Dbxy v1,Dbxy v2) +{ + if(IsTwoLineIntersect(u1,u2,v1,v2)) + { + //ཻ + Dbxy pt = CalIntersection(u1,u2,v1,v2); + if(flg) + { + pt1 = pt; + } + else + { + pt2 = pt; + } + flg =!flg; + } +} +//κ߶εĽ +Dbxy IntersectionOfRectAndLine(Dbxy LinePt1,Dbxy LinePt2,DbRect rect) +{ + bool flg = false;//ֱ浽1 ǵ2 + Dbxy pt1,pt2; + //߶κrect ߵĽ + { + Dbxy TmpPt1(rect.L,rect.T); + Dbxy TmpPt2(rect.L,rect.B); + IntersectionOfRectAndLineExt(flg,pt1,pt2,LinePt1,LinePt2,TmpPt1,TmpPt2); + } + { + Dbxy TmpPt1(rect.L,rect.B); + Dbxy TmpPt2(rect.R,rect.B); + IntersectionOfRectAndLineExt(flg,pt1,pt2,LinePt1,LinePt2,TmpPt1,TmpPt2); + } + { + Dbxy TmpPt1(rect.R,rect.B); + Dbxy TmpPt2(rect.R,rect.T); + IntersectionOfRectAndLineExt(flg,pt1,pt2,LinePt1,LinePt2,TmpPt1,TmpPt2); + } + { + Dbxy TmpPt1(rect.R,rect.T); + Dbxy TmpPt2(rect.L,rect.T); + IntersectionOfRectAndLineExt(flg,pt1,pt2,LinePt1,LinePt2,TmpPt1,TmpPt2); + } + //м + return CenterPtOfTwoPoint(pt1,pt2); +} +//мĵ +Dbxy CenterPtOfTwoPoint(Dbxy Pt1,Dbxy Pt2) +{ + Dbxy ret; + ret.x = (Pt1.x+Pt2.x)/2; + ret.y = (Pt1.y+Pt2.y)/2; + return ret; +} + +#endif +#if 1//㺯 +//нתΪ360 +double AngleTo360(double Angle) +{ + double _360Angle; + _360Angle = - Angle*180/PI; + //УΪֵ + if(_360Angle < 0) + { + _360Angle += 360; + } + if(_360Angle > 180) + { + _360Angle -= 360; + } + return _360Angle; +} +//360 תΪ(360=2л) +double _360ToAngle(double _360Angle) +{ + double Angle; + Angle = (_360Angle*PI)/180; + return Angle; +} + +//㷴нǶStartPt: תʼEndPt: תCenterPt: תĵ +double CalAngle(Dbxy CenterPt,Dbxy StartPt,Dbxy EndPt) +{ + double x2 = CenterPt.x; + double y2 = CenterPt.y; + double x1 = StartPt.x; + double y1 = StartPt.y; + double x3 = EndPt.x; + double y3 = EndPt.y; + + double flRlt,flAtanA,flAtanB; + //ĵʼת + if(x1==x2) + { + if(y1>y2) + { + flAtanA=PI/2; + }else if(y1y2) + { + flAtanB=PI/2; + }else if(y30&&x1-x2<0){ + flAtanA+=PI; + } + if(y1-y2<=0&&x1-x2<0){ + flAtanA+=PI; + } + if(y3-y2>0&&x3-x2<0){ + flAtanB+=PI; + } + if(y3-y2<=0&&x3-x2<0){ + flAtanB+=PI; + } + } + flRlt=flAtanB-flAtanA; + return flRlt*(-1); +} +//ͨ360 Ƚ +double Cal360AngleByTwoPt(Dbxy pt1,Dbxy pt2) +{ + Dbxy StartPt; + StartPt.x = CalDistance(pt1,pt2); + StartPt.y = pt1.y; + //ȼ㷴н + double angle = CalAngle(pt1,StartPt,pt2); + return AngleTo360(angle); +} +//תһ㣬תĵ +//Angle ǻȽǣCenterPt תĵ +Dbxy RotatoPt(Dbxy pt,double Angle,Dbxy CenterPt) +{ + Dbxy ret; + //ת----------------------------------------------- + ret.x = ((pt.x-CenterPt.x)*cos(Angle)-(pt.y-CenterPt.y)*sin(Angle))+CenterPt.x; + ret.y = ((pt.y-CenterPt.y)*cos(Angle)+(pt.x-CenterPt.x)*sin(Angle))+CenterPt.y; + return ret; +} +//ݵһ,߶εij,Ƕȼ߶εڶ +//angle ǻȽ +Dbxy GetPoint2(Dbxy point1,double length,double angle) +{ + Dbxy point2; + point2.x = point1.x+length*cos(angle); + point2.y = point1.y+length*sin(angle); + return point2; +} +#endif +#if 1 +//жdouble Ƿ +bool IsTwoDbEqual(double a,double b) +{ + if((abs(a-b))<=COORD_EPS) + return true; + else + return false; +} +bool IsTwoDbEqual(double a,double b,double eps) +{ + if((abs(a-b))<=eps) + return true; + else + return false; +} +bool IsTwoPtEqual(Dbxy pt1,Dbxy pt2,double eps) +{ + return IsTwoDbEqual(pt1.x,pt2.x,eps) && IsTwoDbEqual(pt1.y,pt2.y,eps); +} +bool IsDbEqualZero(double num) +{ + if(num<0) + { + num *= -1; + } + if(num <= COORD_EPS) + return true; + else + return false; +} +bool IsDbxyZero(Dbxy pt) +{ + return IsDbEqualZero(pt.x) && IsDbEqualZero(pt.y); +} +void SwapTwoPt(Dbxy &pt1,Dbxy &pt2) +{ + Dbxy pt = pt1; + pt1 = pt2; + pt2 = pt; +} +//֮ľ(ɶ:Z^2 = X^2 + Y^2) +//ֵ϶Ǵ0 +double CalDistance(Dbxy pt1,Dbxy pt2) +{ + double flRlt; + flRlt=(pt1.x-pt2.x)*(pt1.x-pt2.x)+(pt1.y-pt2.y)*(pt1.y-pt2.y); + flRlt=sqrt(flRlt); + return flRlt; +} +//num мλ +int GetNumDigit(int num) +{ + int cnt = 0; + while(num) + { + num /=10; + cnt++; + } + if(cnt==0)//һλ + cnt = 1; + return cnt; +} + +#endif +#if 1 +bool CheckStringIsNum(CString str) +{ + CString strSet1 = "qwertyuiopasdfghjklzxcvbnm"; + CString strSet2 = "QWERTYUIOPASDFGHJKLZXCVBNM"; + CString strSet3 = "!@#$%^&*()_+=[]\\{}|;':\",/<>?"; + CString strSet = strSet1+strSet2+strSet3; + if(str.FindOneOf(strSet)==-1) + { + return true; + } + return false; +} +//str ȡֵ(123.456,789.123) +//ȡVal1 1,ͬʱȡVal1,Val2 2 +//һûȡ0 +int GetTwoNum(CString str,double &Val1,double &Val2) +{ + int CommaPos = 0; + //Ƿж + CommaPos = str.Find(',',0); + if(CommaPos!=-1) + { + CString str1(str,CommaPos); + str.Delete(0,CommaPos+1); + CString str2(str); + if(CheckStringIsNum(str1)&&CheckStringIsNum(str2)) + { + Val1 = atof(str1); + Val2 = atof(str2); + return 2; + } + } + else + { + if(CheckStringIsNum(str)) + { + Val1 = atof(str); + return 1; + } + } + return 0; +} +#endif +#if 1// +//ͨx +bool CompareDbxyByX(Dbxy pt1,Dbxy pt2) +{ + return pt1.x>pt2.x; +} +bool CompareDbxyByY(Dbxy pt1,Dbxy pt2) +{ + return pt1.y>pt2.y; +} +#endif +#if 1 +//жshift Ƿ +bool IsShiftKeyDown() +{ + if((GetAsyncKeyState(VK_SHIFT)&0x8000)&&(GetAsyncKeyState(VK_CONTROL)&0x8000)) + return true; + else + return false; +} +//ģ(CoordX,CoordYĻ) +void MouseLeftBtnClick(int CoordX,int CoordY,bool bDbClick) +{ + SetCursorPos(CoordX,CoordY);//ƶλ + mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,NULL);//down¼ + mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,NULL);//up¼ + if(bDbClick)//˫ + { + mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,NULL);//down¼ + mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,NULL);//up¼ + } +} +//ȡlist ǰѡк +int GetCurListIdx(CListCtrl &list) +{ + POSITION pos = list.GetFirstSelectedItemPosition(); + if(pos == NULL) + { + return -1; + } + else + { + while (pos) + { + int nItem = list.GetNextSelectedItem(pos); + return nItem; + } + } + return -1; +} +#endif +#if 1 +int Byte2Int(BYTE x) +{ + BYTE c = 0x80; + int a = (IsBitOn(x,7))?c:0; + x = SetBitOff(x,7); + return x+a; +} +//double Сn λ +double RetainDecimalPlaces(double val,int n) +{ + for(int i=0;i=0 && n<=15) +char Int2HexChar(int n) +{ + char c = '0'; + if(n>=0 && n<= 9) + c = '0' + n; + else if(n>=10 && n<= 15) + c = 'A' + n - 10; + return c; +} +//16Ƶchar תΪʮ +int HexChar2Int(char c) +{ + int val = 0; + if(c>='0' && c<='9') + val = (c - '0'); + else if(c>='A' && c<='F') + val = (c - 'A') + 10; + else if(c>='a' && c<='f') + val = (c - 'a') + 10; + return val; +} +//ֽڵ16 תΪʮ(0707 ---->17991179---->4473) +double _4DigitHex2Double(char *buf,int len) +{ + double Sum = 0; + for(int k=0;k15) +int TwoCharHexStringToInt(CString str) +{ + int Val = 0; + if(str.GetLength()>=2) + { + char *buf = CStringToLPCSTR(str); + Val = _2CharToHex(buf[0],buf[1]); + } + return Val; +} +//13 88--->5000 20 08--->8200 +int HexByte2Int(int Byte1,int Byte2) +{ + int Byte4 = Byte1%16; + int Byte3 = (Byte1-Byte4)/16; + int Byte6 = Byte2%16; + int Byte5 = (Byte2-Byte6)/16; + + int val =0; + val = (Byte3)*16*16*16+(Byte4)*16*16+(Byte5)*16+(Byte6); + return val; +} +//10C3E4(ʮ)--->1098724(ʮ) +//Byte3 λByte2 λByte1 λ +double _3HexByteToDouble(unsigned int ByteH,unsigned int ByteM,unsigned int ByteL) +{ + unsigned int Byte4 = ByteH%16; + unsigned int Byte3 = (ByteH-Byte4)/16; + + unsigned int Byte6 = ByteM%16; + unsigned int Byte5 = (ByteM-Byte6)/16; + + unsigned int Byte7 = ByteL%16; + unsigned int Byte8 = (ByteL-Byte7)/16; + + double val =0; + val = (Byte3)*16*16*16*16*16+(Byte4)*16*16*16*16+(Byte5)*16*16*16+(Byte6)*16*16+(Byte8)*16 + (Byte7); + return val; +} +double _4HexByteToDouble(unsigned int HexByte1,unsigned int HexByte2,unsigned int HexByte3,unsigned int HexByte4) +{ + unsigned int Byte7 = HexByte1%16; + unsigned int Byte8 = (HexByte1-Byte7)/16; + + unsigned int Byte5 = HexByte2%16; + unsigned int Byte6 = (HexByte2-Byte5)/16; + + unsigned int Byte3 = HexByte3%16; + unsigned int Byte4 = (HexByte3-Byte3)/16; + + unsigned int Byte1 = HexByte4%16; + unsigned int Byte2 = (HexByte4-Byte1)/16; + + double val =0; + val += (Byte1); + val += (Byte2)*16; + val += (Byte3)*16*16; + val += (Byte4)*16*16*16; + val += (Byte5)*16*16*16*16; + val += (Byte6)*16*16*16*16*16; + val += (Byte7)*16*16*16*16*16*16; + val += (Byte8)*16*16*16*16*16*16*16; + return val; +} +//ַתΪ16 +//charA = 'B' ,charB = 'F' תΪ 0xBF (ʮ191) +int _2CharToHex(char charA,char charB) +{ + int a = HexChar2Int(charA); + int b = HexChar2Int(charB); + return a*16 + b; +} +/*תΪ2 ֽ16 +500016 Ϊ0x1388 ,ת +buf[0] = 0x13 +buf[1] = 0x88 +*/ +void IntTo2ByteHex(int n,char *buf) +{ + char TmpBuf[128]; + memset(TmpBuf,0,128); + //5000->"1388" + itoa(n,TmpBuf,16); + int len = strlen(TmpBuf); + char CharBuf4[4]; + memset(CharBuf4,0,4); + int idx = 3; + while(len>0 && idx>=0) + { + CharBuf4[idx] = TmpBuf[len-1];//TmpBuf ĺ漸λ + len--; + idx--; + } + buf[0] = _2CharToHex(CharBuf4[0],CharBuf4[1]);//0x13 + buf[1] = _2CharToHex(CharBuf4[2],CharBuf4[3]);//0x88 +} +//5000->"1388" תΪֽڵ16asc ַ +CString IntTo4ByteHexStr(int n) +{ + CString ValStr = "0000"; + char *CharBuf = CStringToLPCSTR(ValStr); + char TmpBuf[128]; + memset(TmpBuf,0,128); + //int --> char (16) + itoa(n,TmpBuf,16);//ñ׼ + int len = strlen(TmpBuf); + int idx = 3; + while(len>0 && idx>=0) + { + CharBuf[idx] = TmpBuf[len-1];//TmpBuf ĺ漸λ + len--; + idx--; + } + //תɴдַ + ValStr.MakeUpper(); + return ValStr; +} +//500000->"07 A1 20" תΪֽڵ16asc ַ +CString IntTo6ByteHexStr(int n) +{ + CString ValStr = "000000"; + char *CharBuf = CStringToLPCSTR(ValStr); + char TmpBuf[128]; + memset(TmpBuf,0,128); + //int --> char (16) + itoa(n,TmpBuf,16);//ñ׼ + int len = strlen(TmpBuf); + int idx = 5; + while(len>0 && idx>=0) + { + CharBuf[idx] = TmpBuf[len-1];//TmpBuf ĺ漸λ + len--; + idx--; + } + //תɴдַ + ValStr.MakeUpper(); + return ValStr; +} + +CString IntTo8ByteHexStr(int n) +{ + CString ValStr = "00000000"; + char *CharBuf = CStringToLPCSTR(ValStr); + char TmpBuf[128]; + memset(TmpBuf,0,128); + //int --> char (16) + itoa(n,TmpBuf,16);//ñ׼ + int len = strlen(TmpBuf); + int idx = 7; + while(len>0 && idx>=0) + { + CharBuf[idx] = TmpBuf[len-1];//TmpBuf ĺ漸λ + len--; + idx--; + } + //תɴдַ + ValStr.MakeUpper(); + return ValStr; +} +//ByteLow 8λ,ByteHigh 8λ +int TwoByte2Int(BYTE ByteLow,BYTE ByteHigh) +{ + int val = 0; + //ByteLow 8λ + for(int k=0;k<8;k++) + { + if(IsBitOn(ByteLow,k)) + SetIntBitOn(val,k); + } + //ByteHigh 8λ + for(int k=0;k<8;k++) + { + if(IsBitOn(ByteHigh,k)) + SetIntBitOn(val,k+8); + } + return val; +} +//ȡint 0~7 λ8~15λ +BYTE Int2Byte(int Val,bool bByteLow) +{ + BYTE Byte = 0; + int Start=(bByteLow)?0:8; + for(int k=0;k<8;k++) + { + if((Val>>(k+Start))&1) + { + Byte= Byte |(1<m_hThread,FALSE,INFINITE,QS_ALLINPUT); + if (dRet == WAIT_OBJECT_0)//ȴ߳̽ + { + break; + } + else if (dRet == WAIT_OBJECT_0+1)//Ϣ,ת + { + while (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + } + else// + { + break; + } + } +} +//bool b Ϊֵ,ؼǷͨ +bool CheckBool(bool b,CString msg) +{ + if(!b) + { + CMsgBox MsgBox; + MsgBox.Show(msg); + return false; + } + return true; +} +//n ķΧ[Start,end] +bool CheckRange(int n,int Start,int end) +{ + return n>=Start && n<=end; +} +bool CheckRangeDb(double n,double Start,double end) +{ + return n>=Start && n<=end; +} +bool CheckParRangeDb(CString ParName,double n,double Start,double end) +{ + if(!CheckRangeDb(n,Start,end)) + { + CString s1,s2; + s1 += "["; + s1 += ParName; + s1 += "]Χ:"; + s2.Format("[%.3f]~[%.3f]",Start,end); + s1 += s2; + CMsgBox MsgBox; + MsgBox.Show(s1); + return false; + } + return true; +} +//ͨCirclePar ԲݵVec +void CreatCircleData(CCirclePar CirclePar,vector &Vec) +{ + Dbxy CenterPt = CirclePar.CenterPt; + double Radius = CirclePar.Radius; + int DEdgeCnt = CirclePar.DEdgeCnt; + bool bMerge = CirclePar.bMerge; + double StartAng = CirclePar.StartAng; + double EndAng = CirclePar.EndAng; + + if(DEdgeCnt == 0) + { + DEdgeCnt = gDraw->GetCirclePtCnt(Radius); + } + //뾶------------------------------------ + double EachAngle = 360/DEdgeCnt; + bool Flg = true;//һı־ + double CurrAngle =StartAng; + + Dbxy pt; + Dbxy FirstPt; + bool bLastPt = false; + + vector VecTmp; + while(CurrAngle<(EndAng+0.001)) + { + //ǶתΪ + double radian = CurrAngle*PI/180; + if(IsDbEqualZero(Radius))//뾶Ϊ0 Ϊ + { + pt = CenterPt; + } + else + { + pt.x = CenterPt.x + Radius*cos(radian); + pt.y = CenterPt.y + Radius*sin(radian); + } + + if(Flg) + { + Flg = false; + FirstPt = pt; + VecTmp.push_back(pt); + } + else + { + VecTmp.push_back(pt); + } + if(bLastPt) + break; + + CurrAngle += EachAngle; + if(CurrAngle>EndAng)//һ + { + CurrAngle = EndAng; + bLastPt = true; + } + } + //һ߶ + if(bMerge) + { + VecTmp.push_back(FirstPt); + } + + if(CirclePar.bReverse) + { + vector::iterator iter = VecTmp.begin(); + vector::iterator iter_end = VecTmp.end(); + reverse(iter,iter_end); + } + vector::iterator iter = VecTmp.begin(); + vector::iterator iter_end = VecTmp.end(); + for(;iter!=iter_end;iter++) + { + Dbxy pt = *iter; + pt.Cx = CenterPt.x;//ԲϢ + pt.Cy = CenterPt.y; + pt.bArc = true; + pt.bDir = CirclePar.bReverse;//Բķ(˳ʱʱ) + Vec.push_back(pt); + } +} + +//Բķ +bool GetArcDir(vector &PtVec,Dbxy CenterPt) +{ + int size = PtVec.size(); + if(size>3) + { + Dbxy pt1 = PtVec[0]; + Dbxy pt2 = PtVec[size/2]; + Dbxy pt3 = PtVec[size-1]; + if(((pt2.x-pt1.x)*(pt3.y-pt2.y)-(pt2.y-pt1.y)*(pt3.x-pt2.x))<0) + return true; + else + return false; + } + return true; +} +//΢뼶ʱusΪ΢ +void ExactDelay(unsigned int us) +{ + if(us>0) + { + LARGE_INTEGER ClockFre; + QueryPerformanceFrequency(&ClockFre); + + LARGE_INTEGER start, end; + LONGLONG count = (us*ClockFre.QuadPart)/(1000*1000); + QueryPerformanceCounter(&start); + count = count + start.QuadPart ; + do + { + QueryPerformanceCounter(&end); + }while(end.QuadPart &DlgItemStrVec) +{ + int size = DlgItemStrVec.size(); + for(int k=0;k YearPathVec; + //ȡǰ· + CFileMgr FileMgr; + FileMgr.GetChildFileOrDirName(true,FilePath,YearPathVec,""); + CString ThisYear = WorkTime.GetCurYear(); + int size = YearPathVec.size(); + if(size<1)// + { + ComboBox.InsertString(0,ThisYear); + ComboBox.SetCurSel(0); + return; + } + int SelIdx = 0; + for(int k=0;kGetItemCount(); + + // Delete all of the columns. + for (int i=0; i < nColumnCount; i++) + { + List.DeleteColumn(0); + } +} +//ȴָʱms(ⳤʱSleepʱ) +bool WaitDelayTime(int DelayTime) +{ + int TotalDelay = DelayTime;//ܹȴʱms + int CheckDelay = 300;//ÿѭʱ + int CurDelay = 0;//ǰʱ + while(1) + { + if(gStopAllWrokCmd) + { + return false; + } + Sleep(CheckDelay); + CurDelay += CheckDelay; + if(CurDelay>TotalDelay)//ʱ䵽 + break; + } + return true; +} +//MFC CString תΪC++ string +//ҪʹCString GetBuffer ڴй©ķ +char* CStringToLPCSTR(CString s) +{ + return (char*)(LPCTSTR)s; +} +/* +//DirPath = E:\\LaipuLaserData\\ParaModifyRecord\\ +//-->E:\\LaipuLaserData\\ParaModifyRecord\\2022\\01\\19\\ +*/ +//ǰʱĿ¼ +CString CreatDataTimePath(CString DirPath) +{ + CString Path = DirPath; + CFileMgr FileMgr; + CWorkTime WorkTime; + Path += WorkTime.GetCurYear(); + Path += "\\"+WorkTime.GetCurMonth(); + Path += "\\"+WorkTime.GetCurDay(); + Path += "\\"; + if(!FileMgr.IsDirectoryExists(Path)) + { + FileMgr.CreatDir(Path); + } + return Path; +} + diff --git a/LaipuDrawing/GlobalFunction.h b/LaipuDrawing/GlobalFunction.h new file mode 100644 index 0000000..43d66e7 --- /dev/null +++ b/LaipuDrawing/GlobalFunction.h @@ -0,0 +1,89 @@ +#pragma once + +#include "LaiPuLaserView.h" +#include "MainFrm.h" +#include "ChildFrm.h" +#include "LaiPuLaserDoc.h" +#include "Layer.h" + +extern CLaiPuLaserView *GetCurViewPtr(); +extern CLaiPuLaserDoc *GetCurDocPtr(); +extern int IsTwoLineIntersect(Dbxy u1,Dbxy u2,Dbxy v1,Dbxy v2); +extern bool IsTwoRectIntersect(DbRect &rect1,DbRect &rect2); +extern bool IsLineInRect(Dbxy point1,Dbxy point2,DbRect rect); +extern bool IsPointInRect(Dbxy point,DbRect rect); +extern int Parallel(Dbxy u1,Dbxy u2,Dbxy v1,Dbxy v2); +extern double CalAngle(Dbxy CenterPt,Dbxy StartPt,Dbxy EndPt); +extern void AdjustRectByPoint(DbRect &rect,Dbxy pt); +extern void AdjustRectByRect(DbRect &rect1,DbRect rect2); +extern void AdjustRange(double &min,double &max,double val); +extern bool IsTwoDbEqual(double a,double b);//COORD_EPS ĬϾ +extern bool IsTwoDbEqual(double a,double b,double eps); +extern bool IsDbEqualZero(double num); +extern double CalDistance(Dbxy pt1,Dbxy pt2); +extern double AngleTo360(double Angle); +extern double _360ToAngle(double _360Angle); +extern CMainFrame* GetFrame(); +extern int GetTwoNum(CString str,double &Val1,double &Val2); +extern double Cal360AngleByTwoPt(Dbxy pt1,Dbxy pt2); +extern Dbxy GetPoint2(Dbxy point1,double length,double angle); +extern Dbxy CalIntersection(Dbxy u1,Dbxy u2,Dbxy v1,Dbxy v2); +extern Dbxy IntersectionOfRectAndLine(Dbxy LinePt1,Dbxy LinePt2,DbRect rect); +extern Dbxy CenterPtOfTwoPoint(Dbxy Pt1,Dbxy Pt2); +extern int GetNumDigit(int num); +extern Dbxy RotatoPt(Dbxy pt,double Angle,Dbxy CenterPt); +extern DbRect GetDbPointVecRect(vector &vec); +extern void SwapTwoPt(Dbxy &pt1,Dbxy &pt2); +extern bool IsShiftKeyDown(); +extern bool CompareDbxyByX(Dbxy pt1,Dbxy pt2); +extern bool CompareDbxyByY(Dbxy pt1,Dbxy pt2); +extern int dot_online_in(Dbxy p,Dbxy l1,Dbxy l2); +extern bool IsDbxyZero(Dbxy pt); +extern int Byte2Int(BYTE x); +extern double RetainDecimalPlaces(double val,int n); +extern int GetRandVal(int rang); +extern bool IsLineAndRectIntersect(Dbxy pt,DbRect rect,double Ang,double Radius=500); +extern void WaitForThreadExit(CWinThread* pThread); +extern bool CheckBool(bool b,CString msg); +extern void CreatCircleData(CCirclePar CirclePar,vector &Vec); +extern bool CheckRange(int n,int Start,int end); +extern DbRect GetDbPointVecRect(vector> &vec); +extern char Int2HexChar(int n); +extern bool GetArcDir(vector &PtVec,Dbxy CenterPt); +extern bool IsTwoPtEqual(Dbxy pt1,Dbxy pt2,double eps); +extern void ExactDelay(unsigned int us); +extern int Ms2Us(int ms); +extern double _4DigitHex2Double(char *buf,int len); +extern int HexChar2Int(char c); +extern void IntTo2ByteHex(int n,char *buf); +extern int _2CharToHex(char charA,char charB); +extern double _3HexByteToDouble(unsigned int ByteH,unsigned int ByteM,unsigned int ByteL); +extern double _4HexByteToDouble(unsigned int HexByte1,unsigned int HexByte2,unsigned int HexByte3,unsigned int HexByte4); +extern int HexByte2Int(int Byte1,int Byte2); +extern int MM2UM(double mm); +extern double UM2MM(int um); +extern double D_UM2MM(double um); +extern void MouseLeftBtnClick(int CoordX,int CoordY,bool bDbClick=false); +extern CString IntTo4ByteHexStr(int n); +extern int TwoCharHexStringToInt(CString str); +extern CString IntTo6ByteHexStr(int n); +extern CString IntTo8ByteHexStr(int n); +extern bool CheckRangeDb(double n,double Start,double end); +extern CCirclePar CalCircleByThreePt(Dbxy Pt1,Dbxy Pt2,Dbxy Pt3); +extern void RedrawViewByThread(); +extern int GetCurListIdx(CListCtrl &list); +extern bool CheckParRangeDb(CString ParName,double n,double Start,double end); +extern bool IsDlgItemStrChange(int ID,CString Str,vector &DlgItemStrVec); +extern bool SendMsgToWnd(CString &WndName,CString &WndMsg); +extern bool IsWndExist(CString WndName); +extern int TwoByte2Int(BYTE ByteLow,BYTE ByteHigh); +extern BYTE Int2Byte(int Val,bool bByteLow); +extern void ShowMsgInNewThread(CString s); +extern BOOL PictureWindows(const CString &strPicFile); +extern void InitYearComb(CString FilePath,CComboBox &ComboBox); +extern void InitMonthComb(CComboBox &ComboBox); +extern void ResetListCtrl(CListCtrl &List); +extern bool WaitDelayTime(int DelayTime); +extern void SendComLogToWnd(bool bSend,CString WndName,CString Msg); +extern char* CStringToLPCSTR(CString s); +extern CString CreatDataTimePath(CString DirPath); \ No newline at end of file diff --git a/LaipuDrawing/KernelMode.h b/LaipuDrawing/KernelMode.h new file mode 100644 index 0000000..41c978d --- /dev/null +++ b/LaipuDrawing/KernelMode.h @@ -0,0 +1,27 @@ +// ifdef Ǵʹ DLL 򵥵 +// ı׼ DLL еļ϶ KERNELMODE_EXPORTS +// űġʹô DLL +// κĿϲӦ˷šԴļаļκĿὫ +// KERNELMODE_API ΪǴ DLL ģ DLL ô˺궨 +// ΪDZġ + +#pragma once + + +#ifdef KERNELMODE_EXPORTS +#define KERNELMODE_API __declspec(dllexport) +#else +#define KERNELMODE_API __declspec(dllimport) +#endif + +// Ǵ KernelMode.dll +class KERNELMODE_API CKernelMode { +public: + CKernelMode(void); + int CheckState(); + void GetDogTime(int *DogYear,int *DogMonth,int *DogDay); +}; + +extern KERNELMODE_API int nKernelMode; + +KERNELMODE_API int fnKernelMode(void); diff --git a/LaipuDrawing/KernelMode.lib b/LaipuDrawing/KernelMode.lib new file mode 100644 index 0000000..ddf826a Binary files /dev/null and b/LaipuDrawing/KernelMode.lib differ diff --git a/LaipuDrawing/LabVecRang.h b/LaipuDrawing/LabVecRang.h new file mode 100644 index 0000000..67ba3d0 --- /dev/null +++ b/LaipuDrawing/LabVecRang.h @@ -0,0 +1,136 @@ +#pragma once +#include "GlobalDefine.h" +#include "WorkFileLable.h" + +//洢ݵ +enum VAL_TYPE +{ + _TYPE_NULL = 0,//ʾ + _TYPE_INT, + _TYPE_DOUBLE, + _TYPE_STRING, + _TYPE_BOOL, +}; + +//һڴ洢ıǩ +class CLab +{ +public: + CLab() + { + m_ValType = _TYPE_NULL; + }; + CLab(LAB_TYPE LabType) + { + m_ValType = _TYPE_NULL; + m_LabType = LabType; + }; + CLab(LAB_TYPE LabType,int val) + { + m_ValType = _TYPE_INT; + m_LabType = LabType; + m_Int = val; + }; + CLab(LAB_TYPE LabType,double val) + { + m_ValType = _TYPE_DOUBLE; + m_LabType = LabType; + m_Double = val; + }; + CLab(LAB_TYPE LabType,bool val) + { + m_ValType = _TYPE_BOOL; + m_LabType = LabType; + m_Bool = val; + }; + CLab(LAB_TYPE LabType,CString val) + { + m_ValType = _TYPE_STRING; + m_LabType = LabType; + m_String = val; + }; + ~CLab(void){}; + void Serialize( CArchive& ar) + { + if(ar.IsStoring()) + { + ar<<(int)m_ValType;//ݵ + ar<<(int)m_LabType;//ǩ + switch(m_ValType)//ݵѡ洢 + { + case _TYPE_INT: + ar<>tmp;//ݵ + m_ValType = (VAL_TYPE)tmp; + ar>>tmp;//ǩ + m_LabType = (LAB_TYPE)tmp; + switch(m_ValType)//ݵѡ洢 + { + case _TYPE_INT: + ar>>m_Int; + break; + case _TYPE_DOUBLE: + ar>>m_Double; + break; + case _TYPE_BOOL: + ar>>m_Bool; + break; + case _TYPE_STRING: + ar>>m_String; + break; + default: + break; + } + } + } +public: + VAL_TYPE m_ValType;//ݵ + LAB_TYPE m_LabType;//ǩ + + int m_Int;//ڴ洢 + double m_Double;//ڴ洢˫ + bool m_Bool;//ڴ洢 + CString m_String; +}; + + +//vector һηΧĿӶȡļ㷨ٶ +class CLabVecRang +{ +public: + CLabVecRang(vector &vec,size_t start,size_t End) + :m_vec(vec),m_start(start),m_End(End) + { + + }; + ~CLabVecRang(void){}; + int GetStart(){return m_start;} + int GetEnd(){return m_End;} + CLab &GetLab(int idx){return m_vec[idx];}; + LAB_TYPE GetLabType(int idx){return m_vec[idx].m_LabType;}; + int GetInt(int idx){return m_vec[idx].m_Int;}; + double GetDouble(int idx){return m_vec[idx].m_Double;}; + bool GetBool(int idx){return m_vec[idx].m_Bool;}; + vector &GetVec(){return m_vec;}; +private: + vector &m_vec; + size_t m_start; + size_t m_End; +}; diff --git a/LaipuDrawing/LabelEx.cpp b/LaipuDrawing/LabelEx.cpp new file mode 100644 index 0000000..787ce42 --- /dev/null +++ b/LaipuDrawing/LabelEx.cpp @@ -0,0 +1,296 @@ +// LabelEx.cpp : implementation file +// + +#include "stdafx.h" +#include "LabelEx.h" +#include "GlobalDefine.h" + + + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CLabelEx + +CLabelEx::CLabelEx() +{ + m_bClicked=FALSE; + m_bOver=FALSE; + m_bUnderLine=FALSE; + m_bAutoUnderLine=FALSE; + m_bBorder=FALSE; + m_bHighLight=TRUE; + m_bBackUnderLine=FALSE; + + m_crText=RGB(0,0,0); + m_crBorder=RGB(0,0,0); + m_crBG=RGB(255,255,255); + m_crUnderLine=RGB(0,0,255); + + m_hHandCur=AfxGetApp()->LoadCursor(IDC_HAND); + + SetTextColor(RGB_RED); + SetBkColor(RGB_GRAY); + + m_CurBmpID = 0; + } + +CLabelEx::~CLabelEx() +{ + if(m_BGBm.GetSafeHandle()!=NULL) + m_BGBm.DeleteObject(); + if(m_MouseOverBGBm.GetSafeHandle()!=NULL) + m_MouseOverBGBm.DeleteObject(); + if(m_ClickedBGBm.GetSafeHandle()!=NULL) + m_ClickedBGBm.DeleteObject(); + if(m_LabelBm.GetSafeHandle()!=NULL) + m_LabelBm.DeleteObject(); + if(m_MouseOverLabelBm.GetSafeHandle()!=NULL) + m_MouseOverLabelBm.DeleteObject(); + if(m_ClickedLabelBm.GetSafeHandle()!=NULL) + m_ClickedLabelBm.DeleteObject(); +} + + +BEGIN_MESSAGE_MAP(CLabelEx, CStatic) + //{{AFX_MSG_MAP(CLabelEx) + ON_WM_PAINT() + ON_WM_MOUSEMOVE() + ON_WM_LBUTTONDOWN() + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CLabelEx message handlers + +void CLabelEx::OnPaint() +{ + CPaintDC dc(this); // device context for painting + dc.SetTextColor(m_crText); + dc.SetBkMode(TRANSPARENT); + dc.SelectObject(this->GetFont()); + ///׼ + CRect rect; + CDC MemDC; + CPen BorderPen,*pOldPen,UnderLinePen; + CBrush BGBrush,*pOldBrush; + BITMAP bm; + + this->GetClientRect(&rect); + + MemDC.CreateCompatibleDC(&dc); + MemDC.SetMapMode(dc.GetMapMode()); + + ///߿ + if(m_bBorder) + { + BorderPen.CreatePen(PS_SOLID,1,m_crBorder); + BGBrush.CreateSolidBrush(m_crBG); + + pOldPen=dc.SelectObject(&BorderPen); + pOldBrush=dc.SelectObject(&BGBrush); + + dc.Rectangle(&rect); + + dc.SelectObject(pOldPen); + dc.SelectObject(pOldBrush); + + rect.DeflateRect(1,1); + } + ///ͼ + if(m_bClicked && m_ClickedBGBm.GetSafeHandle()!=NULL) + { + MemDC.SelectObject(m_ClickedBGBm); + dc.BitBlt(rect.left,rect.top,rect.Width(),rect.Height(), + &MemDC,0,0,SRCCOPY); + } + else if(m_bOver && m_MouseOverBGBm.GetSafeHandle()!=NULL)//꾭ʱ + { + MemDC.SelectObject(m_MouseOverBGBm); + dc.BitBlt(rect.left,rect.top,rect.Width(),rect.Height(), + &MemDC,0,0,SRCCOPY); + } + else if(m_BGBm.GetSafeHandle()!=NULL) + { + MemDC.SelectObject(m_BGBm); + dc.BitBlt(rect.left,rect.top,rect.Width(),rect.Height(), + &MemDC,0,0,SRCCOPY); + } + ///ǩͼƬ + if(m_bClicked && m_ClickedLabelBm.GetSafeHandle()!=NULL) + { + m_ClickedLabelBm.GetBitmap(&bm); + double fScal=bm.bmWidth*1.0/bm.bmHeight; + MemDC.SelectObject(m_ClickedLabelBm); + dc.StretchBlt(rect.left,rect.top,int(rect.Height()*fScal),rect.Height(), + &MemDC,0,0,bm.bmWidth,bm.bmHeight,SRCCOPY); + } + else if(m_bOver && m_MouseOverLabelBm.GetSafeHandle()!=NULL) + { + m_MouseOverLabelBm.GetBitmap(&bm); + double fScal=bm.bmWidth*1.0/bm.bmHeight; + MemDC.SelectObject(m_MouseOverLabelBm); + dc.StretchBlt(rect.left,rect.top,int(rect.Height()*fScal),rect.Height(), + &MemDC,0,0,bm.bmWidth,bm.bmHeight,SRCCOPY); + } + else if(m_LabelBm.GetSafeHandle()!=NULL) + { + m_LabelBm.GetBitmap(&bm); + double fScal=bm.bmWidth*1.0/bm.bmHeight; + MemDC.SelectObject(m_LabelBm); + dc.StretchBlt(rect.left,rect.top,int(rect.Height()*fScal),rect.Height(), + &MemDC,0,0,bm.bmWidth,bm.bmHeight,SRCCOPY); + } + + /// + TEXTMETRIC tm; + dc.GetTextMetrics(&tm); + CString strText1 = m_CurText1; + CString strText2 = m_CurText2; + if(strText1.GetLength()>0) + { + CRect TextRect = rect; + int AdjustPos = -8; + TextRect.bottom += AdjustPos; + TextRect.top += AdjustPos; + dc.DrawText(strText1, -1, &TextRect, DT_SINGLELINE| DT_VCENTER | DT_CENTER); + } + if(strText2.GetLength()>0) + { + CRect TextRect = rect; + int AdjustPos = 12; + TextRect.bottom += AdjustPos; + TextRect.top += AdjustPos; + dc.DrawText(strText2, -1, &TextRect, DT_SINGLELINE| DT_VCENTER | DT_CENTER); + } +} + +void CLabelEx::PreSubclassWindow() +{ + // TODO: Add your specialized code here and/or call the base class + DWORD dwStyle = GetStyle(); + ::SetWindowLong(GetSafeHwnd(), GWL_STYLE, dwStyle | SS_NOTIFY); + + SetFont(GetParent()->GetFont()); + CStatic::PreSubclassWindow(); +} +void CLabelEx::SetTextColor(COLORREF crText) +{ + m_crText=crText; +} + +void CLabelEx::SetUnderLine(BOOL bUnderLine, COLORREF crUnderLine) +{ + m_bUnderLine=bUnderLine; + m_crUnderLine=crUnderLine; + +} + +void CLabelEx::SetBorder(BOOL bBorder, COLORREF crBorder) +{ + m_bBorder=bBorder; + m_crBorder=crBorder; +} + +void CLabelEx::SetBkColor(COLORREF crBkColor) +{ + m_crBG=crBkColor; + +} + +void CLabelEx::EnableAutoUnderLine(BOOL bAutoUnderLine) +{ + m_bAutoUnderLine=bAutoUnderLine; + if(m_bAutoUnderLine) ///Զ» + { + m_bBackUnderLine=m_bUnderLine;//ԭ»ߵ״̬ + m_bUnderLine=FALSE; + } + else ///ȡԶ» + { + m_bUnderLine=m_bBackUnderLine;//ظԭ»ߵ״̬ + } +} + +void CLabelEx::RedrawWindow() +{ + CStatic::RedrawWindow(); + //RECT rect; + //this->GetWindowRect(&rect); + //GetParent()->ScreenToClient(&rect); + //GetParent()->InvalidateRect(&rect); +} + +void CLabelEx::SetBGBitmap(UINT ID) +{ + if(m_BGBm.GetSafeHandle()!=NULL) + m_BGBm.DeleteObject(); + m_BGBm.LoadBitmap(ID); + +} + +void CLabelEx::SetMouseOverBGBitmap(UINT ID) +{ + if(m_MouseOverBGBm.GetSafeHandle()!=NULL) + m_MouseOverBGBm.DeleteObject(); + m_MouseOverBGBm.LoadBitmap(ID); +} + +void CLabelEx::SetClickedBGBitmap(UINT ID) +{ + if(m_ClickedBGBm.GetSafeHandle()!=NULL) + m_ClickedBGBm.DeleteObject(); + m_ClickedBGBm.LoadBitmap(ID); + +} + +void CLabelEx::SetLabelBitmap(UINT ID) +{ + if(m_LabelBm.GetSafeHandle()!=NULL) + m_LabelBm.DeleteObject(); + m_LabelBm.LoadBitmap(ID); + +} +void CLabelEx::OnLButtonDown(UINT nFlags, CPoint point) +{ + // TODO: Add your message handler code here and/or call default + m_bClicked=!m_bClicked; + RedrawWindow(); + CStatic::OnLButtonDown(nFlags, point); +} + +void CLabelEx::SetMouseOverLabelBitmap(UINT ID) +{ + if(m_MouseOverLabelBm.GetSafeHandle()!=NULL) + m_MouseOverLabelBm.DeleteObject(); + m_MouseOverLabelBm.LoadBitmap(ID); + +} + +void CLabelEx::SetClickedLabelBitmap(UINT ID) +{ + if(m_ClickedLabelBm.GetSafeHandle()!=NULL) + m_ClickedLabelBm.DeleteObject(); + m_ClickedLabelBm.LoadBitmap(ID); + +} +///ԶӦɫ +void CLabelEx::EnableHighLight(BOOL bHighLight) +{ + m_bHighLight=bHighLight; +} +void CLabelEx::SetLabelInfo(UINT ID,CString Text1,CString Text2) +{ + if(m_CurBmpID!=ID || Text1 != m_CurText1|| Text2 != m_CurText2) + { + m_CurText1 = Text1; + m_CurText2 = Text2; + m_CurBmpID = ID; + SetLabelBitmap(ID); + RedrawWindow();//ػ + } +} \ No newline at end of file diff --git a/LaipuDrawing/LabelEx.h b/LaipuDrawing/LabelEx.h new file mode 100644 index 0000000..f37b150 --- /dev/null +++ b/LaipuDrawing/LabelEx.h @@ -0,0 +1,83 @@ +#if !defined(AFX_LABELEX_H__C9BE230C_B8E9_48DE_8022_F3D4F5260B65__INCLUDED_) +#define AFX_LABELEX_H__C9BE230C_B8E9_48DE_8022_F3D4F5260B65__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// LabelEx.h : header file +// + +///////////////////////////////////////////////////////////////////////////// +// CLabelEx window + + +//ͼƬ +class CLabelEx : public CStatic +{ +// Construction +public: + CLabelEx(); + +// Attributes +public: + +// Operations +public: + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CLabelEx) + protected: + virtual void PreSubclassWindow(); + //}}AFX_VIRTUAL + +// Implementation +public: + void EnableHighLight(BOOL bHighLight); + void SetClickedLabelBitmap(UINT ID); + void SetMouseOverLabelBitmap(UINT ID); + void SetClickedBGBitmap(UINT ID); + void SetLabelBitmap(UINT ID); + void SetMouseOverBGBitmap(UINT ID); + void SetBGBitmap(UINT ID); + void RedrawWindow(); + void EnableAutoUnderLine(BOOL bAutoUnderLine); + void SetBkColor(COLORREF crBkColor); + void SetBorder(BOOL bBorder,COLORREF crBorder); + void SetUnderLine(BOOL bUnderLine,COLORREF crUnderLine); + void SetTextColor(COLORREF crText); + virtual ~CLabelEx(); + + void SetLabelInfo(UINT ID,CString Text1,CString Text2); + // Generated message map functions +protected: + HCURSOR m_hHandCur; + CFont m_Font; + BOOL m_bBorder; + BOOL m_bClicked; + BOOL m_bOver; + BOOL m_bUnderLine,m_bBackUnderLine; + BOOL m_bAutoUnderLine; + BOOL m_bHighLight; + CBitmap m_BGBm,m_MouseOverBGBm,m_ClickedBGBm; + CBitmap m_LabelBm,m_MouseOverLabelBm,m_ClickedLabelBm; + COLORREF m_crText,m_crBorder,m_crBG,m_crUnderLine; + COLORREF m_crBackText; + + UINT m_CurBmpID; + CString m_CurText1; + CString m_CurText2; + //{{AFX_MSG(CLabelEx) + afx_msg void OnPaint(); + afx_msg void OnLButtonDown(UINT nFlags, CPoint point); + //}}AFX_MSG + + DECLARE_MESSAGE_MAP() +}; + +///////////////////////////////////////////////////////////////////////////// + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_LABELEX_H__C9BE230C_B8E9_48DE_8022_F3D4F5260B65__INCLUDED_) diff --git a/LaipuDrawing/LaiPuLaser.aps b/LaipuDrawing/LaiPuLaser.aps new file mode 100644 index 0000000..4c50405 Binary files /dev/null and b/LaipuDrawing/LaiPuLaser.aps differ diff --git a/LaipuDrawing/LaiPuLaser.cpp b/LaipuDrawing/LaiPuLaser.cpp new file mode 100644 index 0000000..2d4a96f --- /dev/null +++ b/LaipuDrawing/LaiPuLaser.cpp @@ -0,0 +1,304 @@ + +// LaiPuLaser.cpp : ӦóΪ +// + +#include "stdafx.h" +#include "afxwinappex.h" +#include "afxdialogex.h" +#include "LaiPuLaser.h" +#include "MainFrm.h" + +#include "ChildFrm.h" +#include "LaiPuLaserDoc.h" +#include "LaiPuLaserView.h" +#include "FontTypeMgr.h" +#include "WorkCmdInvoker.h" +#include "ModuleDeviceMgr.h" +#include "ModuleDrawMgr.h" +#include "AuthorityMgr.h" +#include "Layer.h" +#include "GlobalFunction.h" +#include "ProgramLaserTuiHuo.h" +#include "EncryptionMgr.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + + +// CLaiPuLaserApp + +BEGIN_MESSAGE_MAP(CLaiPuLaserApp, CWinAppEx) + ON_COMMAND(ID_APP_ABOUT, &CLaiPuLaserApp::OnAppAbout) + // ļı׼ĵ + ON_COMMAND(ID_FILE_NEW, &CWinAppEx::OnFileNew) + ON_COMMAND(ID_FILE_OPEN, &CWinAppEx::OnFileOpen) + // ׼ӡ + ON_COMMAND(ID_FILE_PRINT_SETUP, &CWinAppEx::OnFilePrintSetup) +END_MESSAGE_MAP() + + +// CLaiPuLaserApp + +CLaiPuLaserApp::CLaiPuLaserApp() +{ + EnableHtmlHelp(); + + m_bHiColorIcons = TRUE; + + // ֧ + m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_ALL_ASPECTS; +#ifdef _MANAGED + // Ӧóùʱ֧(/clr)ģ: + // 1) д˸ãֲ֧ + // 2) ĿУ밴˳ System.Windows.Forms á + System::Windows::Forms::Application::SetUnhandledExceptionMode(System::Windows::Forms::UnhandledExceptionMode::ThrowException); +#endif + + //Ϊ CompanyName.ProductName.SubProduct.VersionInformation + SetAppID(_T("LaiPuDrawing.AppID.NoVersion")); + + // Ҫijʼ InitInstance +} + +// Ψһһ CLaiPuLaserApp + +CLaiPuLaserApp theApp; + + +// CLaiPuLaserApp ʼ + +BOOL CLaiPuLaserApp::InitInstance() +{ + // һ Windows XP ϵӦó嵥ָҪ + // ʹ ComCtl32.dll 汾 6 ߰汾ÿӻʽ + //Ҫ InitCommonControlsEx()򣬽޷ڡ + INITCOMMONCONTROLSEX InitCtrls; + InitCtrls.dwSize = sizeof(InitCtrls); + // ΪҪӦóʹõ + // ؼࡣ + InitCtrls.dwICC = ICC_WIN95_CLASSES; + InitCommonControlsEx(&InitCtrls); + + CWinAppEx::InitInstance(); + + if (!AfxSocketInit()) + { + AfxMessageBox(IDP_SOCKETS_INIT_FAILED); + return FALSE; + } + + // ʼ OLE + if (!AfxOleInit()) + { + AfxMessageBox(IDP_OLE_INIT_FAILED); + return FALSE; + } + + AfxEnableControlContainer(); + + EnableTaskbarInteraction(); + + // ʹ RichEdit ؼҪ AfxInitRichEdit2() + // AfxInitRichEdit2(); + + // ׼ʼ + // δʹЩܲϣС + // տִļĴСӦƳ + // Ҫضʼ + // ڴ洢õע + // TODO: Ӧʵ޸ĸַ + // ޸Ϊ˾֯ + SetRegistryKey(_T("ӦóɵıӦó")); + +#if 0 + HANDLE hObject = ::CreateMutex(NULL,FALSE, _T("LaipuDrawing")); + if(GetLastError() == ERROR_ALREADY_EXISTS) + { + CloseHandle(hObject); + AfxMessageBox(("ظ,в鿴Laipụ")); + return FALSE; + } +#endif + LoadStdProfileSettings(10); // ر׼ INI ļѡ( MRU) + + + InitContextMenuManager(); + InitShellManager(); + + InitKeyboardManager(); + + InitTooltipManager(); + CMFCToolTipInfo ttParams; + ttParams.m_bVislManagerTheme = TRUE; + theApp.GetTooltipManager()->SetTooltipParams(AFX_TOOLTIP_TYPE_ALL,RUNTIME_CLASS(CMFCToolTipCtrl), &ttParams); + + + + // עӦóĵģ塣ĵģ + // ĵܴںͼ֮ + CMultiDocTemplate* pDocTemplate; + pDocTemplate = new CMultiDocTemplate(IDR_LAIPU_LASER_MENU, + RUNTIME_CLASS(CLaiPuLaserDoc), + RUNTIME_CLASS(CChildFrame), // Զ MDI ӿ + RUNTIME_CLASS(CLaiPuLaserView)); + if (!pDocTemplate) + return FALSE; + AddDocTemplate(pDocTemplate); + + // MDI ܴ + CMainFrame* pMainFrame = new CMainFrame; + if (!pMainFrame || !pMainFrame->LoadFrame(IDR_MAINFRAME)) + { + delete pMainFrame; + return FALSE; + } + m_pMainWnd = pMainFrame; + // к׺ʱŵ DragAcceptFiles + // MDI ӦóУӦ m_pMainWnd ֮ + // / + m_pMainWnd->DragAcceptFiles(); + + // ׼ shell DDEļ + CCommandLineInfo cmdInfo; + ParseCommandLine(cmdInfo); + + // áDDE ִС + EnableShellOpen(); + RegisterShellFileTypes(TRUE); + + // ָ + // /RegServer/Register/Unregserver /Unregister Ӧó򷵻 FALSE + if (!ProcessShellCommand(cmdInfo)) + return FALSE; + // ѳʼʾи + #if 0 + //pMainFrame->ShowWindow(m_nCmdShow); + CChildFrame *pChild = (CChildFrame*)pMainFrame->GetActiveFrame(); + pChild->ShowWindow(SW_SHOWMAXIMIZED);//Ĭ + + pMainFrame->ShowWindow(SW_SHOWMAXIMIZED); + pMainFrame->UpdateWindow(); + #endif + + // ѳʼʾи + //pMainFrame->ShowWindow(m_nCmdShow); + CChildFrame *pChild = (CChildFrame*)pMainFrame->GetActiveFrame(); + pChild->ShowWindow(SW_SHOWMAXIMIZED);//Ĭ + + //pMainFrame->ShowWindow(SW_SHOWMAXIMIZED); + pMainFrame->UpdateWindow(); + + LaiPuAppInitialize(); + + + return TRUE; +} +void CLaiPuLaserApp::LaiPuAppInitialize() +{ + gAuthorityMgr->SetAuthority(_Authority_Factory);//²ҪȨ + //ʼȫ + gModuleDrawMgr.InitPar(); + gModuleDeviceMgr.InitPar(); + gModuleDrawMgr.SaveAllModuleProperty(); + gModuleDeviceMgr.SaveAllModuleProperty(); + if(gAuthorityMgr->IsAutoFactory()==false) + { + gAuthorityMgr->Lock(); + } + + //ʼ + CFontTypeMgr &FontTypeMgr = CFontTypeMgr::Instance(); + FontTypeMgr.Initialize(); + +} +//˳ +void CLaiPuLaserApp::AppExit() +{ + CWinApp::OnAppExit(); +} +int CLaiPuLaserApp::ExitInstance() +{ + //TODO: ӵĸԴ + AfxOleTerm(FALSE); + //gModuleDeviceMgr.OnExitApp(); + return CWinAppEx::ExitInstance(); +} +// CLaiPuLaserApp Ϣ + +// Ӧó򡰹ڡ˵ CAboutDlg Ի +CAboutDlg::CAboutDlg():CDialogEx(CAboutDlg::IDD) +{ +} +void CAboutDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); +} +BOOL CAboutDlg::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + CString s("ʱ:"); + s+=gProgramLaserTuiHuo->GetAppOpenTime(); + GetDlgItem(IDC_APP_OPEN_TIME)->SetWindowText(s); + UpdateData(FALSE); + + CString AppMakeTime("ʱ: "); + AppMakeTime += __DATE__; + AppMakeTime += " "; + AppMakeTime += __TIME__; + GetDlgItem(IDC_APP_MAKE_TIME)->SetWindowText(AppMakeTime); + + #ifdef __USE_SUPER_DOG__ + GetDlgItem(IDC_SUPER_DOG_INFO)->ShowWindow(SW_SHOW); + //ʾܹʱ + int DogYear =0; + int DogMonth = 0; + int DogDay = 0; + gKernelMode.GetDogTime(&DogYear,&DogMonth,&DogDay); + CString SuperDogTime; + SuperDogTime.Format(_T("Hardware Time : %d / %d / %d"),DogYear,DogMonth,DogDay); + CString str = "["; + str += gEncryptionMgr->GetCurHardDiskSerialNum(); + str += "]"; + str += SuperDogTime; + GetDlgItem(IDC_SUPER_DOG_INFO)->SetWindowText(str); + #endif + + + return TRUE; +} + + +BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx) +END_MESSAGE_MAP() + +// жԻӦó +void CLaiPuLaserApp::OnAppAbout() +{ + CAboutDlg aboutDlg; + aboutDlg.DoModal(); +} + +// CLaiPuLaserApp Զ/淽 + +void CLaiPuLaserApp::PreLoadState() +{ + BOOL bNameValid; + CString strName; + bNameValid = strName.LoadString(IDS_EDIT_MENU); + ASSERT(bNameValid); + GetContextMenuManager()->AddMenu(strName, IDR_POPUP_EDIT); +} + +void CLaiPuLaserApp::LoadCustomState() +{ +} + +void CLaiPuLaserApp::SaveCustomState() +{ +} + +// CLaiPuLaserApp Ϣ + + + diff --git a/LaipuDrawing/LaiPuLaser.h b/LaipuDrawing/LaiPuLaser.h new file mode 100644 index 0000000..9ed9bf9 --- /dev/null +++ b/LaipuDrawing/LaiPuLaser.h @@ -0,0 +1,59 @@ + +// LaiPuLaser.h : LaiPuLaser Ӧóͷļ +// +#pragma once + +#ifndef __AFXWIN_H__ + #error "ڰļ֮ǰstdafx.h PCH ļ" +#endif + +#include "resource.h" // +#include "ModuleDeviceMgr.h" + +// CLaiPuLaserApp: +// йشʵ֣ LaiPuLaser.cpp +// +class CAboutDlg : public CDialogEx +{ +public: + CAboutDlg(); + +// Ի + enum { IDD = IDD_ABOUTBOX }; + +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); +// ʵ +protected: + DECLARE_MESSAGE_MAP() +}; + +class CLaiPuLaserApp : public CWinAppEx +{ +public: + CLaiPuLaserApp(); + + +// д +public: + virtual BOOL InitInstance(); + virtual int ExitInstance(); + +// ʵ + UINT m_nAppLook; + BOOL m_bHiColorIcons; + + virtual void PreLoadState(); + virtual void LoadCustomState(); + virtual void SaveCustomState(); + + afx_msg void OnAppAbout(); + + void AppExit(); + DECLARE_MESSAGE_MAP() +private: + void LaiPuAppInitialize(); +}; + +extern CLaiPuLaserApp theApp; diff --git a/LaipuDrawing/LaiPuLaser.hhc b/LaipuDrawing/LaiPuLaser.hhc new file mode 100644 index 0000000..5589537 --- /dev/null +++ b/LaipuDrawing/LaiPuLaser.hhc @@ -0,0 +1,46 @@ + + + + + + +
    +
  • + + + +
  • + + +
      +
    • + + + +
    • + + + +
    • + + + +
    • + + + +
    • + + + +
    +
  • + + + +
  • + + + +
+ diff --git a/LaipuDrawing/LaiPuLaser.rc b/LaipuDrawing/LaiPuLaser.rc new file mode 100644 index 0000000..c2d65dc Binary files /dev/null and b/LaipuDrawing/LaiPuLaser.rc differ diff --git a/LaipuDrawing/LaiPuLaser.reg b/LaipuDrawing/LaiPuLaser.reg new file mode 100644 index 0000000..4cd9742 --- /dev/null +++ b/LaipuDrawing/LaiPuLaser.reg @@ -0,0 +1,15 @@ +REGEDIT +; .REG ļ SETUP ʹá +; SETUP 򲻿ã +; CWinApp::RegisterShellFileTypes COleObjectFactory::UpdateRegistryAll +; InitInstance жԶעᡣ + +HKEY_CLASSES_ROOT\.mak = LaiPuLaser.Document +HKEY_CLASSES_ROOT\LaiPuLaser.Document\shell\open\command = LaiPuLaser.EXE %1 +HKEY_CLASSES_ROOT\LaiPuLaser.Document\shell\open\ddeexec = [open("%1")] +HKEY_CLASSES_ROOT\LaiPuLaser.Document\shell\open\ddeexec\application = LaiPuLaser + ; ע: Ӧóǿѡ + ; (ĬΪеӦó) + +HKEY_CLASSES_ROOT\LaiPuLaser.Document = LaiPuLaser.Document + diff --git a/LaipuDrawing/LaiPuLaserDoc.cpp b/LaipuDrawing/LaiPuLaserDoc.cpp new file mode 100644 index 0000000..6fb3aca --- /dev/null +++ b/LaipuDrawing/LaiPuLaserDoc.cpp @@ -0,0 +1,125 @@ + +// LaiPuLaserDoc.cpp : CLaiPuLaserDoc ʵ +// + +#include "stdafx.h" +// SHARED_HANDLERS ʵԤͼɸѡ +// ATL Ŀнж壬Ŀĵ롣 +#ifndef SHARED_HANDLERS +#include "LaiPuLaser.h" +#endif + +#include "LaiPuLaserDoc.h" +#include "GlobalFunction.h" +#include + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +// CLaiPuLaserDoc + +IMPLEMENT_DYNCREATE(CLaiPuLaserDoc, CDocument) + +BEGIN_MESSAGE_MAP(CLaiPuLaserDoc, CDocument) + ON_COMMAND(ID_FILE_SEND_MAIL, &CLaiPuLaserDoc::OnFileSendMail) + ON_UPDATE_COMMAND_UI(ID_FILE_SEND_MAIL, &CLaiPuLaserDoc::OnUpdateFileSendMail) +END_MESSAGE_MAP() + + +// CLaiPuLaserDoc / + +CLaiPuLaserDoc::CLaiPuLaserDoc() +{ + // TODO: ڴһԹ + +} + +CLaiPuLaserDoc::~CLaiPuLaserDoc() +{ +} + +BOOL CLaiPuLaserDoc::OnNewDocument() +{ + if (!CDocument::OnNewDocument()) + return FALSE; + + // TODO: ڴ³ʼ + // (SDI ĵøĵ) + + return TRUE; +} + +#if 1//л +void CLaiPuLaserDoc::Serialize(CArchive& ar) +{ + +} +#endif +#ifdef SHARED_HANDLERS + +// ͼ֧ +void CLaiPuLaserDoc::OnDrawThumbnail(CDC& dc, LPRECT lprcBounds) +{ + // ޸Ĵ˴Իĵ + dc.FillSolidRect(lprcBounds, RGB(255, 255, 255)); + + CString strText = _T("TODO: implement thumbnail drawing here"); + LOGFONT lf; + + CFont* pDefaultGUIFont = CFont::FromHandle((HFONT) GetStockObject(DEFAULT_GUI_FONT)); + pDefaultGUIFont->GetLogFont(&lf); + lf.lfHeight = 36; + + CFont fontDraw; + fontDraw.CreateFontIndirect(&lf); + + CFont* pOldFont = dc.SelectObject(&fontDraw); + dc.DrawText(strText, lprcBounds, DT_CENTER | DT_WORDBREAK); + dc.SelectObject(pOldFont); +} + +// ֧ +void CLaiPuLaserDoc::InitializeSearchContent() +{ + CString strSearchContent; + // ĵݡ + // ݲӦɡ;ָ + + // : strSearchContent = _T("point;rectangle;circle;ole object;") + SetSearchContent(strSearchContent); +} + +void CLaiPuLaserDoc::SetSearchContent(const CString& value) +{ + if (value.IsEmpty()) + { + RemoveChunk(PKEY_Search_Contents.fmtid, PKEY_Search_Contents.pid); + } + else + { + CMFCFilterChunkValueImpl *pChunk = NULL; + ATLTRY(pChunk = new CMFCFilterChunkValueImpl); + if (pChunk != NULL) + { + pChunk->SetTextValue(PKEY_Search_Contents, value, CHUNK_TOOL_TEXT); + SetChunkValue(pChunk); + } + } +} + +#endif // SHARED_HANDLERS + +// CLaiPuLaserDoc + +#ifdef _DEBUG +void CLaiPuLaserDoc::AssertValid() const +{ + CDocument::AssertValid(); +} + +void CLaiPuLaserDoc::Dump(CDumpContext& dc) const +{ + CDocument::Dump(dc); +} +#endif //_DEBUG diff --git a/LaipuDrawing/LaiPuLaserDoc.h b/LaipuDrawing/LaiPuLaserDoc.h new file mode 100644 index 0000000..c367862 --- /dev/null +++ b/LaipuDrawing/LaiPuLaserDoc.h @@ -0,0 +1,42 @@ + +// LaiPuLaserDoc.h : CLaiPuLaserDoc Ľӿ +// + + +#pragma once + +class CLaiPuLaserDoc : public CDocument +{ +protected: // л + CLaiPuLaserDoc(); + DECLARE_DYNCREATE(CLaiPuLaserDoc) +// д +public: + virtual BOOL OnNewDocument(); + virtual void Serialize(CArchive& ar); +#ifdef SHARED_HANDLERS + virtual void InitializeSearchContent(); + virtual void OnDrawThumbnail(CDC& dc, LPRECT lprcBounds); +#endif // SHARED_HANDLERS + +// ʵ +public: + virtual ~CLaiPuLaserDoc(); +#ifdef _DEBUG + virtual void AssertValid() const; + virtual void Dump(CDumpContext& dc) const; +#endif + +protected: + +// ɵϢӳ亯 +protected: + DECLARE_MESSAGE_MAP() + +#ifdef SHARED_HANDLERS + // Ϊݵ Helper + void SetSearchContent(const CString& value); +#endif // SHARED_HANDLERS +private: +}; + diff --git a/LaipuDrawing/LaiPuLaserView.cpp b/LaipuDrawing/LaiPuLaserView.cpp new file mode 100644 index 0000000..51d8943 --- /dev/null +++ b/LaipuDrawing/LaiPuLaserView.cpp @@ -0,0 +1,1327 @@ + +// LaiPuLaserView.cpp : CLaiPuLaserView ʵ +// + +#include "stdafx.h" +// SHARED_HANDLERS ʵԤͼɸѡ +// ATL Ŀнж壬Ŀĵ롣 +#ifndef SHARED_HANDLERS +#include "LaiPuLaser.h" +#endif + +#include "LaiPuLaserDoc.h" +#include "LaiPuLaserView.h" +#include "MainFrm.h" +#include "MouseToolmgr.h" +#include "GlobalDrawMgr.h" +#include "MarkObjPropertieMgr.h" +#include "GlobalFunction.h" +#include "CommandDelete.h" +#include "CommandMove.h" +#include "LogMgr.h" +#include "DlgArray.h" +#include "WorkAreaMgr.h" +#include "Ruler.h" +#include "ModuleDeviceMgr.h" +#include "ModuleDrawMgr.h" +#include "CommandMgr.h" +#include "WorkDataMgr.h" +#include "TemplateMgr.h" +#include "AuthorityMgr.h" +#include "ObjFillMgr.h" +#include "CommonFlowMgr.h" +#include "CriticalSection.h" + + + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +// CLaiPuLaserView +#if 1 +IMPLEMENT_DYNCREATE(CLaiPuLaserView, CScrollView) + +BEGIN_MESSAGE_MAP(CLaiPuLaserView, CScrollView) + // ׼ӡ + ON_COMMAND(ID_FILE_PRINT, &CScrollView::OnFilePrint) + ON_COMMAND(ID_FILE_PRINT_DIRECT, &CScrollView::OnFilePrint) + ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview) + ON_COMMAND(ID_MOUSE_RECT, OnToolRect) + ON_UPDATE_COMMAND_UI(ID_MOUSE_RECT, OnUpdateToolRect) + ON_COMMAND(ID_TOOL_POINT, OnToolOnePoint) + ON_UPDATE_COMMAND_UI(ID_TOOL_POINT, OnUpdateToolOnePoint) + ON_COMMAND(ID_LASER_COORD, OnToolLaserCoord) + ON_UPDATE_COMMAND_UI(ID_LASER_COORD, OnUpdateToolLaserCoord) + + ON_COMMAND(ID_MOUSE_CIRCLE, OnToolCircle) + ON_UPDATE_COMMAND_UI(ID_MOUSE_CIRCLE, OnUpdateToolCircle) + ON_COMMAND(ID_MOUSE_LINE, OnToolLine) + ON_UPDATE_COMMAND_UI(ID_MOUSE_LINE, OnUpdateToolLine) + ON_COMMAND(ID_PLINE, OnToolPline) + ON_UPDATE_COMMAND_UI(ID_PLINE, OnUpdateToolPline) + ON_COMMAND(ID_POLYGON, OnToolPolygon) + ON_UPDATE_COMMAND_UI(ID_POLYGON, OnUpdateToolPolygon) + + ON_COMMAND(ID_UNDO, OnUndo) + ON_UPDATE_COMMAND_UI(ID_UNDO, OnUpdateUndo) + ON_COMMAND(ID_REDO, OnRedo) + ON_UPDATE_COMMAND_UI(ID_REDO, OnUpdateRedo) + ON_COMMAND(ID_ROTATO, OnToolRotato) + ON_COMMAND(ID_SLE_ALL, OnSelAllObj) + ON_COMMAND(ID_REV_SEL_OBJ, OnRevSelObj) + ON_COMMAND(ID_ZOOM_IN, OnZoomIn) + ON_COMMAND(ID_ZOOM_OUT, OnZoomOut) + ON_COMMAND(ID_WORK_SPACE_VIEW, OnWorkSpaceView) + ON_COMMAND(ID_MOVE_TO_CENTER, OnMoveToCenter) + ON_COMMAND(ID_OBJ_FILL, OnObjFill) + ON_COMMAND(ID_MIRROR_H, OnMirrorH) + ON_COMMAND(ID_MIRROR_V, OnMirrorV) + ON_COMMAND(ID_ROTATO_90_L, OnRotato90L) + ON_COMMAND(ID_ROTATO_90_R, OnRotato90R) + ON_COMMAND(ID_ARRAY, OnArray) + ON_COMMAND(ID_CUT, OnCut) + ON_COMMAND(ID_BREAK, OnBreak) + ON_COMMAND(ID_CHAMFER, OnChamfer) + ON_COMMAND(ID_FILLET, OnFillet) + ON_COMMAND(ID_EXPLODE, OnExplode) + ON_COMMAND(ID_DELETE, OnDelSelObj) + ON_COMMAND(ID_JOIN, OnJoin) + ON_COMMAND(ID_COPY, OnCopy) + ON_COMMAND(ID_MOVE, OnMove) + ON_COMMAND(ID_DIS_MEASURE, OnMeasure) + ON_COMMAND(ID_REVERSE, OnReverse) + ON_COMMAND(ID_ADD_NODE, OnAddNode) + ON_COMMAND(ID_DEL_NODE, OnDelNode) + ON_UPDATE_COMMAND_UI(ID_ROTATO, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_MOVE_TO_CENTER, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_OBJ_FILL, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_MIRROR_H, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_MIRROR_V, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_ROTATO_90_L, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_ROTATO_90_R, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_ARRAY, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_CHAMFER, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_FILLET, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_EXPLODE, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_DELETE, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_FILL, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_JOIN, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_COPY, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_MOVE, OnUpdateObjOperate) + ON_UPDATE_COMMAND_UI(ID_REVERSE, OnUpdateObjOperate) + + + ON_WM_ERASEBKGND() + ON_WM_CONTEXTMENU() + ON_WM_RBUTTONUP() + ON_WM_MOUSEWHEEL()//Ϣ + ON_WM_MOUSEMOVE() + ON_WM_LBUTTONDOWN() + ON_WM_LBUTTONUP() + ON_WM_RBUTTONDOWN() + ON_WM_RBUTTONUP() + ON_WM_SETCURSOR()// +END_MESSAGE_MAP() +#endif +// CLaiPuLaserView / + +CLaiPuLaserView::CLaiPuLaserView() +{ + m_bFirstIn = true;//Ƿһν + m_bCtrl = false;//ctrl Ƿ + m_bEraseBkgnd = true;//Ƿػ汳ɫ + m_bEraseBkgnd2 = true;//Ƿػ汳ɫ(Զָ) +} + +CLaiPuLaserView::~CLaiPuLaserView() +{ +} +//ȡǰָ +CLaiPuLaserView* m_pView = NULL;//浱ǰָ +BOOL CLaiPuLaserView::PreCreateWindow(CREATESTRUCT& cs) +{ + // CREATESTRUCT cs ޸Ĵʽ + return CScrollView::PreCreateWindow(cs); +} +//ڵһεOnDrawǰOnInitialUpdate +void CLaiPuLaserView::OnInitialUpdate() +{ + CScrollView::OnInitialUpdate(); + CSize Size; + Size = gDraw->GetScrollViewSize(); + SetZoomSizes(Size); +} +#if 1// +HDC CLaiPuLaserView::GetHDC() +{ + return ::GetDC(GetSafeHwnd()); +} +CDC* CLaiPuLaserView::GetCDC() +{ + return CDC::FromHandle(GetHDC()); +} +// CLaiPuLaserView +void CLaiPuLaserView::OnDraw(CDC* pDC) +{ + CLaiPuLaserDoc* pDoc = GetDocument(); + ASSERT_VALID(pDoc); + if (!pDoc) + return; + if(m_bFirstIn) + { + //۲ + DoZoomFull(); + } + //Ȳ֮ǰIJ׽ + gMouseToolMgr.ResetCatchPoint(pDC); + + //ģԻһЩ + gModuleDeviceMgr.Draw(pDC); + gModuleDrawMgr.Draw(pDC); + //Ƶǰlayer + if(!m_bFirstIn) + { + gLayer.Draw(pDC); + } + + m_bFirstIn = false; +} +#endif +// CLaiPuLaserView ӡ +void CLaiPuLaserView::OnFilePrintPreview() +{ +#ifndef SHARED_HANDLERS + AFXPrintPreview(this); +#endif +} + +BOOL CLaiPuLaserView::OnPreparePrinting(CPrintInfo* pInfo) +{ + // Ĭ׼ + return DoPreparePrinting(pInfo); +} + +void CLaiPuLaserView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) +{ +} +void CLaiPuLaserView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) +{ +} +#if 1//̲ +//ϢӦ +BOOL CLaiPuLaserView::OnMouseWheel(UINT nFlags,short zDelta,CPoint point) +{ + if(gDraw->IsbMouseWheel()) + { + CClientDC dc(this); + OnPrepareDC(&dc); + dc.DPtoLP(&point); + + //Ȳ֮ǰIJ׽ + gMouseToolMgr.ResetCatchPoint(&dc); + + if(zDelta > 0)//ϹŴ + { + DoZoomIn(gDraw->GetCurZoomPoint()); + } + else if(zDelta < 0)//¹С + { + DoZoomOut(gDraw->GetCurZoomPoint()); + } + + //ʾű + CMainFrame *pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd(); + pFrame->ShowViewScale(m_zoomScale); + } + return TRUE; +} +void CLaiPuLaserView::OnMouseMove(UINT nFlags, CPoint point) +{ + //ĻתΪ豸 + CClientDC dc(this); + OnPrepareDC(&dc); + dc.DPtoLP(&point); + + gDraw->SetCurZoomPoint(point);//ƶʱ¼ŵ + gDraw->SetbNeedRedraw(true); + //ʾλ + CMainFrame *pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd(); + pFrame->ShowMouseCoord(point); + //깤 + gMouseToolMgr.OnMouseMove(nFlags,point,dc); + + //Ʊ߹λ + gRuler->DrawMousePos(&dc, point); + + CScrollView::OnMouseMove(nFlags, point); +} +void CLaiPuLaserView::OnLButtonDown(UINT nFlags, CPoint point) +{ + //ĻתΪ豸 + CClientDC dc(this); + OnPrepareDC(&dc); + dc.DPtoLP(&point); + gMouseToolMgr.OnLButtonDown(nFlags,point,dc); + CScrollView::OnLButtonDown(nFlags, point); +} +void CLaiPuLaserView::OnLButtonUp(UINT nFlags, CPoint point) +{ + //ĻתΪ豸 + CClientDC dc(this); + OnPrepareDC(&dc); + dc.DPtoLP(&point); + gMouseToolMgr.OnLButtonUp(nFlags,point,dc); + CScrollView::OnLButtonUp(nFlags, point); +} +void CLaiPuLaserView::OnRButtonDown(UINT nFlags, CPoint point) +{ + //ĻתΪ豸 + CClientDC dc(this); + OnPrepareDC(&dc); + dc.DPtoLP(&point); + + gMouseToolMgr.OnRButtonDown(nFlags,point,dc); + //CScrollView::OnRButtonDown(nFlags, point); +} +void CLaiPuLaserView::OnRButtonUp(UINT nFlags, CPoint point) +{ + //ĻתΪ豸 + CClientDC dc(this); + OnPrepareDC(&dc); + dc.DPtoLP(&point); + + gMouseToolMgr.OnRButtonUp(nFlags,point,dc); + //CScrollView::OnRButtonUp(nFlags, point); +} +void CLaiPuLaserView::OnMButtonDown(UINT nFlags, CPoint point) +{ + +} +void CLaiPuLaserView::OnMButtonUp(UINT nFlags, CPoint point) +{ + +} +//ˮƽϢӦ +void CLaiPuLaserView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) +{ + //ͷ + if(SB_LINEDOWN == nSBCode || SB_LINEUP == nSBCode) + { + CScrollView::OnHScroll(nSBCode, nPos, pScrollBar); + Invalidate(); + } + //ϵʱ + if(SB_THUMBTRACK == nSBCode) + { + CScrollView::OnHScroll(SB_THUMBTRACK, nPos, pScrollBar); + Invalidate(); + } + //϶ + if(SB_THUMBPOSITION == nSBCode) + { + CScrollView::OnHScroll(SB_THUMBPOSITION, nPos, pScrollBar); + Invalidate(); + } +} +//ֱϢӦ +void CLaiPuLaserView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) +{ + //ͷ + if(SB_LINEDOWN == nSBCode || SB_LINEUP == nSBCode) + { + CScrollView::OnVScroll(nSBCode, nPos, pScrollBar); + Invalidate(); + } + //ϵʱ + if(SB_THUMBTRACK == nSBCode) + { + CScrollView::OnVScroll(SB_THUMBTRACK, nPos, pScrollBar); + Invalidate(); + } + //϶ + if(SB_THUMBPOSITION == nSBCode) + { + CScrollView::OnVScroll(SB_THUMBPOSITION, nPos, pScrollBar); + Invalidate(); + } +} + +//Ӧ +BOOL CLaiPuLaserView::PreTranslateMessage(MSG* pMsg) +{ + if(pMsg->message==WM_KEYDOWN) + { + char c = pMsg->wParam; + switch(c) + { + case VK_CONTROL: + m_bCtrl = true; + OnCtrl(); + break; + case 'A'://ctrl + A ȫѡ + if(m_bCtrl) + { + OnSelAllObj(); + } + break; + case 'Z'://ctrl + Z + if(m_bCtrl) + { + OnUndo(); + } + break; + case 'Y'://ctrl + Y + if(m_bCtrl) + { + OnRedo(); + } + break; + case 'S'://ctrl + S + if(m_bCtrl) + { + // + } + break; + case VK_SPACE: + OnSpace(); + break; + case VK_ESCAPE://Esc + OnEscape(); + break; + case VK_DELETE://ɾ + OnDelSelObj(); + break; + case VK_UP: + OnArrowDir(_DIR_U); + break; + case VK_DOWN: + OnArrowDir(_DIR_D); + break; + case VK_LEFT: + OnArrowDir(_DIR_L); + break; + case VK_RIGHT: + OnArrowDir(_DIR_R); + break; + default: + break; + } + } + if(pMsg->message==WM_KEYUP) + { + switch(pMsg->wParam) + { + case VK_CONTROL: + m_bCtrl = false; + break; + default: + break; + } + } + return CScrollView::PreTranslateMessage(pMsg); +} +//ESC Ӧ +void CLaiPuLaserView::OnEscape() +{ + CClientDC dc(this); + OnPrepareDC(&dc); + + gMouseToolMgr.OnEscapeKey(&dc); + gLayer.NotSelAllObj();//obj ȫѡ + gMouseToolMgr.SetMouseTool(_TOOL_POINT); + GetFrame()->ResetCaptionBar(); + RefreshView(); + gLogMgr->WriteDebugLog("OnEscape"); +} +//Ӧ +void CLaiPuLaserView::MoveObjToPtByDir(DIRECTION dir,double Dis) +{ + double MoveDisX = 0; + double MoveDisY = 0; + switch(dir) + { + case _DIR_L: + MoveDisX -= Dis; + break; + case _DIR_R: + MoveDisX += Dis; + break; + case _DIR_U: + MoveDisY += Dis; + break; + case _DIR_D: + MoveDisY -= Dis; + break; + default: + break; + } + gLayer.OnMove(MoveDisX,MoveDisY); + RefreshView(); +} +#endif +#if 1//Ӧ +// +void CLaiPuLaserView::OnArrowDir(DIRECTION dir) +{ + MoveObjToPtByDir(dir,gDraw->GetKeyboardMoveDis()); +} +//ո +void CLaiPuLaserView::OnSpace() +{ + +} +void CLaiPuLaserView::OnCtrl() +{ +} +#endif +void CLaiPuLaserView::OnContextMenu(CWnd* /* pWnd */, CPoint point) +{ +#ifndef SHARED_HANDLERS + theApp.GetContextMenuManager()->ShowPopupMenu(IDR_POPUP_EDIT, point.x, point.y, this, TRUE); +#endif +} + + +// CLaiPuLaserView + +#ifdef _DEBUG +void CLaiPuLaserView::AssertValid() const +{ + CView::AssertValid(); +} + +void CLaiPuLaserView::Dump(CDumpContext& dc) const +{ + CScrollView::Dump(dc); +} + +CLaiPuLaserDoc* CLaiPuLaserView::GetDocument() const // ǵ԰汾 +{ + ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CLaiPuLaserDoc))); + return (CLaiPuLaserDoc*)m_pDocument; +} +#endif //_DEBUG + +#if 1//view +/*--------------------------------------------------------------------------- + FUNCTION: SetZoomSizes + PURPOSE : Set up the CLaiPuLaserView class with the logical page size, and + scrolling page/line units. + This replaces CScrollView::SetScrollSizes. +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::SetZoomSizes (SIZE sizeTotal,const SIZE& sizePage,const SIZE& sizeLine) +{ + // Set up the defaults + ASSERT(sizeTotal.cx >= 0 && sizeTotal.cy >= 0); + m_nMapMode = MM_ANISOTROPIC; // Need for arbitrary scaling + m_totalLog = sizeTotal; + // Setup default Viewport extent to be conversion of Window extent + // into device units. + //BLOCK for DC + { + CWindowDC dc(NULL); + dc.SetMapMode(m_nMapMode); + + // total size + m_totalDev = m_totalLog; + dc.LPtoDP((LPPOINT)&m_totalDev); + } // Release DC here + + // Save the origional Viewport Extent + m_origTotalDev = m_totalDev; + // Save the origional scrollbar info - for CalcBars + + m_origPageDev = sizePage; + m_origLineDev = sizeLine; + // Fugure out scroll bar info + CalcBars(); + // Notify the class that the zoom scale was set + NotifyZoom(); +} // SetZoomSizes + +/*--------------------------------------------------------------------------- + FUNCTION: OnPrepareDC + PURPOSE : Override of CScrollView for MM_ANISOTROPIC zoom mode +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::OnPrepareDC (CDC* pDC,CPrintInfo* pInfo) +{ +#ifdef _DEBUG + if (m_nMapMode != MM_ANISOTROPIC) { + TRACE0("Error: must call SetZoomSizes() before painting zoom view\n"); + ASSERT(FALSE); + return; + } +#endif //_DEBUG + + ASSERT_VALID(pDC); + ASSERT(m_totalLog.cx >= 0 && m_totalLog.cy >= 0); + ASSERT(m_totalDev.cx >= 0 && m_totalDev.cy >= 0); + // Set the Mapping mode, and the window and viewport extents + pDC->SetMapMode(m_nMapMode);//ɱӳģʽ + + pDC->SetViewportExt(m_totalDev); // in device coordinates + pDC->SetWindowExt(m_totalLog);// in logical coordinates + CPoint ptVpOrg; + // by default shift viewport origin in negative direction of scroll + ASSERT(pDC->GetWindowOrg() == CPoint(0,0)); + ptVpOrg = -GetDeviceScrollPosition(); + + // Center full fit + CRect rect; + GetClientRect(&rect); + // if client area is larger than total device size, + // override scroll positions to place origin such that + // output is centered in the window + if (m_totalDev.cx < rect.Width()) + ptVpOrg.x = (rect.Width() - m_totalDev.cx) / 2; + if (m_totalDev.cy < rect.Height()) + ptVpOrg.y = (rect.Height() - m_totalDev.cy) / 2; + // Set the new origin + pDC->SetViewportOrg(ptVpOrg); + // For default Printing behavior + CScrollView::OnPrepareDC(pDC, pInfo); +} // OnPrepareDC + +/*--------------------------------------------------------------------------- + FUNCTION: CalcBars + PURPOSE : Update the scrollbars - uses logical units + Call when the Viewport changes size. +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::CalcBars (void) +{ + { // BLOCK for DC + CWindowDC dc(NULL); + dc.SetMapMode(m_nMapMode); + // Calculate new device units for scrollbar + // Start with origional logical units from SetScrollPos + m_pageDev = m_origPageDev; + dc.LPtoDP((LPPOINT)&m_pageDev); + m_lineDev = m_origLineDev; + dc.LPtoDP((LPPOINT)&m_lineDev); + } // Free DC + + // Make sure of the range + if (m_pageDev.cy < 0) m_pageDev.cy = -m_pageDev.cy; + if (m_lineDev.cy < 0) m_lineDev.cy = -m_lineDev.cy; + + // If none specified - use one tenth + ASSERT(m_totalDev.cx >= 0 && m_totalDev.cy >= 0); + //һеľ + //double Scale = m_zoomScale/DEFAULT_SCALE; + double Scale = m_zoomScale/VIEW_SCALE20; + double min = 10;//С + double max = 500;// + double val = 20*Scale; + if(valmax) + { + val = max; + } + if(m_pageDev.cx == 0) + m_pageDev.cx = m_totalDev.cx/val; + if(m_pageDev.cy == 0) + m_pageDev.cy = m_totalDev.cy/val; + if(m_lineDev.cx == 0) + m_lineDev.cx = m_pageDev.cx /val; + if(m_lineDev.cy == 0) + m_lineDev.cy = m_pageDev.cy /val; + + // Now update the scrollbars + if (m_hWnd != NULL) + { + UpdateBars(); + Invalidate(TRUE); // Zoom scale changed, redraw all + } +} // CalcBars + +//Ŵ +int CLaiPuLaserView::DoZoomIn(CPoint Point) +{ + CPoint ptCenter; + ASSERT(m_nMapMode == MM_ANISOTROPIC); + + CPoint CurPt = GetScreenCenterPoint(); + double Scale = gDraw->GetMouseWheelScale(); + // Save the current center point. + ptCenter.x = CurPt.x+(Point.x-CurPt.x)*(Scale-1); + ptCenter.y = CurPt.y+(Point.y-CurPt.y)*(Scale-1); + + // Increase the zoom scale. + if(m_zoomScaleGetMouseWheelScale(); + // Save the current center point. + ptCenter.x = CurPt.x-(Point.x-CurPt.x)*(Scale-1); + ptCenter.y = CurPt.y-(Point.y-CurPt.y)*(Scale-1); + + // Decrease the zoom scale. + if(m_zoomScale>MIN_SCALE) + m_zoomScale /= Scale; + else + return TRUE; + + // Modify the Viewport extent + m_totalDev.cx = (int) ((double) m_origTotalDev.cx * m_zoomScale); + m_totalDev.cy = (int) ((double) m_origTotalDev.cy * m_zoomScale); + CalcBars(); + + // Set the current center point (logical coordinates. + CenterOnLogicalPoint(ptCenter); + // Notify the class that a new zoom scale was done + NotifyZoom(); + + return TRUE; +} + +//۲(ܻ߳) +int CLaiPuLaserView::DoZoomFull(void) +{ + RectView(gDraw->GetWorkAreaViewScale()); + return TRUE; +} +//۲ +void CLaiPuLaserView::RectView(double scale,Dbxy pt) +{ + ASSERT(m_nMapMode == MM_ANISOTROPIC); + + CRect rect; + CPoint point = gDraw->Dbxy2CPoint(pt); + //ʵ + m_zoomScale = scale; + + // Modify the Viewport extent + m_totalDev.cx = (int) ((double) m_origTotalDev.cx * m_zoomScale); + m_totalDev.cy = (int) ((double) m_origTotalDev.cy * m_zoomScale); + CalcBars(); + // Set the current center point. + CenterOnLogicalPoint(point); + // Notify the class that a new zoom scale was done + NotifyZoom(); +} + +/*--------------------------------------------------------------------------- + FUNCTION: CenterOnLogicalPoint + PURPOSE : Same as CScrollView::CenterOnPoint, but for logical coordinates +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::CenterOnLogicalPoint(CPoint pt) +{ + //Convert the point to device coordinates + ViewLPtoDP(&pt); + // Account for scroll bar position + ClientToDevice(pt); + // Use CScrollView's function for device coordinates + CScrollView::CenterOnPoint(pt); +} // CenterOnLogicalPoint + +/*--------------------------------------------------------------------------- + FUNCTION: GetLogicalCenterPoint + PURPOSE : Get the center of screen in logical coordinates +---------------------------------------------------------------------------*/ +CPoint CLaiPuLaserView::GetLogicalCenterPoint (void) // Point in logical units +{ + CPoint pt; + CRect rect; + // Get the center of screen + GetClientRect(&rect); + pt.x = (rect.Width() / 2); + pt.y = (rect.Height() / 2); + + // Convert the point to logical coordinates + ViewDPtoLP(&pt); + return pt; +} // GetLogicalCenterPoint + +/*--------------------------------------------------------------------------- + FUNCTION: ViewDPtoLP + PURPOSE : Same as DPtoLP, but gets the Client DC for the view +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::ViewDPtoLP ( + LPPOINT lpPoints, + int nCount) +{ + // Convert to logical units + // Called from View when no DC is available + ASSERT(m_nMapMode > 0); // must be set + CWindowDC dc(this); + OnPrepareDC(&dc); + dc.DPtoLP(lpPoints, nCount); +} // ViewDPtoLP + +/*--------------------------------------------------------------------------- + FUNCTION: ViewLPtoDP + PURPOSE : Same as LPtoDP, but gets the Client DC for the view +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::ViewLPtoDP ( + LPPOINT lpPoints, + int nCount) +{ + // Convert to logical units + // Called from View when no DC is available + ASSERT(m_nMapMode > 0); // must be set + CWindowDC dc(this); + OnPrepareDC(&dc); + dc.LPtoDP(lpPoints, nCount); +} // ViewLPtoDP + +/*--------------------------------------------------------------------------- + FUNCTION: ClientToDevice + PURPOSE : Convert from Client coordinates to relative Device coordinates +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::ClientToDevice ( + CPoint &point) +{ + // Need to account for scrollbar position + CPoint scrollPt = GetDeviceScrollPosition(); + point.x += scrollPt.x; + point.y += scrollPt.y; +} // ClientToDevice + +/*--------------------------------------------------------------------------- + FUNCTION: NormalizeRect + PURPOSE : Normalize the rectangle +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::NormalizeRect ( + CRect &rect) +{ + if (rect.left > rect.right) { + int r = rect.right; + rect.right = rect.left; + rect.left = r; + } + if (rect.top > rect.bottom) { + int b = rect.bottom; + rect.bottom = rect.top; + rect.top = b; + } +} // NormalizeRect + +/*--------------------------------------------------------------------------- + FUNCTION: PersistRatio + PURPOSE : Make a CSize maintain the given ratio (by shrinking if nescessary) +---------------------------------------------------------------------------*/ +void CLaiPuLaserView::PersistRatio ( + const CSize &orig, + CSize &dest, + CPoint &remainder) +{ + double ratio1 = (double) orig.cx / orig.cy; + double ratio2 = (double) dest.cx / dest.cy; + int newSize; + + // Do nothing if they are the same + if (ratio1 > ratio2) + { + // Shrink hieght + newSize = (int)(dest.cx / ratio1); + remainder.x = 0; + remainder.y = dest.cy - newSize; + dest.cy = newSize; + } else if (ratio2 > ratio1) + { + // Shrink width + newSize = (int)(dest.cy * ratio1); + remainder.x = dest.cx - newSize; + remainder.y = 0; + dest.cx = newSize; + } +} // PersistRatio +//ȡǰֵ +int CLaiPuLaserView::GetCurrScaleVal(int val) +{ + return (val/m_zoomScale); +} +double CLaiPuLaserView::GetCurrScaleVal(double val) +{ + return (val/m_zoomScale); +} +#endif +#if 1//ͼ +//Ŵ +void CLaiPuLaserView::OnZoomIn() +{ + DoZoomIn(GetScreenCenterPoint()); +} +void CLaiPuLaserView::OnZoomOut() +{ + DoZoomOut(GetScreenCenterPoint()); +} +//۲ +void CLaiPuLaserView::OnWorkSpaceView() +{ + DoZoomFull(); +} +#endif +#if 1// +void CLaiPuLaserView::OnUndo() +{ + gCommandMgr.Undo(); + RefreshView(); + //ѡ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnUpdateUndo(CCmdUI* pCmdUI) +{ + if(gCommandMgr.HasUndoCmd()) + { + pCmdUI->Enable(true); + } + else + { + pCmdUI->Enable(false); + } + pCmdUI->SetCheck(false); +} +void CLaiPuLaserView::OnRedo() +{ + gCommandMgr.Redo(); + RefreshView(); + //ѡ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnUpdateRedo(CCmdUI* pCmdUI) +{ + if(gCommandMgr.HasRedoCmd()) + { + pCmdUI->Enable(true); + } + else + { + pCmdUI->Enable(false); + } + pCmdUI->SetCheck(false); +} +#endif +#if 1// +void CLaiPuLaserView::OnToolPoint() +{ + gMouseToolMgr.SetMouseTool(_TOOL_POINT); +} + +void CLaiPuLaserView::OnToolRect() +{ + gMouseToolMgr.SetMouseTool(_TOOL_RECT); + gLayer.SelAllObj(); + gLayer.RevSelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnUpdateToolRect(CCmdUI* pCmdUI) +{ + pCmdUI->Enable(true); + pCmdUI->SetCheck(gMouseToolMgr.GetToolType()==_TOOL_RECT?1:0); +} +// +void CLaiPuLaserView::OnToolOnePoint() +{ + gMouseToolMgr.SetMouseTool(_TOOL_ONE_POINT); + gLayer.SelAllObj(); + gLayer.RevSelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnUpdateToolOnePoint(CCmdUI* pCmdUI) +{ + pCmdUI->Enable(true); + pCmdUI->SetCheck(gMouseToolMgr.GetToolType()==_TOOL_ONE_POINT?1:0); +} +void CLaiPuLaserView::OnToolLaserCoord() +{ + gMouseToolMgr.SetMouseTool(_TOOL_LASER_COORD); + RefreshView(); +} +void CLaiPuLaserView::OnUpdateToolLaserCoord(CCmdUI* pCmdUI) +{ + pCmdUI->Enable(false); + pCmdUI->SetCheck(gMouseToolMgr.GetToolType()==_TOOL_LASER_COORD?1:0); +} + +void CLaiPuLaserView::OnToolPolygon() +{ + +} +void CLaiPuLaserView::OnUpdateToolPolygon(CCmdUI* pCmdUI) +{ + +} + +void CLaiPuLaserView::OnToolCircle() +{ + gMouseToolMgr.SetMouseTool(_TOOL_CIRCLE); + gLayer.SelAllObj(); + gLayer.RevSelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnUpdateToolCircle(CCmdUI* pCmdUI) +{ + pCmdUI->Enable(true); + pCmdUI->SetCheck(gMouseToolMgr.GetToolType()==_TOOL_CIRCLE?1:0); +} + +void CLaiPuLaserView::OnToolLine() +{ + gMouseToolMgr.SetMouseTool(_TOOL_LINE); + gLayer.SelAllObj(); + gLayer.RevSelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnUpdateToolLine(CCmdUI* pCmdUI) +{ + pCmdUI->Enable(true); + pCmdUI->SetCheck(gMouseToolMgr.GetToolType()==_TOOL_LINE?1:0); +} +void CLaiPuLaserView::OnToolPline() +{ + gMouseToolMgr.SetMouseTool(_TOOL_PLINE); + gLayer.SelAllObj(); + gLayer.RevSelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnUpdateToolPline(CCmdUI* pCmdUI) +{ + pCmdUI->Enable(true); + pCmdUI->SetCheck(gMouseToolMgr.GetToolType()==_TOOL_PLINE?1:0); +} +#endif + +#if 1//ͼβ +void CLaiPuLaserView::OnUpdateObjOperate(CCmdUI* pCmdUI) +{ + if(gLayer.HasObjSel()) + { + pCmdUI->Enable(true); + } + else + { + pCmdUI->Enable(false); + } +} +void CLaiPuLaserView::OnSelAllObj() +{ + if(gDraw->IsEditLayerObj()) + { + gLayer.SelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); + } +} +void CLaiPuLaserView::OnMoveToCenter() +{ + MoveSelObjToCenter(); +} +void CLaiPuLaserView::MoveSelObjToCenter() +{ + CLayer & layer = gLayer; + Dbxy pt = layer.GetSelObjRect().GetCenterPt(); + layer.OnMove(pt.x*(-1),pt.y*(-1)); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +//ѡ +void CLaiPuLaserView::OnRevSelObj() +{ + if(gDraw->IsEditLayerObj()) + { + gLayer.RevSelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); + } +} +void CLaiPuLaserView::OnDelSelObj() +{ + CLayer &layer = gLayer; + if(layer.HasObjSel()) + { + //ָ + CCommandDelete *pCmd = new CCommandDelete; + gCommandMgr.AddUndoCommand(pCmd); + pCmd->Excute(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); + } +} +//ˮƽ +void CLaiPuLaserView::OnMirrorH() +{ + gLayer.OnMirror(_X); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +//ֱ +void CLaiPuLaserView::OnMirrorV() +{ + gLayer.OnMirror(_Y); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +//ת90 +void CLaiPuLaserView::OnRotato90L() +{ + gLayer.OnRotato(90); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnRotato90R() +{ + gLayer.OnRotato(-90); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnToolRotato() +{ + gMouseToolMgr.SetMouseTool(_TOOL_ROTATO); +} +void CLaiPuLaserView::OnCut() +{ + gMouseToolMgr.SetMouseTool(_TOOL_CUT); + gLayer.SelAllObj(); + gLayer.RevSelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +//Ͻڵ +void CLaiPuLaserView::OnBreak() +{ + gMouseToolMgr.SetMouseTool(_TOOL_BREAK_NODE); +} +void CLaiPuLaserView::OnChamfer() +{ +} +void CLaiPuLaserView::OnFillet() +{ +} +//ֽ +void CLaiPuLaserView::OnExplode() +{ + gLayer.OnExplode(); + RefreshView(); +} +//ϲ +void CLaiPuLaserView::OnJoin() +{ + if(gLayer.OnJoin()) + { + RefreshView(); + gLogMgr->WriteDebugLog("OnJoin ----OK "); + } + else + { + gLogMgr->WriteDebugLog("OnJoin ----Err "); + } +} +void CLaiPuLaserView::OnCopy() +{ + gMouseToolMgr.SetMouseTool(_TOOL_COPY); +} +void CLaiPuLaserView::OnMove() +{ + gMouseToolMgr.SetMouseTool(_TOOL_MOVE2); +} +//ת +void CLaiPuLaserView::OnReverse() +{ + gLayer.OnReverseSelObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CLaiPuLaserView::OnAddNode() +{ + gMouseToolMgr.SetMouseTool(_TOOL_ADD_NODE); + RefreshView(); +} +void CLaiPuLaserView::OnDelNode() +{ + gMouseToolMgr.SetMouseTool(_TOOL_DEL_NODE); + RefreshView(); +} +void CLaiPuLaserView::OnMeasure() +{ + gMouseToolMgr.SetMouseTool(_TOOL_MEASURE); + gLayer.SelAllObj(); + gLayer.RevSelAllObj(); + RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +// +void CLaiPuLaserView::OnArray() +{ + CDlgArray dlg; + if(dlg.DoModal()==IDOK) + { + RefreshView(); + } +} + +void CLaiPuLaserView::OnObjFill() +{ + +} + +#endif +#if 1 +//view ɫ +BOOL CLaiPuLaserView::OnEraseBkgnd(CDC *pDC) +{ + if(m_bEraseBkgnd2&&m_bEraseBkgnd) + { + CScrollView::OnEraseBkgnd(pDC); + CRect rect; + GetClientRect(rect); + CBrush BkgndBrush; + COLORREF color = RGB_BLACK; + color = gDraw->GetBkgndColor(); + BkgndBrush.CreateSolidBrush(color); + pDC->FillRect(&rect,&BkgndBrush); + } + m_bEraseBkgnd = true;//ָ + return TRUE; +} +BOOL CLaiPuLaserView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) +{ + return true; +} +//ػview +void CLaiPuLaserView::RefreshView() +{ + #if 1 + if(gDraw->IsbDlgLayerViewShow()) + { + CString WndName = "Wafer View"; + CString WndMsg = "Invalidate"; + SendMsgToWnd(WndName,WndMsg); + } + else + { + //Ҫڱ༭ˢ + if(gDraw->IsbObjEditMode()) + { + gCriticalSection_ViewInvalidate.Lock(); + gLogMgr->WriteDebugLog("RefreshView"); + + Invalidate(); + + gCriticalSection_ViewInvalidate.Unlock(); + } + } + #else + Invalidate(); + #endif +} +CPoint CLaiPuLaserView::GetScreenCenterPoint() +{ + CClientDC dc(this); + OnPrepareDC(&dc); + + //ȡͻΧ + CRect rect; + GetClientRect(&rect);//ȡڿͻ + dc.DPtoLP(rect); + //ĵ + CPoint Cpoint; + Cpoint.x = (rect.left + (rect.right-rect.left)/2); + Cpoint.y = (rect.top + (rect.bottom-rect.top)/2); + + return Cpoint; +} +//귶Χ +void CLaiPuLaserView::LimitCursor() +{ + CRect rect; + GetClientRect(&rect);//ȡڿͻ + ClientToScreen(&rect);//εûתĻ + ClipCursor(&rect);//귶Χ +} +//ͷŶ귶Χ +void CLaiPuLaserView::ReleseLimitCursor() +{ + ClipCursor(NULL);//ͷ +} +// +void CLaiPuLaserView::SetCursorStyle(MOUSE_TOOL type) +{ + switch(type) + { + case _TOOL_POINT: + SetCursor(AfxGetApp()->LoadCursor(IDC_MOUSE_POINT)); + break; + case _TOOL_RECT: + case _TOOL_LINE: + case _TOOL_PLINE: + case _TOOL_CIRCLE: + case _TOOL_MOVE2: + case _TOOL_ROTATO: + case _TOOL_COPY: + case _TOOL_MEASURE: + case _TOOL_ONE_POINT: + case _TOOL_LASER_COORD: + case _TOOL_PT_MOVE_TO_CCD: + case _TOOL_SET_MARK_PT: + SetCursor(AfxGetApp()->LoadCursor(IDC_MOUSE_DRAW)); + break; + case _TOOL_TEXT: + case _TOOL_BARCODE: + SetCursor(AfxGetApp()->LoadCursor(IDC_MOUSE_TXT)); + break; + case _TOOL_MOVE: + SetCursor(AfxGetApp()->LoadCursor(IDC_MOUSE_MOVE)); + break; + case _TOOL_CUT: + case _TOOL_ADD_NODE: + case _TOOL_DEL_NODE: + case _TOOL_BREAK_NODE: + SetCursor(AfxGetApp()->LoadCursor(IDC_MOUSE_NODE)); + break; + case _TOOL_MOVE_NODE: + case _TOOL_STRETCH: + SetCursor(AfxGetApp()->LoadCursor(IDC_MOUSE_HAND)); + break; + default: + break; + } +} +#endif + diff --git a/LaipuDrawing/LaiPuLaserView.h b/LaipuDrawing/LaiPuLaserView.h new file mode 100644 index 0000000..ee38b32 --- /dev/null +++ b/LaipuDrawing/LaiPuLaserView.h @@ -0,0 +1,219 @@ + +// LaiPuLaserView.h : CLaiPuLaserView Ľӿ +// + +#pragma once +#include "LaiPuLaserDoc.h" +#include "EnumDirection.h" +#include "GlobalDefine.h" + +#if 1//view +#define VIEW_SCALE1 (0.000097) +#define VIEW_SCALE2 (0.000121) +#define VIEW_SCALE3 (0.000151) +#define VIEW_SCALE4 (0.000189) +#define VIEW_SCALE5 (0.000236) +#define VIEW_SCALE6 (0.000295) +#define VIEW_SCALE7 (0.000369) +#define VIEW_SCALE8 (0.000461) +#define VIEW_SCALE9 (0.000576) +#define VIEW_SCALE10 (0.000721) +#define VIEW_SCALE11 (0.000901) +#define VIEW_SCALE12 (0.001126) +#define VIEW_SCALE13 (0.001407) +#define VIEW_SCALE14 (0.001759) +#define VIEW_SCALE15 (0.002199) +#define VIEW_SCALE16 (0.002749) +#define VIEW_SCALE17 (0.003436) +#define VIEW_SCALE18 (0.004295) +#define VIEW_SCALE19 (0.005369) +#define VIEW_SCALE20 (0.006711) +#define VIEW_SCALE21 (0.008389) +#define VIEW_SCALE22 (0.010486) +#define VIEW_SCALE23 (0.013107) +#define VIEW_SCALE24 (0.016384) +#define VIEW_SCALE25 (0.020480) +#define VIEW_SCALE26 (0.025600) +#define VIEW_SCALE27 (0.032001) +#define VIEW_SCALE28 (0.040001) +#define VIEW_SCALE29 (0.050001) +#define VIEW_SCALE30 (0.062501) +#define VIEW_SCALE31 (0.078126) +#define VIEW_SCALE32 (0.097658) +#define VIEW_SCALE33 (0.122072) +#define VIEW_SCALE34 (0.152590) +#define VIEW_SCALE35 (0.190738) +#define VIEW_SCALE36 (0.238423) +#define VIEW_SCALE37 (0.298028) +#define VIEW_SCALE38 (0.372535) +#define VIEW_SCALE39 (0.465669) +#define VIEW_SCALE40 (0.582086) +#define VIEW_SCALE41 (0.727608) +#define VIEW_SCALE42 (0.909510) +#define VIEW_SCALE43 (1.136887) +#define VIEW_SCALE44 (1.421109) +#define VIEW_SCALE45 (1.776387) +#define VIEW_SCALE46 (2.220483) +#define VIEW_SCALE47 (2.775604) +#define VIEW_SCALE48 (3.469505) +#define DEFAULT_SCALE VIEW_SCALE17 //ʼviewű +#define SCALE_ONE_TIME (1.25) //ÿű +#define MAX_SCALE (3.0) //Ŵ +#define MIN_SCALE VIEW_SCALE1 //СС +#endif + + +class CLaiPuLaserView : public CScrollView +{ +protected: // л + CLaiPuLaserView(); + DECLARE_DYNCREATE(CLaiPuLaserView) +// д +public: + virtual void OnDraw(CDC* pDC); // дԻƸͼ + virtual BOOL PreCreateWindow(CREATESTRUCT& cs); + virtual void OnInitialUpdate(); + virtual void OnPrepareDC(CDC* pDC, CPrintInfo* pInfo = NULL); + void LimitCursor(); + void ReleseLimitCursor(); + HDC GetHDC(); + CDC* GetCDC(); + afx_msg BOOL PreTranslateMessage(MSG* pMsg); +protected: + virtual BOOL OnPreparePrinting(CPrintInfo* pInfo); + virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo); + virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo); +// ʵ +public: + virtual ~CLaiPuLaserView(); +#ifdef _DEBUG + virtual void AssertValid() const; + virtual void Dump(CDumpContext& dc) const; +#endif + +// +public: + CLaiPuLaserDoc* GetDocument() const; + int GetCurrScaleVal(int val);//λ + double GetCurrScaleVal(double val);//λ: + void RefreshView(); + void OnEscape(); + void MoveObjToPtByDir(DIRECTION dir,double Dis); + afx_msg BOOL OnMouseWheel(UINT nFlags,short zDelta,CPoint pt); + double GetCurZoomScale(){return m_zoomScale;}; + afx_msg void OnZoomIn(); + afx_msg void OnZoomOut(); + void SetCursorStyle(MOUSE_TOOL type); + int DoZoomFull(); + void RectView(double scale,Dbxy pt = Dbxy(0,0)); + void NotEraseBkgndOneTime(){m_bEraseBkgnd = false;}; + void MoveSelObjToCenter(); + void SetbEraseBkgnd(bool b){m_bEraseBkgnd2 = b;} + afx_msg BOOL OnEraseBkgnd(CDC* pDC);//ɫ +private: + void OnArrowDir(DIRECTION dir); + void OnSpace(); + void OnCtrl(); +private: + bool m_bFirstIn;//Ƿһν + bool m_bCtrl;//ctrl Ƿ + bool m_bEraseBkgnd;//Ƿػ汳ɫ(־λÿλԶָ) + bool m_bEraseBkgnd2;//Ƿػ汳ɫ(Զָ) +private: +#if 1//view + void SetZoomSizes(SIZE sizeTotal, const SIZE& sizePage = sizeDefault, const SIZE& sizeLine = sizeDefault); + void CenterOnLogicalPoint(CPoint ptCenter); + CPoint GetLogicalCenterPoint(void); + + // Zooming functions + int DoZoomIn(CPoint CenterPoint); + int DoZoomOut(CPoint CenterPoint); + + + // Override this to get notified of zoom scale change + virtual void NotifyZoom(void) {}; + + // Zooming utility functions + void ViewDPtoLP (LPPOINT lpPoints, int nCount = 1); + void ViewLPtoDP (LPPOINT lpPoints, int nCount = 1); + void ClientToDevice(CPoint &point); + void NormalizeRect(CRect &rect); + void PersistRatio(const CSize &orig, CSize &dest, CPoint &remainder); + void CalcBars(void); + CRect m_ptDragRect; + CSize m_origTotalDev; // Origional total size in device units + CSize m_origPageDev; // Origional per page scroll size in device units + CSize m_origLineDev; // Origional per line scroll size in device units + double m_zoomScale;//ǰű +#endif + CPoint GetScreenCenterPoint(); + +// ɵϢӳ亯 +protected: + afx_msg void OnFilePrintPreview(); + afx_msg void OnLButtonDown(UINT nFlags, CPoint point); + afx_msg void OnLButtonUp(UINT nFlags, CPoint point); + afx_msg void OnRButtonDown(UINT nFlags, CPoint point); + afx_msg void OnRButtonUp(UINT nFlags, CPoint point); + afx_msg void OnMButtonDown(UINT nFlags, CPoint point); + afx_msg void OnMButtonUp(UINT nFlags, CPoint point); + afx_msg void OnContextMenu(CWnd* pWnd, CPoint point); + + afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar); + afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar); + + afx_msg void OnMouseMove(UINT nFlags, CPoint point); + afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message); + afx_msg void OnToolPoint(); + afx_msg void OnUndo(); + afx_msg void OnArray(); + afx_msg void OnCut(); + afx_msg void OnReverse(); + afx_msg void OnAddNode(); + afx_msg void OnDelNode(); + afx_msg void OnBreak(); + afx_msg void OnChamfer(); + afx_msg void OnFillet(); + afx_msg void OnExplode(); + afx_msg void OnMeasure(); + afx_msg void OnJoin(); + afx_msg void OnUpdateUndo(CCmdUI* pCmdUI); + afx_msg void OnRedo(); + afx_msg void OnUpdateRedo(CCmdUI* pCmdUI); + afx_msg void OnToolRect(); + afx_msg void OnUpdateToolRect(CCmdUI* pCmdUI); + afx_msg void OnToolOnePoint(); + afx_msg void OnUpdateToolOnePoint(CCmdUI* pCmdUI); + afx_msg void OnToolLaserCoord(); + afx_msg void OnUpdateToolLaserCoord(CCmdUI* pCmdUI); + afx_msg void OnToolPolygon(); + afx_msg void OnUpdateToolPolygon(CCmdUI* pCmdUI); + afx_msg void OnToolRotato(); + afx_msg void OnUpdateObjOperate(CCmdUI* pCmdUI); + afx_msg void OnToolCircle(); + afx_msg void OnUpdateToolCircle(CCmdUI* pCmdUI); + afx_msg void OnToolLine(); + afx_msg void OnUpdateToolLine(CCmdUI* pCmdUI); + afx_msg void OnToolPline(); + afx_msg void OnUpdateToolPline(CCmdUI* pCmdUI); + afx_msg void OnSelAllObj(); + afx_msg void OnRevSelObj(); + afx_msg void OnMoveToCenter(); + afx_msg void OnObjFill(); + afx_msg void OnDelSelObj(); + afx_msg void OnWorkSpaceView() ; + afx_msg void OnMirrorH(); + afx_msg void OnMirrorV(); + afx_msg void OnRotato90L(); + afx_msg void OnRotato90R(); + afx_msg void OnCopy(); + afx_msg void OnMove(); + DECLARE_MESSAGE_MAP() +}; + +#ifndef _DEBUG // LaiPuLaserView.cpp еĵ԰汾 +inline CLaiPuLaserDoc* CLaiPuLaserView::GetDocument() const + { return reinterpret_cast(m_pDocument); } +#endif + +extern CLaiPuLaserView* m_pView; \ No newline at end of file diff --git a/LaipuDrawing/LaipuDrawing.sln b/LaipuDrawing/LaipuDrawing.sln new file mode 100644 index 0000000..f46b632 --- /dev/null +++ b/LaipuDrawing/LaipuDrawing.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LaipuDrawing", "LaipuDrawing.vcxproj", "{2AD399A8-0907-418E-8F7F-42C75175C7FE}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {2AD399A8-0907-418E-8F7F-42C75175C7FE}.Debug|x86.ActiveCfg = Debug|Win32 + {2AD399A8-0907-418E-8F7F-42C75175C7FE}.Debug|x86.Build.0 = Debug|Win32 + {2AD399A8-0907-418E-8F7F-42C75175C7FE}.Release|x86.ActiveCfg = Release|Win32 + {2AD399A8-0907-418E-8F7F-42C75175C7FE}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/LaipuDrawing/LaipuDrawing.vcxproj b/LaipuDrawing/LaipuDrawing.vcxproj new file mode 100644 index 0000000..838220e --- /dev/null +++ b/LaipuDrawing/LaipuDrawing.vcxproj @@ -0,0 +1,1056 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {2AD399A8-0907-418E-8F7F-42C75175C7FE} + LaiPuLaserDrawing + MFCProj + LaipuDrawing + 8.1 + + + + Application + true + MultiByte + Static + v140 + + + Application + false + true + MultiByte + Static + v140 + + + + + + + + + + + + + true + $(IncludePath) + $(ReferencePath) + $(LibraryPath) + D:\program\Laser_TUIHUO\00_COMMON_PGM\03_YMTC\ANLAA\LaiPuLaser\Debug;$(ExecutablePath) + + + false + + + + Use + Level3 + Disabled + WIN32;_WINDOWS;_DEBUG;%(PreprocessorDefinitions) + MultiThreadedDebug + $(PYLON_ROOT)\include;$(PYLON_GENICAM_ROOT)\library\CPP\include;%(AdditionalIncludeDirectories) + false + false + + + Windows + true + C:\Program Files (x86)\Advantech\Common Motion\Public;$(PYLON_GENICAM_ROOT)\library\CPP\Lib\Win32_i86;$(PYLON_ROOT)\lib\Win32;%(AdditionalLibraryDirectories) + $(OutDir)$(TargetName)$(TargetExt) + + + false + true + _DEBUG;%(PreprocessorDefinitions) + + + 0x0804 + _DEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + copy /Y "$(OutDir)$(TargetName)$(TargetExt)" "E:\LaipuLaser\" +copy /Y "$(OutDir)$(TargetName).pdb" "E:\LaipuLaser\" + + + + + Level3 + Use + MaxSpeed + true + true + WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions) + + + Windows + true + true + true + + + false + true + NDEBUG;%(PreprocessorDefinitions) + + + 0x0804 + NDEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + copy /Y "$(OutDir)$(TargetName)$(TargetExt)" "E:\LaipuLaser\" +copy /Y "$(OutDir)$(TargetName).pdb" "E:\LaipuLaser\" + + + + + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + + + + Document + $(OutDir)LaiPuLaser.chm;%(Outputs) + hlp\HTMLDefines.h;%(AdditionalInputs) + start /wait hhc "hlp\LaiPuLaser.hhp" +if not exist "hlp\LaiPuLaser.chm" goto :HelpError +copy "hlp\LaiPuLaser.chm" "$(OutDir)LaiPuLaser.chm" +goto :HelpDone +:HelpError +echo hlp\LaiPuLaser.hhp(1) : error:创建帮助文件时遇到问题 +echo. +:HelpDone +echo. + + 正在生成帮助文件... + $(OutDir)LaiPuLaser.chm;%(Outputs) + hlp\HTMLDefines.h;%(AdditionalInputs) + start /wait hhc "hlp\LaiPuLaser.hhp" +if not exist "hlp\LaiPuLaser.chm" goto :HelpError +copy "hlp\LaiPuLaser.chm" "$(OutDir)LaiPuLaser.chm" +goto :HelpDone +:HelpError +echo hlp\LaiPuLaser.hhp(1) : error:创建帮助文件时遇到问题 +echo. +:HelpDone +echo. + + 正在生成帮助文件... + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + hlp\HTMLDefines.h;%(Outputs) + echo // 生成的帮助映射文件。使用者为LaiPuLaser.HHP. > "hlp\HTMLDefines.h" +echo. > "hlp\HTMLDefines.h" +echo // 命令(ID_* 和 IDM_*) >> "hlp\HTMLDefines.h" +makehm /h ID_,HID_,0x10000 IDM_,HIDM_,0x10000 "%(FullPath)" >> "hlp\HTMLDefines.h" +echo. >> "hlp\HTMLDefines.h" +echo // 提示(IDP_*) >> "hlp\HTMLDefines.h" +makehm /h IDP_,HIDP_,0x30000 "%(FullPath)" >> "hlp\HTMLDefines.h" +echo. >> "hlp\HTMLDefines.h" +echo // 资源(IDR_*) >> "hlp\HTMLDefines.h" +makehm /h IDR_,HIDR_,0x20000 "%(FullPath)" >> "hlp\HTMLDefines.h" +echo. >> "hlp\HTMLDefines.h" +echo // 对话框(IDD_*) >> "hlp\HTMLDefines.h" +makehm /h IDD_,HIDD_,0x20000 "%(FullPath)" >> "hlp\HTMLDefines.h" +echo. >> "hlp\HTMLDefines.h" +echo // 框架控件(IDW_*) >> "hlp\HTMLDefines.h" +makehm /h /a afxhh.h IDW_,HIDW_,0x50000 "%(FullPath)" >> "hlp\HTMLDefines.h" + + 正在生成帮助编译器的映射文件... + hlp\HTMLDefines.h;%(Outputs) + echo // 生成的帮助映射文件。使用者为LaiPuLaser.HHP. > "hlp\HTMLDefines.h" +echo. > "hlp\HTMLDefines.h" +echo // 命令(ID_* 和 IDM_*) >> "hlp\HTMLDefines.h" +makehm /h ID_,HID_,0x10000 IDM_,HIDM_,0x10000 "%(FullPath)" >> "hlp\HTMLDefines.h" +echo. >> "hlp\HTMLDefines.h" +echo // 提示(IDP_*) >> "hlp\HTMLDefines.h" +makehm /h IDP_,HIDP_,0x30000 "%(FullPath)" >> "hlp\HTMLDefines.h" +echo. >> "hlp\HTMLDefines.h" +echo // 资源(IDR_*) >> "hlp\HTMLDefines.h" +makehm /h IDR_,HIDR_,0x20000 "%(FullPath)" >> "hlp\HTMLDefines.h" +echo. >> "hlp\HTMLDefines.h" +echo // 对话框(IDD_*) >> "hlp\HTMLDefines.h" +makehm /h IDD_,HIDD_,0x20000 "%(FullPath)" >> "hlp\HTMLDefines.h" +echo. >> "hlp\HTMLDefines.h" +echo // 框架控件(IDW_*) >> "hlp\HTMLDefines.h" +makehm /h /a afxhh.h IDW_,HIDW_,0x50000 "%(FullPath)" >> "hlp\HTMLDefines.h" + + 正在生成帮助编译器的映射文件... + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Create + Create + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/LaipuDrawing/LaipuDrawing.vcxproj.filters b/LaipuDrawing/LaipuDrawing.vcxproj.filters new file mode 100644 index 0000000..2c7f7fb --- /dev/null +++ b/LaipuDrawing/LaipuDrawing.vcxproj.filters @@ -0,0 +1,2145 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {aa39c02c-0305-4ccc-b403-2019854126a2} + hhp;hhc;hhk;gif;jpg + + + {71acd02b-0bc1-45bd-81aa-9f5ba2c20efb} + htm;html + + + + + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + HTML 帮助文件 + + + HTML 帮助文件 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + HTML 帮助主题 + + + 资源文件 + + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + 资源文件 + + + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + + + 资源文件 + + + + + HTML 帮助文件 + + + 头文件 + + + \ No newline at end of file diff --git a/LaipuDrawing/LaipuDrawing.vcxproj.user b/LaipuDrawing/LaipuDrawing.vcxproj.user new file mode 100644 index 0000000..d7096bf --- /dev/null +++ b/LaipuDrawing/LaipuDrawing.vcxproj.user @@ -0,0 +1,16 @@ + + + + WindowsLocalDebugger + E:\LaipuLaser\$(TargetName)$(TargetExt) + E:\LaipuLaser\ + + + false + + + E:\LaipuLaser\$(TargetName)$(TargetExt) + WindowsLocalDebugger + E:\LaipuLaser\ + + \ No newline at end of file diff --git a/LaipuDrawing/LanguageMgr.cpp b/LaipuDrawing/LanguageMgr.cpp new file mode 100644 index 0000000..9eefd08 --- /dev/null +++ b/LaipuDrawing/LanguageMgr.cpp @@ -0,0 +1,348 @@ +#include "StdAfx.h" +#include "LanguageMgr.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "MyDlgView.h" + + +#define LANGUAGE_PARA_FILE _T("\\Language.bin") + +CLanguageMgr *gLanguageMgr = new CLanguageMgr; +CLanguageMgr::CLanguageMgr(void) +{ + m_bEnglishMode = false;//Ӣģʽ +} +CLanguageMgr::~CLanguageMgr(void) +{ +} +CMFCPropertyGridProperty *CLanguageMgr::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = GetParDirName();//洢· + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T(""); + GroupName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + { + //Աӳ + Name = _T("m_bEnglishMode");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bEnglishMode); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Ӣģʽ"); + Description = _T("Ӣģʽ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bEnglishMode, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + } + return pGroup; +} +//ʱ +void CLanguageMgr::OnAppInitialize() +{ + //ʼ + InitLanguageTxt(); + //ʾ + UpdateLanguageTxt(); +} +//仯ʱ +void CLanguageMgr::OnPropertyChanged() +{ + //ʾ + UpdateLanguageTxt(); +} + +//ʼ +void CLanguageMgr::InitLanguageTxt() +{ + gLogMgr->WriteDebugLog("Func--->CLanguageMgr::InitLanguageTxt"); + + m_LanguageTxtVec.clear(); + CLanguageTxt LanguageTxt; + LanguageTxt.m_TxtName = "LANGUAGE_SELECT_ALL";LanguageTxt.m_TxtEnglish = "Select All";LanguageTxt.m_TxtChinese = "ȫѡ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_MANUAL_ANNEAL";LanguageTxt.m_TxtEnglish = "Manual Anneal";LanguageTxt.m_TxtChinese = "ֶ˻"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_ADD_JOB";LanguageTxt.m_TxtEnglish = "Add Job";LanguageTxt.m_TxtChinese = "Job"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_START_JOB";LanguageTxt.m_TxtEnglish = "Job Start";LanguageTxt.m_TxtChinese = "ʼJob"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PAUSE_JOB";LanguageTxt.m_TxtEnglish = "Job Pause";LanguageTxt.m_TxtChinese = "ͣJob"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_STOP_JOB";LanguageTxt.m_TxtEnglish = "Job Stop";LanguageTxt.m_TxtChinese = "ֹJob"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_CANCEL_JOB";LanguageTxt.m_TxtEnglish = "Cancel Job";LanguageTxt.m_TxtChinese = "ȡJob"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_JOB_QUEUE";LanguageTxt.m_TxtEnglish = "Job Queue";LanguageTxt.m_TxtChinese = "Job"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_SECS_STATE";LanguageTxt.m_TxtEnglish = "Secs State";LanguageTxt.m_TxtChinese = "Secs״̬"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_COMM_STATE";LanguageTxt.m_TxtEnglish = "Comm State:";LanguageTxt.m_TxtChinese = "ͨ״̬:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_CTRL_STATE";LanguageTxt.m_TxtEnglish = "Control State:";LanguageTxt.m_TxtChinese = "״̬:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PROCESS_STATE";LanguageTxt.m_TxtEnglish = "Process State";LanguageTxt.m_TxtChinese = "״̬:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PORT1_STATE";LanguageTxt.m_TxtEnglish = "Port1 State";LanguageTxt.m_TxtChinese = "Port1״̬:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PORT2_STATE";LanguageTxt.m_TxtEnglish = "Port2 State";LanguageTxt.m_TxtChinese = "Port2״̬:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_LASER_POW_RET";LanguageTxt.m_TxtEnglish = "laser Beam result";LanguageTxt.m_TxtChinese = "߼"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_CUR_PROCESS_RCP";LanguageTxt.m_TxtEnglish = "Current Process Recipe";LanguageTxt.m_TxtChinese = "ǰRecipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_JOB_TIME";LanguageTxt.m_TxtEnglish = "Job Time:";LanguageTxt.m_TxtChinese = "Jobʱ:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PROCESS_TIME";LanguageTxt.m_TxtEnglish = "Process time:";LanguageTxt.m_TxtChinese = "ʱ:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_NO_WAFER";LanguageTxt.m_TxtEnglish = "NoWafer";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_NO_SEL";LanguageTxt.m_TxtEnglish = "NoSelect";LanguageTxt.m_TxtChinese = "δѡ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_UNTREATED";LanguageTxt.m_TxtEnglish = "Untreated";LanguageTxt.m_TxtChinese = "δ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_WAITING";LanguageTxt.m_TxtEnglish = "Waiting";LanguageTxt.m_TxtChinese = "ȴ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PROCESSING";LanguageTxt.m_TxtEnglish = "Processing";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_FINISHED";LanguageTxt.m_TxtEnglish = "Finished";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_NO_FINISHED";LanguageTxt.m_TxtEnglish = "NoFinished";LanguageTxt.m_TxtChinese = "δ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_USER";LanguageTxt.m_TxtEnglish = "User:";LanguageTxt.m_TxtChinese = "û:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_AUTHORITY";LanguageTxt.m_TxtEnglish = "Authority:";LanguageTxt.m_TxtChinese = "Ȩ:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_LASER_SLEEP_TIME";LanguageTxt.m_TxtEnglish = "Laser Sleep Time:";LanguageTxt.m_TxtChinese = "ʱ:"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_ACCOUNT";LanguageTxt.m_TxtEnglish = "Account";LanguageTxt.m_TxtChinese = "˻"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_ALARM";LanguageTxt.m_TxtEnglish = "Alarm";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_INIT_DEV";LanguageTxt.m_TxtEnglish = "Dev Init";LanguageTxt.m_TxtChinese = "Ԥ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POS_X";LanguageTxt.m_TxtEnglish = "RPosX";LanguageTxt.m_TxtChinese = "λX"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POS_Y";LanguageTxt.m_TxtEnglish = "RPosY";LanguageTxt.m_TxtChinese = "λY"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POS_Z";LanguageTxt.m_TxtEnglish = "RPosZ";LanguageTxt.m_TxtChinese = "λZ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_FEEDBACK_X";LanguageTxt.m_TxtEnglish = "FPosX";LanguageTxt.m_TxtChinese = "դX"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_FEEDBACK_Y";LanguageTxt.m_TxtEnglish = "FPosY";LanguageTxt.m_TxtChinese = "դY"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_FEEDBACK_Z";LanguageTxt.m_TxtEnglish = "FPosZ";LanguageTxt.m_TxtChinese = "դZ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_CUR_POS";LanguageTxt.m_TxtEnglish = "Currect Pos(mm)";LanguageTxt.m_TxtChinese = "(mm)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_LASER_POW_INFO";LanguageTxt.m_TxtEnglish = "Laser Pow(W)";LanguageTxt.m_TxtChinese = "⹦Ϣ(W)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PATH_POW";LanguageTxt.m_TxtEnglish = "Path Pow";LanguageTxt.m_TxtChinese = "·"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_VALID_POW";LanguageTxt.m_TxtEnglish = "Wafer Power(W)";LanguageTxt.m_TxtChinese = "Ч"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_GREEN_LASER_INFO";LanguageTxt.m_TxtEnglish = "Green Laser Info";LanguageTxt.m_TxtChinese = "̹Ϣ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_FRE";LanguageTxt.m_TxtEnglish = "frequency(Hz)";LanguageTxt.m_TxtChinese = "Ƶ(Hz)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_SET_CURR";LanguageTxt.m_TxtEnglish = "Set Curr(A)";LanguageTxt.m_TxtChinese = "õ(A)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_REAL_CURR";LanguageTxt.m_TxtEnglish = "Real Curr(A)";LanguageTxt.m_TxtChinese = "ʵʵ(A)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_REAL_CURR1";LanguageTxt.m_TxtEnglish = "Real Curr1(A)";LanguageTxt.m_TxtChinese = "ʵʵ1(A)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_REAL_CURR2";LanguageTxt.m_TxtEnglish = "Real Curr2(A)";LanguageTxt.m_TxtChinese = "ʵʵ2(A)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_REAL_VOL";LanguageTxt.m_TxtEnglish = "Real Voltage(V)";LanguageTxt.m_TxtChinese = "ѹ(V)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PULSE_DELAY";LanguageTxt.m_TxtEnglish = "Pulse Delay(ns)";LanguageTxt.m_TxtChinese = "ʱ(ns)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PULSE_W_NS";LanguageTxt.m_TxtEnglish = "Pulse W(ns)";LanguageTxt.m_TxtChinese = "(ns)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_LASER_WATER_FLOW";LanguageTxt.m_TxtEnglish = "Water Flow";LanguageTxt.m_TxtChinese = "ˮ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RED_LASER_INFO";LanguageTxt.m_TxtEnglish = "Red Laser Info";LanguageTxt.m_TxtChinese = "Ϣ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PULSE_W_US";LanguageTxt.m_TxtEnglish = "Pulse W(us)";LanguageTxt.m_TxtChinese = "(us)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_DIS_MEASURE";LanguageTxt.m_TxtEnglish = "Laser Distance Measure";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_DIS_READ_VAL";LanguageTxt.m_TxtEnglish = "Read Val(mm)";LanguageTxt.m_TxtChinese = "ֵ(mm)"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_IO_SIGNAL";LanguageTxt.m_TxtEnglish = "I/O Signal";LanguageTxt.m_TxtChinese = "I/O ź"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_IO_LIST";LanguageTxt.m_TxtEnglish = "IO List";LanguageTxt.m_TxtChinese = "IO б"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_MAINTENANCE";LanguageTxt.m_TxtEnglish = "Maintenance";LanguageTxt.m_TxtChinese = "Թ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_MAIN_LASER_STATE";LanguageTxt.m_TxtEnglish = "Main Laser";LanguageTxt.m_TxtChinese = "̹״̬"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RED_LASER_STATE";LanguageTxt.m_TxtEnglish = "Red Laser";LanguageTxt.m_TxtChinese = "״̬"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POW_CHECK";LanguageTxt.m_TxtEnglish = "Pow Check";LanguageTxt.m_TxtChinese = "ʵ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PCS_CHECK";LanguageTxt.m_TxtEnglish = "Beam Check";LanguageTxt.m_TxtChinese = "߼"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_CLOSE_LASER";LanguageTxt.m_TxtEnglish = "Close Laser";LanguageTxt.m_TxtChinese = "رռ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_DEV_PAR";LanguageTxt.m_TxtEnglish = "Device Par";LanguageTxt.m_TxtChinese = "豸"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_GRAP_PAR";LanguageTxt.m_TxtEnglish = "Graphic Par";LanguageTxt.m_TxtChinese = "ͼβ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_GRAP_OP";LanguageTxt.m_TxtEnglish = "Graphic Operation";LanguageTxt.m_TxtChinese = "ͼβ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_OPEN";LanguageTxt.m_TxtEnglish = "Open";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_SAVE";LanguageTxt.m_TxtEnglish = "Save";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_EDIT_MODE";LanguageTxt.m_TxtEnglish = "Edit Mode";LanguageTxt.m_TxtChinese = "༭ģʽ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_SHOW_IDX";LanguageTxt.m_TxtEnglish = "Show Idx";LanguageTxt.m_TxtChinese = "ʾ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_FIRST_OBJ";LanguageTxt.m_TxtEnglish = "First Obj";LanguageTxt.m_TxtChinese = "һ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PER_OBJ";LanguageTxt.m_TxtEnglish = "Per Obj";LanguageTxt.m_TxtChinese = "ǰһ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_AFTER_OBJ";LanguageTxt.m_TxtEnglish = "After Obj";LanguageTxt.m_TxtChinese = "һ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_SORT_ADJUST";LanguageTxt.m_TxtEnglish = "Sort Adjust";LanguageTxt.m_TxtChinese = "˳"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_INSERT_IDX";LanguageTxt.m_TxtEnglish = "Insert Idx";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_INSERT_EXT";LanguageTxt.m_TxtEnglish = "Insert";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_REVERSED";LanguageTxt.m_TxtEnglish = "Reversed";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_S_SORT";LanguageTxt.m_TxtEnglish = "S Sort";LanguageTxt.m_TxtChinese = "S"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_SORT_DIR";LanguageTxt.m_TxtEnglish = "Dir";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_S_SORT_EXT";LanguageTxt.m_TxtEnglish = "Sort";LanguageTxt.m_TxtChinese = "Ӧ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POW_START";LanguageTxt.m_TxtEnglish = "Start";LanguageTxt.m_TxtChinese = "ʼ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POW_STOP";LanguageTxt.m_TxtEnglish = "Stop";LanguageTxt.m_TxtChinese = "ֹͣ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POW_SET";LanguageTxt.m_TxtEnglish = "Setup";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POW_COMMIT";LanguageTxt.m_TxtEnglish = "Commit";LanguageTxt.m_TxtChinese = "Ӧ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POW_RECORD";LanguageTxt.m_TxtEnglish = "Record";LanguageTxt.m_TxtChinese = "¼"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_POW_CLOSE";LanguageTxt.m_TxtEnglish = "Close";LanguageTxt.m_TxtChinese = "ر"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_LOAD";LanguageTxt.m_TxtEnglish = "Load";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_UNLOAD";LanguageTxt.m_TxtEnglish = "UnLoad";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_UNLOAD_SMIF";LanguageTxt.m_TxtEnglish = "UnLoad";LanguageTxt.m_TxtChinese = "Ϻ˳"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_MAPPING";LanguageTxt.m_TxtEnglish = "Load/Map";LanguageTxt.m_TxtChinese = "Load/Map"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_JOB_COMMIT";LanguageTxt.m_TxtEnglish = "Commit";LanguageTxt.m_TxtChinese = "ȷ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PCS";LanguageTxt.m_TxtEnglish = "PCS";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RECIPE_SET";LanguageTxt.m_TxtEnglish = "Recipe";LanguageTxt.m_TxtChinese = "Recipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_DEVICE_STATE";LanguageTxt.m_TxtEnglish = "Status";LanguageTxt.m_TxtChinese = "豸״̬"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RECORD";LanguageTxt.m_TxtEnglish = "Record";LanguageTxt.m_TxtChinese = "ӹ¼"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_DEV_SETUP";LanguageTxt.m_TxtEnglish = "Setup";LanguageTxt.m_TxtChinese = "ϵͳ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RCP_GROUP_NAME";LanguageTxt.m_TxtEnglish = "Group Name";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RCP_NAME";LanguageTxt.m_TxtEnglish = "Recipe Name";LanguageTxt.m_TxtChinese = "Recipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_COPY_RCP";LanguageTxt.m_TxtEnglish = "Copy Recipe";LanguageTxt.m_TxtChinese = "Recipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_PASTE_RCP";LanguageTxt.m_TxtEnglish = "Move Recipe";LanguageTxt.m_TxtChinese = "ƶRecipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RESET_RCP";LanguageTxt.m_TxtEnglish = "Reset Recipe";LanguageTxt.m_TxtChinese = "Recipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_TRANSFER_USE";LanguageTxt.m_TxtEnglish = "Transfer Use";LanguageTxt.m_TxtChinese = "Ƭ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_WORK_JOB_USE";LanguageTxt.m_TxtEnglish = "Work Job Use";LanguageTxt.m_TxtChinese = "ӹʹ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_ANNEAL_AREA";LanguageTxt.m_TxtEnglish = "Anneal Area";LanguageTxt.m_TxtChinese = "˻Χ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_AREA_IDX";LanguageTxt.m_TxtEnglish = "Area Idx";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RCP_COMMIT";LanguageTxt.m_TxtEnglish = "Commit";LanguageTxt.m_TxtChinese = "ӦRecipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RCP_GRP";LanguageTxt.m_TxtEnglish = "Recipe group";LanguageTxt.m_TxtChinese = "Recipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RCP_LIST";LanguageTxt.m_TxtEnglish = "Recipe List";LanguageTxt.m_TxtChinese = "Recipeб"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_CUR_COPY_RCP";LanguageTxt.m_TxtEnglish = "Cur Copy Recipe";LanguageTxt.m_TxtChinese = "ǰRecipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_CUR_SEL_RCP";LanguageTxt.m_TxtEnglish = "Cur Select Recipe";LanguageTxt.m_TxtChinese = "ǰѡRecipe"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_INIT_XYZ";LanguageTxt.m_TxtEnglish = "Init XYZ";LanguageTxt.m_TxtChinese = "ʼXYZ"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_OPEN_LASER_LDD";LanguageTxt.m_TxtEnglish = "Open Laser Ldd";LanguageTxt.m_TxtChinese = "򿪼LDD"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_LASER1_POW_CHECK";LanguageTxt.m_TxtEnglish = "Laser1 Power Check";LanguageTxt.m_TxtChinese = "1"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_LASER2_POW_CHECK";LanguageTxt.m_TxtEnglish = "Laser2 Power Check";LanguageTxt.m_TxtChinese = "2"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_LASER_SPOT_CHECK";LanguageTxt.m_TxtEnglish = "Laser Beam Check";LanguageTxt.m_TxtChinese = "߼"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_STEP_SET_BTN";LanguageTxt.m_TxtEnglish = "Step Set";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RECOVER_ALL_WAFER";LanguageTxt.m_TxtEnglish = "Recover All Wafer";LanguageTxt.m_TxtChinese = "wafer"; + m_LanguageTxtVec.push_back(LanguageTxt); + LanguageTxt.m_TxtName = "LANGUAGE_RED_LASER_POW_CHECK";LanguageTxt.m_TxtEnglish = "Red Laser Power Check";LanguageTxt.m_TxtChinese = ""; + m_LanguageTxtVec.push_back(LanguageTxt); +} + +//ȡTxtName Ӧ +CString CLanguageMgr::GetLanguageTxt(CString TxtName) +{ + CString Txt = ""; + int size = m_LanguageTxtVec.size(); + for(int k=0;kWriteDebugLog("Func--->UpdateLanguageTxt"); + gChildPCS->UpdateLanguageTxt(); + gChildLaserPathState->UpdateLanguageTxt(); + gChildSysParaSet->UpdateLanguageTxt(); + gChildRecipe->UpdateLanguageTxt(); + //GetFrame()->m_DlgDeviceMain.UpdateLanguageTxt(); +} diff --git a/LaipuDrawing/LanguageMgr.h b/LaipuDrawing/LanguageMgr.h new file mode 100644 index 0000000..f326730 --- /dev/null +++ b/LaipuDrawing/LanguageMgr.h @@ -0,0 +1,40 @@ +#pragma once +#include "module.h" + + +class CLanguageTxt +{ +public: + CLanguageTxt(void) + { + + }; +public: + CString m_TxtName;// + CString m_TxtEnglish;//Ӣ + CString m_TxtChinese;// +}; + + + +class CLanguageMgr :public CModule +{ +public: + CLanguageMgr(void); + ~CLanguageMgr(void); + virtual MODULE GetModuleType(){return _LANGUAGE_PORP;}; + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual CString GetParDirName(){return "LanguageMgr";}; + virtual void OnPropertyChanged(); + virtual void OnAppInitialize(); + CString GetLanguageTxt(CString TxtName); +private: + void UpdateLanguageTxt(); + void InitLanguageTxt(); +private: + vector m_LanguageTxtVec; + bool m_bEnglishMode;//Ӣģʽ +}; + +extern CLanguageMgr *gLanguageMgr; + diff --git a/LaipuDrawing/Laser.cpp b/LaipuDrawing/Laser.cpp new file mode 100644 index 0000000..c92fdf7 --- /dev/null +++ b/LaipuDrawing/Laser.cpp @@ -0,0 +1,1040 @@ +#include "StdAfx.h" +#include "Laser.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "MsgBox.h" +#include "ExceptionMsg.h" +#include "WorkCmdContainer.h" +#include "DrawSimpleShape.h" +#include "GlobalDrawMgr.h" +#include "PenParMgr.h" +#include "CStringFuc.h" +#include "WorkCmdInvoker.h" +#include "ObjFillMgr.h" +#include "AllThreadMgr.h" +#include "ProgramLaserTuiHuo.h" +#include "RecipeMgr.h" +#include "CStringFuc.h" +#include "WarningMgr.h" +#include "FileMgr.h" +#include "LaserPowCheckMgr.h" + + +#define EDI_PARA_FILE _T("\\CommPar\\EnergyDensityPara.bin") + + + +//߳ +UINT LaserSleepThread(LPVOID pParam) +{ + CLaser *p = (CLaser *)pParam; + p->LaserSleepTimeExt(); + return 0; +} + +CLaser *gLaser = new CLaser; +CLaser::CLaser(void) +{ + m_bAdaptThickness = false; + m_bInited = false;//Ƿʼɹ + m_BaseThickness = 0;//ԽĻ׼Ʒmm + m_WorkThickness = 0;//ǰӹIJƷmm + m_MaxThickness = 1;//Ʒmm + m_MinThickness = 1;//СƷmm + m_LaserSwitch = false;//Ƿ + m_bScanByDirX = true;//Xɨ + + m_LaserType = 3;// + m_OpenLaserDelay = 0;//ʱms + m_OpenLaserDelayShort = 0;//ʱms (ʱ) + m_bSetGateFre = false;//Ƿ˹բƵ(ֻһ) + m_ScanOverlapRatio = 30;//ɨص,ɨ(0~100%) + m_GateOpDelay = 100;//բʱms(ΪբƫתҪʱ) + m_GateFre = 30;//բƵ + m_FocusZMoveUpVal = 20;//Z ļ⽹λ(ǻ׼ƶֵ) + m_bAutoCalCurr = false;//ݹܶԶ(ֵ) + m_bCloseAppCloseLaser = true; + m_SpotSize.w = m_SpotSize.h = 1;//ߵijߴ(˻豸Ƿε).h = 1;//ߵijߴ(˻豸Ƿε) + + m_bLaserGateOpen = false; + m_bRedLaserGateOpen = false;//2 gate ǷΪ״̬() + m_bMachineGateOpen = true;//բǷ + + m_bAutoCalSpeedX = true;//صԶɨٶ + m_bCtrLaserDimmerRev = false;//բƷ + + m_CurWorkFoucsZcoord = 0;//ǰӹԲZ () + + m_EnergyParChangeScal = 1;//жϵܶȲ仯ķΧ%(ֵ) + + m_RedLaserDelayAdjust = 0;//ʱֵ(ڵ巢λ) + + m_RedLaserPowCheckPluseW = 100;//ʱʹõus + + m_bPowRecordWriteCalPow = false;//ʵ¼ʱ㹦P = Po+K*I; + + m_LaserCurrDigitsCnt = 1;//Сλ + + + +} +CLaser::~CLaser(void) +{ +} +CMFCPropertyGridProperty *CLaser::CreatGridProperty() +{ + CPropertieMgr *pPropertieMgr = &gDevicePropertieMgr; + CString PropertyName;// + CString Description;// + CString Path = _T("Laser");//洢· + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T(""); + ModuleName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + { + { + //Աӳ + Name = _T("m_LaserSwitch");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_LaserSwitch); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ⷴ"); + Description = _T("ƶ˿Ƿ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + pPropertie->SetModuleName(ModuleName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LaserSwitch, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_LaserCurrDigitsCnt");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_LaserCurrDigitsCnt); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("λ"); + Description = _T("Ŀλ(1 or 2)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LaserCurrDigitsCnt, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_OpenLaserDelay");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_OpenLaserDelay); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ʱ()"); + Description = _T("򿪼ʱʱ(״̬)(ms)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_OpenLaserDelay, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + + { + //Աӳ + Name = _T("m_OpenLaserDelayShort");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_OpenLaserDelayShort); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ʱ()"); + Description = _T("򿪼ʱʱ(ms)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_OpenLaserDelayShort, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + + { + //Աӳ + Name = _T("m_GateOpDelay");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_GateOpDelay); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("բʱ"); + Description = _T("բʱms(ΪբƫתҪʱ)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_GateOpDelay, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + + { + //Աӳ + Name = _T("m_bCloseAppCloseLaser");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bCloseAppCloseLaser); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("˳ʱҪرLD"); + Description = _T("˳ʱҪرռLD"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCloseAppCloseLaser, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_GateFre");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_GateFre); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("բƵ"); + Description = _T("ƹբƫתٶ(ֵȴСԽ)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_GateFre, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_LaserType");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_LaserType); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Type"); + Description = _T("Type"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LaserType, Description); + pGroup->AddSubItem(p); + pPropertieMgr->Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_FocusZMoveUpVal");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_FocusZMoveUpVal); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("⽹"); + Description = _T("Zό㵽Բľmm"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_FocusZMoveUpVal, Description); + p1->AllowEdit(FALSE);//޸ + pGroup->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bScanByDirX");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bScanByDirX); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Xɨ"); + Description = _T("true: Xɨ,false: Yɨ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bScanByDirX, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_bAutoCalSpeedX");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bAutoCalSpeedX); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Զɨٶ"); + Description = _T("ǷصԶɨٶ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_bAutoCalSpeedX, Description); + pGroup->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bAutoCalCurr");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bAutoCalCurr); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Զ"); + Description = _T("ǷݹܶԶ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_bAutoCalCurr, Description); + pGroup->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bPowRecordWriteCalPow");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bPowRecordWriteCalPow); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Ϲ"); + Description = _T("ʵ¼ʱ㹦"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bPowRecordWriteCalPow, Description); + pGroup->AddSubItem(p); + + pPropertieMgr->Insert(p, pPropertie); + } + } + { + GroupName = (""); + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(GroupName); + { + { + //Աӳ + Name = _T("m_SpotSize_w");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_SpotSize.w); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("߳ߴX(mm)"); + Description = _T("X ij(mm)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_SpotSize.w, Description); + pGroup1->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_SpotSize_h");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_SpotSize.h); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("߳ߴY(mm)"); + Description = _T("Y ij(mm)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_SpotSize.h, Description); + pGroup1->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_EnergyParChangeScal");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_EnergyParChangeScal); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("챣%"); + Description = _T("ʵõKPo ͵ǰֵı仯ֵᱨ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_EnergyParChangeScal, Description); + pGroup1->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + } + { + GroupName = (""); + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(GroupName); + { + { + //Աӳ + Name = _T("m_RedSpotSize_w");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_RedSpotSize.w); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("߳ߴX(mm)"); + Description = _T("X ij(mm)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_RedSpotSize.w, Description); + pGroup1->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_RedSpotSize_h");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_RedSpotSize.h); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("߳ߴY(mm)"); + Description = _T("Y ij(mm)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_RedSpotSize.h, Description); + pGroup1->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_RedLaserDelayAdjust");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_RedLaserDelayAdjust); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ʱ(us)"); + Description = _T("ڲ̹ͺʱ(us)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_RedLaserDelayAdjust, Description); + pGroup1->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_RedLaserPowCheckPluseW");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_RedLaserPowCheckPluseW); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ʵ(us)"); + Description = _T("ʱʹõus"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_RedLaserPowCheckPluseW, Description); + pGroup1->AddSubItem(p1); + pPropertieMgr->Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } + } + } +//-------------------------------------------------------------------------------// + return pGroup; +} +void CLaser::Draw(CDC* pDC) +{ + +} +#if 1 +void CLaser::OnAppInitialize() +{ + //ļжȡܶȵIJ + ReadEnergyDensityParFile(); +} +void CLaser::OnExitApp() +{ + +} +//ļΪ +void CLaser::WriteWorkFileExt(vector &LabVec) +{ + LabVec.push_back(CLab(LAB_NULL,m_WorkThickness));//Ʒ +} +void CLaser::ReadWorkFile(CLabVecRang &LabVecRang) +{ + int idx = LabVecRang.GetStart()+1; + m_WorkThickness = LabVecRang.GetDouble(idx++); +} +//ȡʱ +int CLaser::GetOpenLaserDelay() +{ + if(m_bLaserGateOpen)//ʱöʱ + return m_OpenLaserDelayShort; + + return m_OpenLaserDelay; +} +int CLaser::GetShortOpenLaserDelay() +{ + return m_OpenLaserDelayShort; +} +//ùբƵ +void CLaser::SetGateFre() +{ + +} +//ȡ⽹(ֵDzǵĻ׼Z ƶֵ) +double CLaser::GetFocusZMoveUpVal() +{ + return m_FocusZMoveUpVal; +} +//ؼϲDZ׼Ľֵ(ʾ) +double CLaser::GetLaserFocusDis() +{ + return m_FocusZMoveUpVal; +} +void CLaser::ResetCurWorkFoucsZcoord() +{ + m_CurWorkFoucsZcoord = 0; + gLogMgr->WriteDebugLog("Func---->ResetCurWorkFoucsZcoord"); +} +//õǰwafer ĽZ (FindFoucsCoordZ DzҵZ (ֵ)) +void CLaser::SetCurWorkFoucsZcoord(double FindFoucsCoordZ) +{ + //= DzZ Ϲ̶(ǵԽõ) + m_CurWorkFoucsZcoord = FindFoucsCoordZ+m_FocusZMoveUpVal; + CString s; + s.Format("FindFoucsCoordZ=%.f,FocusZMoveUpVal=%.f,WorkFoucsZcoord=%.f",FindFoucsCoordZ,m_FocusZMoveUpVal,m_CurWorkFoucsZcoord); + gLogMgr->WriteDebugLog(s); +} +#endif +#if 1//ɨ + +//ܶ(ͨI /F Ƶ) +void CLaser::CalEnergyDensity(eLaserDeviceType LaserDeviceType,double F,double I,double &Edi) +{ + double EnergyDensityPo = 0; + double EnergyDensityK = 0; + GetEnergyDensityPar(LaserDeviceType,F,EnergyDensityK,EnergyDensityPo); + Edi = CalEnergyDensityExt(LaserDeviceType,F,I,EnergyDensityK,EnergyDensityPo); +} +double CLaser::CalEnergyDensityExt(eLaserDeviceType LaserDeviceType,double F,double I,double K,double Po) +{ + if(F==0 || I==0) + return 0; + //ʱȡƵ= 1 + if(LaserDeviceType == _LaserDeviceType_RedLaser) + F = 1; + + DbSize SpotSize = GetSpotSize(LaserDeviceType); + double Pi = Po + K*I;//Ϲֵ + double Ei = Pi/F;// + double Edi = 0.1*Ei/(SpotSize.w*SpotSize.h); + if(LaserDeviceType != _LaserDeviceType_RedLaser) + Edi *= 1000; + CString s; + s.Format("%.3f",Edi);//λС + Edi = CStringToDouble(s); + return Edi; +} +//ͨʼ㹦ܶ +double CLaser::CalEnergyDensityByPow(eLaserDeviceType LaserDeviceType,double F,double P) +{ + if(F==0) + return 0; + //̹ҹբûд򿪵ʱ + if(LaserDeviceType != _LaserDeviceType_RedLaser && !IsMachineGateOpen()) + return 0; + //Һgateûд򿪵ʱ + if(LaserDeviceType == _LaserDeviceType_RedLaser && !IsbRedLaserGateOpen()) + return 0; + //ʱȡƵ= 1 + if(LaserDeviceType == _LaserDeviceType_RedLaser) + F = 1; + + DbSize SpotSize = GetSpotSize(LaserDeviceType); + double Ei = P/F;// + double Edi = 0.1*Ei/(SpotSize.w*SpotSize.h); + if(LaserDeviceType != _LaserDeviceType_RedLaser) + Edi *= 1000; + CString s; + s.Format("%.3f",Edi);//λС + Edi = CStringToDouble(s); + return Edi; +} + +//ݹܶȺƵʼֵ +void CLaser::CalCurrByEdi(eLaserDeviceType LaserDeviceType,double F,double &I,double Edi) +{ + double EnergyDensityPo = 0; + double EnergyDensityK = 0; + GetEnergyDensityPar(LaserDeviceType,F,EnergyDensityK,EnergyDensityPo); + I = CalCurrByEdiExt(LaserDeviceType,F,Edi,EnergyDensityK,EnergyDensityPo); +} +//FƵEdiܶP0ؾKб +double CLaser::CalCurrByEdiExt(eLaserDeviceType LaserDeviceType,double F,double Edi,double K,double Po) +{ + if(F==0 || Edi==0) + return 0; + //߳ߴ + DbSize SpotSize = GetSpotSize(LaserDeviceType); + //ʱȡƵ= 1 + if(LaserDeviceType == _LaserDeviceType_RedLaser) + F = 1; + if(LaserDeviceType != _LaserDeviceType_RedLaser) + Edi /= 1000; + double Ei = Edi*(SpotSize.w*SpotSize.h)/0.1;// + double Pi = Ei*F;//Ϲֵ + double I = (Pi-Po)/K; + + CString s; + if(m_LaserCurrDigitsCnt>=2) + s.Format("%.2f",I);//2 λС + else + s.Format("%.1f",I);//1 λС + + I = CStringToDouble(s); + + s.Format("Po=[%.3f] K=[%.3f] I=[%.3f] F=[%.3f] L=[%.3f] W=[%.3f]Pi=[%.3f] Ei=[%.3f] Edi=[%.3f]",Po,K,I,F,SpotSize.w,SpotSize.h,Pi,Ei,Edi); + //gLogMgr->WriteDebugLog(s); + + return I; +} +//recipe жӦĹֵ(P = P0 + K*I) +double CLaser::CalPowerByRecipePar(eLaserDeviceType LaserDeviceType,double Fre,double I) +{ + double P = 0; + //ҵƵFre ӦKPo + double Po = 0; + double K = 0; + if(GetEnergyDensityPar(LaserDeviceType,Fre,K,Po)) + { + P = CalPowerByDensityPar(Po,K,I); + } + return P; +} +double CLaser::CalPowerByDensityPar(double Po,double K,double I) +{ + double P = 0; + P = Po + K*I; + if(P<0) + P=0; + return P; +} +#endif +#if 1 +//ȡ߳ߴ +DbSize CLaser::GetSpotSize(eLaserDeviceType LaserDeviceType) +{ + DbSize SpotSize = m_SpotSize; + //ʱȡƵ= 1 + if(LaserDeviceType == _LaserDeviceType_RedLaser) + { + SpotSize = m_RedSpotSize; + } + return SpotSize; +} +CString CLaser::GetLaserDeviceName(eLaserDeviceType LaserDeviceType) +{ + CString s; + if(LaserDeviceType == _LaserDeviceType_MainLaser1) + s = ("̹1"); + if(LaserDeviceType == _LaserDeviceType_MainLaser2) + s = ("̹2"); + if(LaserDeviceType == _LaserDeviceType_RedLaser) + s = (""); + return s; +} + +//鹦ܶȲǷ޶Χ(򷢳WarningMsg) +bool CLaser::CheckEnergyDensityPar(eLaserDeviceType LaserDeviceType,double Fre,double K,double Po) +{ + gLogMgr->WriteDebugLog("Func---->CheckEnergyDensityPar"); + double CurK,CurPo;//ǰֵ + GetEnergyDensityPar(LaserDeviceType,Fre,CurK,CurPo); + + CString Log = GetLaserDeviceName(LaserDeviceType); + Log += "\n"; + CString s; + s.Format("ֵK[%lf] Po[%lf]",CurK,CurPo); + Log += s; + Log += "\n"; + + s.Format("ֵK[%lf] Po[%lf]",K,Po); + Log += s; + Log += "\n"; + gLogMgr->WriteDebugLog(Log); + + //ⱨ + if(CurK==0 || CurPo==0) + return false; + + bool Ret = true; + double ChangeScal = (fabs(K-CurK)/CurK)*100; + if(ChangeScal >(m_EnergyParChangeScal)) + { + s.Format("K 仯%lf%% ޶Χ",ChangeScal); + Log += s; + Log += "\n"; + Ret = false; + } + ChangeScal = (fabs(Po-CurPo)/CurPo)*100; + if(ChangeScal >(m_EnergyParChangeScal)) + { + s.Format("Po 仯%lf%% ޶Χ",ChangeScal); + Log += s; + Log += "\n"; + Ret = false; + } + if(Ret)// + { + Log += "޶Χ"; + } + else//ʧ,ͱϢ + { + CString AddInfo; + AddInfo = Log; + if(LaserDeviceType == _LaserDeviceType_MainLaser1) + gWarningMgr->SendWarningMsg(_Warning_Code_41,AddInfo); + if(LaserDeviceType == _LaserDeviceType_MainLaser2) + gWarningMgr->SendWarningMsg(_Warning_Code_42,AddInfo); + if(LaserDeviceType == _LaserDeviceType_RedLaser) + gWarningMgr->SendWarningMsg(_Warning_Code_43,AddInfo); + } + + return Ret; +} +//ͨصʺ͹ֱɨmm (bhorizontal Ƿ) +double CLaser::GetScanIntervals(double ScanOverlapRatio,bool bhorizontal) +{ + double ScanIntervals = 1; + double SpotSize; + if(gLaser->IsbScanByDirX()) + SpotSize = m_SpotSize.h; + else + SpotSize = m_SpotSize.w; + + if(ScanOverlapRatio>0&&ScanOverlapRatio<100) + { + ScanIntervals = SpotSize-(SpotSize*ScanOverlapRatio)/100; + } + return ScanIntervals; +} +#endif +#if 1 +void CLaser::IniEdiParList(CListCtrl &list) +{ + //÷ + list.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + int idx = 0; + list.InsertColumn(idx,"Idx",LVCFMT_LEFT,35,-1); + idx++; + list.InsertColumn(idx,"Laser",LVCFMT_LEFT,55,-1); + idx++; + list.InsertColumn(idx,"Fre",LVCFMT_LEFT,55,-1); + idx++; + list.InsertColumn(idx,"K",LVCFMT_LEFT,70,-1); + idx++; + list.InsertColumn(idx,"Po",LVCFMT_LEFT,70,-1); + idx++; +} +void CLaser::UpdateEdiParList(CListCtrl &List) +{ + List.DeleteAllItems(); + int size = m_EnergyDensityParVec.size(); + for(int k=0;kWriteDebugLog("Func--->WriteEnergyDensityParFile"); + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,EDI_PARA_FILE); + ofstream fileStream; + fileStream.open(FilePath);//ǵķʽ + int size = m_EnergyDensityParVec.size(); + for(int k=0;kWriteDebugLog("Func--->ReadEnergyDensityParFile"); + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,EDI_PARA_FILE); + vector> StrVec; + FileMgr.ReadFileToStrVec(FilePath,StrVec); + m_EnergyDensityParVec.clear(); + int size = StrVec.size(); + for(int k=0;kWriteDebugLog(log); + } + } +} +//ʵֵΪֵ(ֶ) +void CLaser::SetEnergyDensityPar(eLaserDeviceType LaserDeviceType,double Fre,double K,double Po) +{ + +} + +//ȡܶȵIJ(Ƿ) +bool CLaser::GetEnergyDensityPar(eLaserDeviceType LaserDeviceType,double Fre,double &K,double &Po) +{ + int LaserType = (int)LaserDeviceType; + int size = m_EnergyDensityParVec.size(); + for(int k=0;kWriteDebugLog("Func---->StopSleepLaserTime"); +} +//ȡǰʣʱ +CString CLaser::GetCurSleepLeftTimes() +{ + CString LeftTimes; + if(m_bStopLaserSleepTime) + LeftTimes = "00:00:00"; + else + LeftTimes = m_LaserSleepTime.GetLeftTimes(); + return LeftTimes; +} +void CLaser::LaserSleepTimeExt() +{ + +} +// +void CLaser::LaserSleepImmediately() +{ + gLogMgr->WriteDebugLog("Func---->Laser Sleep Immediately"); + m_bStopLaserSleepTime = false; + m_LaserSleepTime.StopRecordTime(); +} +#endif +#if 1 +//¼ϵͳ +void CLaser::UpdateLaserProp() +{ + gLogMgr->WriteDebugLog("Func---->UpdateLaserProp"); + { + //Աӳ + CString Path = "Laser"; + CString Name = _T("m_SpotSize_w");// + CPropertie Propertie; + Propertie.SetpVal((void*)&m_SpotSize.w); + Propertie.SetType(_PROP_TYPE_DOUBLE); + Propertie.SetPath(Path); + Propertie.SetName(Name); + Propertie.WriteRead(true);//ȡ + } + { + //Աӳ + CString Path = "Laser"; + CString Name = _T("m_SpotSize_h");// + CPropertie Propertie; + Propertie.SetpVal((void*)&m_SpotSize.h); + Propertie.SetType(_PROP_TYPE_DOUBLE); + Propertie.SetPath(Path); + Propertie.SetName(Name); + Propertie.WriteRead(true);//ȡ + } + CString log; + log.Format("SpotSize.w=%f,SpotSize.h=%f",m_SpotSize.w,m_SpotSize.h); + gLogMgr->WriteDebugLog(log); +} +//ȡеǰõĵֵ +double CLaser::ReadCurSetLddCurrent(eLaserDeviceType LaserDeviceType) +{ + bool bTwoLaserLddMode = false; + { + //Աӳ + CString Path = "PhotonicsLaserMgr"; + CString Name = _T("m_bTwoLaserLddMode");// + CPropertie Propertie; + Propertie.SetpVal((void*)&bTwoLaserLddMode); + Propertie.SetType(_PROP_TYPE_BOOL); + Propertie.SetPath(Path); + Propertie.SetName(Name); + Propertie.WriteRead(true);//ȡ + } + if(LaserDeviceType==_LaserDeviceType_MainLaser2 && !bTwoLaserLddMode) + return 0; + double Laser1LddOpenCurr = 0; + { + //Աӳ + CString Path = "AnnealMonitoringMgr"; + CString Name = _T("m_Laser1LddOpenCurr");// + CPropertie Propertie; + Propertie.SetpVal((void*)&Laser1LddOpenCurr); + Propertie.SetType(_PROP_TYPE_DOUBLE); + Propertie.SetPath(Path); + Propertie.SetName(Name); + Propertie.WriteRead(true);//ȡ + } + return Laser1LddOpenCurr; +} +//ȡFixCurr ӦĹFixPow +void CLaser::GetLaserFixedCurrentPow(eLaserDeviceType LaserDeviceType,double Fre,double FixCurr,double &FixPow) +{ + //̶Dz趨ֵ(Ԥʱĵ) + //FixCurr = ReadCurSetLddCurrent(LaserDeviceType); + vector PowCheckPtPowCheckPVec; + gLaserPowCheckMgr->ReadLaserFixedCurrentPowFile(PowCheckPtPowCheckPVec); + int size = PowCheckPtPowCheckPVec.size(); + for(int k=0;k &LabVec); + virtual void ReadWorkFile(CLabVecRang &LabVecRang); + virtual void Draw(CDC* pDC); + virtual void OnExitApp(); + + double GetBaseThickness(){return m_BaseThickness;}; + void SetBaseThickness(double n){m_BaseThickness = n;}; + void SetWorkThickness(double n){m_WorkThickness = n;}; + double GetWorkThickness(){return m_WorkThickness;}; + bool IsLaserSwitch(){return m_LaserSwitch;}; + int GetLaserType(){return m_LaserType;}; + int GetOpenLaserDelay(); + double GetScanIntervals(double ScanOverlapRatio,bool bhorizontal); + double GetScanOverlapRatio(){return m_ScanOverlapRatio;}; + void SetScanOverlapRatio(double val){m_ScanOverlapRatio = val;}; + void SetGateFre(); + int GetGateOpDelay(){return m_GateOpDelay;}; + + void SetbLaserGateOpen(bool b){m_bLaserGateOpen = b;}; + bool IsbLaserGateOpen(){return m_bLaserGateOpen;}; + void SetbRedLaserGateOpen(bool b){m_bRedLaserGateOpen = b;}; + bool IsbRedLaserGateOpen(){return m_bRedLaserGateOpen;}; + void SetbMachineGateOpen(bool b){m_bMachineGateOpen = b;}; + bool IsMachineGateOpen(){return m_bMachineGateOpen;}; + int GetShortOpenLaserDelay(); + bool IsbCloseAppCloseLaser(){return m_bCloseAppCloseLaser;}; + void SetFocusZMoveUpVal(double ZFocus){m_FocusZMoveUpVal = ZFocus;}; + double GetFocusZMoveUpVal(); + + bool IsbAutoCalScanSpeed(){return m_bAutoCalSpeedX;}; + bool IsbAutoCalCurr(){return m_bAutoCalCurr;}; + double GetLaserFocusDis(); + void IOSwitchLaserDimmer(bool bOpen); + void IOSwitchLaserDimmerByTargetCoord(Dbxy TargetCoord); + + void StartLaserSleepTime(); + void StopLaserSleepTime(); + void LaserSleepTimeExt(); + CString GetCurSleepLeftTimes(); + void CalEnergyDensity(eLaserDeviceType LaserDeviceType,double F,double I,double &Edi); + void CalCurrByEdi(eLaserDeviceType LaserDeviceType,double F,double &I,double Edi); + void LaserSleepImmediately(); + double GetCurWorkFoucsZcoord(){return m_CurWorkFoucsZcoord;}; + void SetCurWorkFoucsZcoord(double Coord); + void ResetCurWorkFoucsZcoord(); + bool IsbInited(){return m_bInited;}; + void SetEnergyDensityPar(eLaserDeviceType LaserDeviceType,double Fre,double K,double Po); + bool GetEnergyDensityPar(eLaserDeviceType LaserDeviceType,double Fre,double &K,double &Po); + bool CheckEnergyDensityPar(eLaserDeviceType LaserDeviceType,double Fre,double K,double Po); + int GetRedLaserDelayAdjust(){return m_RedLaserDelayAdjust;}; + int GetRedLaserPowCheckPluseW(){return m_RedLaserPowCheckPluseW;}; + DbSize GetSpotSize(eLaserDeviceType LaserDeviceType); + bool IsbScanByDirX(){return m_bScanByDirX;}; + CString GetLaserDeviceName(eLaserDeviceType LaserDeviceType); + void IniEdiParList(CListCtrl &list); + void UpdateEdiParList(CListCtrl &list); + bool IsLaserSleepTimeRun(){return !m_bStopLaserSleepTime;};//߼ʱǷ + double CalPowerByRecipePar(eLaserDeviceType LaserDeviceType,double Fre,double I); + double CalPowerByDensityPar(double Po,double K,double I); + bool IsbPowRecordWriteCalPow(){return m_bPowRecordWriteCalPow;}; + double CalEnergyDensityByPow(eLaserDeviceType LaserDeviceType,double F,double P); + int GetLaserCurrDigitsCnt(){return (m_LaserCurrDigitsCnt==1)?1:2;}; + void UpdateLaserProp(); + void GetLaserFixedCurrentPow(eLaserDeviceType LaserDeviceType,double Fre,double FixCurr,double &FixPow); +private: + double CalEnergyDensityExt(eLaserDeviceType LaserDeviceType,double F,double I,double K,double Po); + double CalCurrByEdiExt(eLaserDeviceType LaserDeviceType,double F,double Edi,double K,double Po); + void ReadEnergyDensityParFile(); + void WriteEnergyDensityParFile(); + double ReadCurSetLddCurrent(eLaserDeviceType LaserDeviceType); +private: + bool m_bInited;//Ƿʼɹ + DbSize m_SpotSize;//ߵijߴwʾXhʾY(ֵ) + double m_ScanOverlapRatio;//ɨص,ɨ(0~100%) + bool m_bAutoCalSpeedX;//صԶɨٶ(ֵ) + bool m_bAutoCalCurr;//ݹܶԶ(ֵ) + bool m_LaserSwitch;//Ƿ(ֵ) + bool m_bScanByDirX;//Xɨ + int m_LaserType;//(ֵ) + int m_OpenLaserDelay;//ʱms (ʱ) (ֵ) + int m_OpenLaserDelayShort;//ʱms (ʱ) (ֵ) + + bool m_bLaserGateOpen;//gate ǷΪ״̬ + bool m_bRedLaserGateOpen;//2 gate ǷΪ״̬() + + bool m_bSetGateFre;//Ƿ˹բƵ + bool m_bMachineGateOpen;//բǷ + + int m_GateOpDelay;//բʱms(ΪբƫתҪʱ)(ֵ) + + int m_GateFre;//բƵ(ֵ) + + //⽹,Z еʹ + bool m_bAdaptThickness;//ǷӦƷĺ + double m_BaseThickness;//ԽĻ׼Ʒmm + double m_WorkThickness;//ǰӹIJƷmm + double m_MaxThickness;//Ʒmm + double m_MinThickness;//СƷmm + + double m_FocusZMoveUpVal;//Z ļ⽹λ(ǻ׼ƶֵ) + bool m_bCloseAppCloseLaser;//Ƿڹرʱرռ(ֵ) + + bool m_bCtrLaserDimmerByMotionIO;//Ƽ˥(true ˶ƿIO )(false PLC) + bool m_bCtrLaserDimmerRev;//բƷ + + + + CWorkTime m_LaserSleepTime;//Ƽߵʱ + bool m_bStopLaserSleepTime;//ֹͣ߼ʱ + + double m_EnergyParChangeScal;//жϵܶȲ仯ķΧ(ֵ) + int m_RedLaserPowCheckPluseW;//ʱʹõus + DbSize m_RedSpotSize;//⼤ߵijߴwʾXhʾY(ֵ) + int m_RedLaserDelayAdjust;//ʱֵ(ڵ巢λ) + + bool m_bPowRecordWriteCalPow;//ʵ¼ʱ㹦P = Po+K*I; + int m_LaserCurrDigitsCnt;//Сλ + vector m_EnergyDensityParVec;//ǰĹܶȲ + + double m_CurWorkFoucsZcoord;//ǰӹԲZ () +}; +extern CLaser *gLaser; \ No newline at end of file diff --git a/LaipuDrawing/LaserPowCheckMgr.cpp b/LaipuDrawing/LaserPowCheckMgr.cpp new file mode 100644 index 0000000..898d948 --- /dev/null +++ b/LaipuDrawing/LaserPowCheckMgr.cpp @@ -0,0 +1,503 @@ +#include "StdAfx.h" +#include "LaserPowCheckMgr.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "WorkTime.h" +#include "CStringFuc.h" +#include "MsgBox.h" +#include "ExceptionMsg.h" +#include "MsgBox.h" +#include "WorkCmdInvoker.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "CommonFlowMgr.h" +#include "GlobalFunction.h" +#include "RecipeMgr.h" +#include "Laser.h" + +#define POW_CHECK_FILE_PATH _T("\\LaserPowerCheckData\\") +#define POW_CHECK_PAR_FILE _T("\\Parameter\\LaserMeasureData\\LaserPowCheckPar.par") +#define FIX_POW_PARA_FILE _T("\\CommPar\\LaserFixCurrentPower.bin") + +#define TAB_STR " " +#define SPECIAL_CHAR '#' + +void CPowCheckPar::Serialize( CArchive& ar) +{ + if(ar.IsStoring()) + { + ar<>m_PulseFre;//ƵHz + ar>>m_StartCurr;//ʼֵA + ar>>m_EndCurr;//ֵA + ar>>m_GapCurr;//ֵA + ar>>m_CheckDelay;//ÿֵʱms + ar>>m_FirstCheckDelay;//һֵʱms + } +} + +CLaserPowCheckMgr *gLaserPowCheckMgr = new CLaserPowCheckMgr; +CLaserPowCheckMgr::CLaserPowCheckMgr(void) +{ + m_CurPowCheckType = _LaserDeviceType_MainLaser1;//ǰʵ + m_ParList = NULL; + m_CurSelCheckRecordIdx = -1; + m_CurExtLaserType = 0; +} +CLaserPowCheckMgr::~CLaserPowCheckMgr(void) +{ +} +void CLaserPowCheckMgr::OnAppInitialize() +{ + //ʵĿ¼ + CString DirPath = GetPowCheckFilePath(); + CFileMgr FileMgr; + if(!FileMgr.IsDirectoryExists(DirPath)) + FileMgr.CreatDir(DirPath); +} +//ȡʵļ· +CString CLaserPowCheckMgr::GetPowCheckFilePath() +{ + CString DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(POW_CHECK_FILE_PATH); + return DirPath; +} +#if 1 +void CLaserPowCheckMgr::InitSelYearComb(CComboBox &ComboBox) +{ + CString FilePath = GetPowCheckFilePath(); + InitYearComb(FilePath,ComboBox); +} +void CLaserPowCheckMgr::InitSelMonthComb(CComboBox &ComboBox) +{ + InitMonthComb(ComboBox); +} +void CLaserPowCheckMgr::InitSelLaserComb(CComboBox &ComboBox) +{ + int idx = 0; + ComboBox.InsertString(idx++,"̹1"); + ComboBox.InsertString(idx++,"̹2"); + ComboBox.InsertString(idx++,""); + //Ĭѡ + ComboBox.SetCurSel(0); +} +void CLaserPowCheckMgr::IniParList(CListCtrl &list,int AddW) +{ + //÷ + list.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + int idx = 0; + list.InsertColumn(idx,"Idx",LVCFMT_LEFT,35,-1); + idx++; + list.InsertColumn(idx,"Current(A)",LVCFMT_LEFT,70+AddW,-1); + idx++; + list.InsertColumn(idx,"Laser Po(W)",LVCFMT_LEFT,90+AddW,-1); + idx++; + list.InsertColumn(idx,"Valid Po(W)",LVCFMT_LEFT,90+AddW,-1); + idx++; +} +void CLaserPowCheckMgr::IniRecordList(CListCtrl &list) +{ + //÷ + list.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + int idx = 0; + list.InsertColumn(idx,"Idx",LVCFMT_LEFT,35,-1); + idx++; + list.InsertColumn(idx,"Time",LVCFMT_LEFT,120,-1); + idx++; + list.InsertColumn(idx,"Fre",LVCFMT_LEFT,70,-1); + idx++; + list.InsertColumn(idx,"K ",LVCFMT_LEFT,100,-1); + idx++; + list.InsertColumn(idx,"Po ",LVCFMT_LEFT,100,-1); + idx++; +} +#endif +#if 1// +//õǰʵ +void CLaserPowCheckMgr::SetCurPowCheckType(int idx) +{ + eLaserDeviceType Type = (eLaserDeviceType)idx; + m_CurPowCheckType = Type; +} +//õǰƵ(CreatCurPowCheckData֮ǰʹ) +void CLaserPowCheckMgr::SetCurPowCheckFre(double Fre) +{ + CPowCheckPar &CurPowCheckPar = (*GetCurPowCheckPar()); + if(Fre>0)//ʹָļƵ + { + CurPowCheckPar.m_PulseFre = Fre; + } +} +//ȡǰļ +CPowCheckPar *CLaserPowCheckMgr::GetCurPowCheckPar() +{ + CPowCheckPar *p; + p = &m_MainPowCheckPar; + return p; +} +void CLaserPowCheckMgr::SetPowCheckPar(CPowCheckPar CheckPar) +{ + CPowCheckPar &CurPowCheckPar = (*GetCurPowCheckPar()); + CurPowCheckPar = CheckPar; +} +#endif +#if 1 +//ȡǰĹܶȲ(ʾ) +void CLaserPowCheckMgr::GetEnergyDensityPar(double &K,double &Po) +{ + K = m_CurPowCheckData.m_EnergyDensityK; + Po = m_CurPowCheckData.m_EnergyDensityPo; +} +//㹦ܶȲ(KPo)(Ϣ) +bool CLaserPowCheckMgr::CalEnergyDensityPar() +{ + gLogMgr->WriteDebugLog("Func---->CalEnergyDensityPar"); + vector&PowCheckPtVec = m_CurPowCheckData.m_PowCheckPtVec; + int size = PowCheckPtVec.size(); + if(size<2) + return false; + double SumK = 0; + double SumP = 0;//ʺ + double SumI = 0;// + bool bSaveToPar = true;//Ƿ񱣴浽 + for(int k=0;kWriteDebugLog(LogStr); + + //ʵĹܶȲֵΪֵ + bool Ret = false; + if(bSaveToPar) + { + //ȡ̹/ĵ + CPowCheckPar &CheckPar = (*GetCurPowCheckPar()); + //Ƿ趨 + //Ret = gLaser->CheckEnergyDensityPar(m_CurPowCheckType,CheckPar.m_PulseFre,m_CurPowCheckData.m_EnergyDensityK,m_CurPowCheckData.m_EnergyDensityPo); + } + return Ret; +} +//Ĺܶб +double CLaserPowCheckMgr::CalTwoPtK(CPowCheckPt CheckPt1,CPowCheckPt CheckPt2) +{ + double K = (CheckPt2.m_SurfacePow - CheckPt1.m_SurfacePow)/(CheckPt2.m_SetCurr - CheckPt1.m_SetCurr); + return K; +} +//ָһεĵ +void CLaserPowCheckMgr::RecoverLastPowCheckData(eLaserDeviceType LaserDeviceType) +{ + if(LaserDeviceType==_LaserDeviceType_MainLaser1) + m_CurPowCheckData = m_LastPow1CheckData; + if(LaserDeviceType==_LaserDeviceType_MainLaser2) + m_CurPowCheckData = m_LastPow2CheckData; + if(LaserDeviceType==_LaserDeviceType_RedLaser) + m_CurPowCheckData = m_LastRedPowCheckData; +} +void CLaserPowCheckMgr::GetLastPowCheckPar(eLaserDeviceType LaserDeviceType,double &K,double &Po) +{ + if(LaserDeviceType==_LaserDeviceType_MainLaser1) + { + K = m_LastPow1CheckData.m_EnergyDensityK; + Po = m_LastPow1CheckData.m_EnergyDensityPo; + } + if(LaserDeviceType==_LaserDeviceType_MainLaser2) + { + K = m_LastPow2CheckData.m_EnergyDensityK; + Po = m_LastPow2CheckData.m_EnergyDensityPo; + } + if(LaserDeviceType==_LaserDeviceType_RedLaser) + { + K = m_LastRedPowCheckData.m_EnergyDensityK; + Po = m_LastRedPowCheckData.m_EnergyDensityPo; + } +} +//ǰĵ +void CLaserPowCheckMgr::CreatCurPowCheckData() +{ + vector&PowCheckPtVec = m_CurPowCheckData.m_PowCheckPtVec; + m_CurPowCheckData.m_CheckType = m_CurPowCheckType; + m_CurPowCheckData.m_EnergyDensityK = 0; + m_CurPowCheckData.m_EnergyDensityPo = 0; + PowCheckPtVec.clear(); + //ȡ̹/ĵ + CPowCheckPar &CheckPar = (*GetCurPowCheckPar()); + //ͬļ + if(CheckPar.m_StartCurr == CheckPar.m_EndCurr) + { + int Cnt = CheckPar.m_GapCurr;//ǵĸ + for(int k=0;k=0 && SelIdx&PowCheckPtVec = PowCheckData.m_PowCheckPtVec; + int size = PowCheckPtVec.size(); + for(int i=0;i PowCheckPtPowCheckPVec; + ReadLaserFixedCurrentPowFile(PowCheckPtPowCheckPVec); + + vector &PowCheckPtVec = m_CurPowCheckData.m_PowCheckPtVec; + int PtCnt = PowCheckPtVec.size(); + for(int k=0;k &PowCheckPtPowCheckPVec) +{ + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,FIX_POW_PARA_FILE); + vector> StrVec; + FileMgr.ReadFileToStrVec(FilePath,StrVec); + int size = StrVec.size(); + for(int k=0;k DataFilePathVec; + CFileMgr FileMgr; + FileMgr.GetChildFileOrDirName(false,FilePath,DataFilePathVec,".pow"); + m_CurPowCheckRecordVec.clear(); + int size = DataFilePathVec.size(); + for(int k=0;k=size) + { + return; + } + CPowCheckData &PowCheckData = m_CurPowCheckRecordVec[m_CurSelCheckRecordIdx]; + double Po = PowCheckData.m_EnergyDensityPo; + double K = PowCheckData.m_EnergyDensityK; + TCHAR szFilters[]=("TXT ļ(*.txt)|*.txt"); + CString FileName; + FileName = PowCheckData.m_DateTime; + CString s; + s.Format("Laser%ld_",m_CurExtLaserType); + FileName = s+ FileName; + CFileDialog dlg(FALSE,("txt"),FileName,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilters); + if(dlg.DoModal()==IDOK) + { + ofstream ar(dlg.GetPathName()); + ar<<"бK : "<IsbPowRecordWriteCalPow()) + { + ar<&PowCheckPtVec = PowCheckData.m_PowCheckPtVec; + int size = PowCheckPtVec.size(); + for(int i=0;iCalPowerByDensityPar(Po,K,CheckPt.m_SetCurr); + ar<IsbPowRecordWriteCalPow()) + { + ar< m_PowCheckPtVec;//ʵ +}; + +class CLaserPowCheckMgr :public CModule +{ +public: + CLaserPowCheckMgr(void); + ~CLaserPowCheckMgr(void); + virtual void OnAppInitialize(); + + void InitSelYearComb(CComboBox &ComboBox); + void InitSelMonthComb(CComboBox &ComboBox); + void InitSelLaserComb(CComboBox &ComboBox); + void IniParList(CListCtrl &list,int AddW=0); + void UpdatePowCheckDataList(CListCtrl &List,bool bInsert,int SelIdx=-1); + void IniRecordList(CListCtrl &list); + void SetCurPowCheckType(int idx); + CPowCheckPar *GetCurPowCheckPar(); + void SetCurPowCheckFre(double Fre); + void CreatCurPowCheckData(); + void SetPowCheckPar(CPowCheckPar CheckPar); + void GetEnergyDensityPar(double &K,double &Po); + CPowCheckData &GetCurPowCheckData(){return m_CurPowCheckData;}; + void LaserPowSavePt(CPowCheckPt *pCheckPt); + void BindingParList(CListCtrl *p){m_ParList = p;}; + bool SaveCurPowCheckData(); + void ReadPowCheckData(int LaserType,CString Year,CString Month); + void UpdatePowCheckRecordList(CListCtrl &List); + void SaveSelCheckRecordToFile(); + eLaserDeviceType GetCurPowCheckType(){return m_CurPowCheckType;}; + void RecoverLastPowCheckData(eLaserDeviceType LaserDeviceType); + void GetLastPowCheckPar(eLaserDeviceType LaserDeviceType,double &K,double &Po); + void SaveCurPowCheckDataForRecipe(); + void ReadLaserFixedCurrentPowFile(vector &PowCheckPtPowCheckPVec); +private: + CString GetPowCheckFilePath(); + void ReadPowCheckPar(); + bool CalEnergyDensityPar(); + double CalTwoPtK(CPowCheckPt CheckPt1,CPowCheckPt CheckPt2); + void UpdatePowCheckDataListExt(CListCtrl &List,bool bInsert,CPowCheckData &PowCheckData); + void SerializePowCheckData(CArchive& ar,CPowCheckData &PowCheckData); +private: + CPowCheckPar m_MainPowCheckPar;//Ĺʵ + CPowCheckPar m_RedPowCheckPar;//Ĺʵ + CPowCheckData m_CurPowCheckData;//ǰʵ + vector m_CurPowCheckRecordVec;//ǰļ¼б + int m_CurSelCheckRecordIdx; + eLaserDeviceType m_CurPowCheckType;//ǰʵ + CListCtrl *m_ParList; + CString m_CurSelMonth;//ǰѡ + int m_CurExtLaserType; + + CPowCheckData m_LastPow1CheckData;//һμ1 ʵ + CPowCheckData m_LastPow2CheckData;//һμ2 ʵ + CPowCheckData m_LastRedPowCheckData;//һκ⹦ʵ +}; + +extern CLaserPowCheckMgr *gLaserPowCheckMgr; diff --git a/LaipuDrawing/Layer.cpp b/LaipuDrawing/Layer.cpp new file mode 100644 index 0000000..6fd3c6c --- /dev/null +++ b/LaipuDrawing/Layer.cpp @@ -0,0 +1,706 @@ +#include "StdAfx.h" +#include "Layer.h" +#include "LogMgr.h" +#include "GlobalDrawMgr.h" +#include "LaiPuLaserView.h" +#include "GlobalFunction.h" +#include "CommandRotato.h" +#include "CommandMirror.h" +#include "CommandMove.h" +#include "CommandReverse.h" +#include "CommandJion.h" +#include "CommandMgr.h" +#include "EasyOperationMgr.h" +#include "ObjComponentMgr.h" +#include "ObjCircle.h" +#include "ObjPline.h" +#include "Laser.h" +#include "CStringFuc.h" +#include "MsgBox.h" + + +CLayer gLayer; +CLayer::CLayer(void) +{ + m_ObjContainer = &m_TmpObjContainer;//ʼʱ򱨴 + m_bShowObjIdx = false;//Ƿʾobj idx + m_bShowObjPtCoord = true; + m_bDrawObj = true;//Ƿobj + m_AreaCrossPtRange = 10;//ڴɨĽ㷶Χ +} +CLayer::~CLayer(void) +{ +} +#if 1 +void CLayer::Serialize(CArchive& ar) +{ +// m_ObjContainer->Serialize(ar); +} +//󶨵ǰObjContainer +void CLayer::BindObjContainer(CObjContainer &Container) +{ + //ڱ༭״̬ + gCommandMgr.Reset(); + //ʱ + ClearTmpObj(); + //µ + m_ObjContainer = &Container; +} +#endif +#if 1 +void CLayer::Draw(CDC* pDC) +{ + //if(m_bDrawObj) + { + DrawAllObj(pDC); + } +} +void CLayer::DrawAllObj(CDC* pDC) +{ + m_ObjContainer->DrawAllObj(pDC); + //ʱҲҪ + m_TmpObjContainer.DrawAllObj(pDC); + //ֵ + if(m_bShowObjIdx) + { + m_ObjContainer->DrawObjIdx(pDC); + } + //ֻڱ༭ģʽʾ + if(m_bShowObjPtCoord) + { + m_ObjContainer->DrawObjPtCoord(pDC); + } +} +//ػѡͼ +void CLayer::XorRedrawObj(CDC* pDC,bool bNeedSel) +{ + m_ObjContainer->XorRedrawObj(pDC,bNeedSel); +} +#endif +#if 1 +void CLayer::AddObject(CObjBase *pMarkObject) +{ + m_ObjContainer->AddObject(pMarkObject); +} +void CLayer::AddObject(Sptr p) +{ + m_ObjContainer->AddObject(p); +} +void CLayer::AddObject(CObjContainer &ObjContainer) +{ + vector> &vec = ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + (*iter)->SetSelected(false); + AddObject((*iter)); + } + } +} +//ɾѡ +void CLayer::DelSelObj() +{ + m_ObjContainer->DelSelObj(); +} +//ɾObjContainer ָobj +void CLayer::DelObj(CObjContainer &ObjContainer) +{ + vector> &vec = ObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNull()==false) + { + DelObj((*iter)); + } + } +} +//ɾָobj +void CLayer::DelObj(Sptr p) +{ + m_ObjContainer->DelObj(p); +} +#endif +#if 1 +bool CLayer::HasSelObjectInRect(DbRect rect) +{ + return m_ObjContainer->HasSelObjectInRect(rect); +} +bool CLayer::HasSelNodeInRect(DbRect rect) +{ + return m_ObjContainer->HasSelNodeInRect(rect); +} + +bool CLayer::HasObjectInRect(DbRect rect) +{ + return m_ObjContainer->HasObjectInRect(rect); +} +//ѡڵĶ(bNeedAllIn ʾҪrect ) +bool CLayer::SelObjectInRect(DbRect rect,bool bNeedAllIn) +{ + //ѡʱȡ֮ǰѡ + if(!gDraw->IsbMultipleSel()) + { + SelAllObj(); + RevSelAllObj(); + } + if(gDraw->IsEditLayerObj()) + { + if(m_ObjContainer->SelObjectInRect(rect,bNeedAllIn)) + { + gEasyOperationMgr->Refresh(); + return true; + } + } + //ͬʱԪѡ + if(gObjComponentMgr->SelObjectInRect(rect)) + { + return true; + } + return false; +} +//ȡһrect obj +Sptr CLayer::GetFirstObjInRect(DbRect &rect) +{ + return m_ObjContainer->GetFirstObjInRect(rect); +} +Sptr CLayer::GetFirstNodeObjInRect(DbRect &rect) +{ + return m_ObjContainer->GetFirstNodeObjInRect(rect); +} + +//Ƿѡobj +bool CLayer::HasObjSel() +{ + return m_ObjContainer->HasObjSel(); +} + +//ȫѡ +void CLayer::SelAllObj() +{ + m_ObjContainer->SelAllObj(); + gEasyOperationMgr->Refresh(); + //Ԫ + gObjComponentMgr->SelAllObj(); +} +//ȫѡ +void CLayer::NotSelAllObj() +{ + m_ObjContainer->NotSelAllObj(); + + //Ԫ + gObjComponentMgr->NotSelAllObj(); + + gEasyOperationMgr->Refresh(); +} +//ѡ +void CLayer::RevSelAllObj() +{ + m_ObjContainer->RevSelAllObj(); + gEasyOperationMgr->Refresh(); + + //Ԫ + gObjComponentMgr->RevSelAllObj(); +} +//ɾеobj +void CLayer::DelAllObj() +{ + SelAllObj(); + DelSelObj(); +} +//жϵǰ깤ߵ +MOUSE_TOOL CLayer::JudgeMouseToolType(Dbxy pt) +{ + MOUSE_TOOL type = _TOOL_POINT; + DbRect rect = gDraw->GetCurPointRect(pt); + if(HasSelNodeInRect(rect)) + { + type = _TOOL_MOVE_NODE; + } + else if(HasSelObjectInRect(rect)) + { + type = _TOOL_MOVE; + } + return type; +} +DbRect CLayer::GetSelObjRect() +{ + return m_ObjContainer->GetSelObjRect(); +} +//(Բ) +CMFCPropertyGridProperty *CLayer::CreatSpecialGridProperty(CModule *pModule) +{ + return m_ObjContainer->CreatSpecialGridProperty(pModule); +} +//ӦԵı仯 +void CLayer::OnSpecialPropertyChanged() +{ + m_ObjContainer->OnSpecialPropertyChanged(); +} +#endif + +#if 1 +//obj +void CLayer::OperateObj(SObjOperatePar &par,bool bAll) +{ + m_ObjContainer->OperateObj(par,bAll); +} +//ƶѡobj (bAddUndoΪǷ볷ָ) +void CLayer::OnMove(double MoveX,double MoveY,bool bAddUndo) +{ + if(HasObjSel()) + { + //ָ + CCommandMove *p = new CCommandMove; + SObjOperatePar par; + par.OpType = _OP_MOVE; + par.MoveX = MoveX; + par.MoveY = MoveY; + p->SetOperatePar(par); + //ӵ + if(bAddUndo) + gCommandMgr.AddUndoCommand(p); + //ִָ + p->Excute(); + } +} +//ӦָתAngle 360Ƚ +void CLayer::OnRotato(double Angle) +{ + Dbxy pt = GetSelObjRect().GetCenterPt(); + //obj ---------------------------- + SObjOperatePar par; + par.OpType = _OP_ROTATO; + par.BasePt = pt; + par.Angle = Angle; + //undo õָ-----start + CCommandRotato *p = new CCommandRotato; + p->SetOperatePar(par); + gCommandMgr.AddUndoCommand(p); + p->Excute(); + //undo õָ-----end +} +//ֱתAngle (UndoCommand ָ)Angle 360Ƚ +void CLayer::Rotato(double Angle) +{ + Dbxy pt = GetSelObjRect().GetCenterPt(); + //obj ---------------------------- + SObjOperatePar par; + par.OpType = _OP_ROTATO; + par.BasePt = pt; + par.Angle = Angle; + m_ObjContainer->OperateObj(par,false); +} +//Ӧ +void CLayer::OnMirror(X_OR_Y xy) +{ + Dbxy pt = GetSelObjRect().GetCenterPt(); + //obj + SObjOperatePar par; + par.OpType = _OP_MIRROR; + par.BasePt = pt; + par.xy = xy; + //undo õָ-----start + CCommandMirror *p = new CCommandMirror; + p->SetOperatePar(par); + gCommandMgr.AddUndoCommand(p); + p->Excute(); +} +//תڵ˳ +void CLayer::OnReverseSelObj() +{ + //obj + SObjOperatePar par; + par.OpType = _OP_REVERSE; + //undo õָ-----start + CCommandReverse *p = new CCommandReverse; + p->SetOperatePar(par); + gCommandMgr.AddUndoCommand(p); + p->Excute(); +} +//ϲѡͼ +bool CLayer::OnJoin() +{ + CObjBase *p = m_ObjContainer->JoinSelObj(); + if(p)//ϲɹ + { + //ָ----------------------------- + CCommandJion *pCmd = new CCommandJion; + gCommandMgr.AddUndoCommand(pCmd); + Sptr pObj(p); + pCmd->AddOpObj(pObj); + pObj->SetSelected(true);//ϲĬΪѡ״̬ + //ɾϲobj + DelSelObj(); + //Ӻϲobj + AddObject(pObj); + return true; + } + return false; +} +//ֽѡͼ +void CLayer::OnExplode() +{ + +} +#endif +#if 1//׽ +void CLayer::AddTmpObject(Sptr p) +{ + m_TmpObjContainer.AddObject(p); +} +void CLayer::ClearTmpObj() +{ + m_TmpObjContainer.Clear(); +} +//ȡrect Χڵ߶α浽DataPtLineVec +void CLayer::GetLineInRect(DbRect &rect,vector &DataPtLineVec,bool bCatchTemp) +{ + m_ObjContainer->GetLineInRect(rect,DataPtLineVec,bCatchTemp); + //ʱ + if(bCatchTemp) + { + vector> &vec = m_TmpObjContainer.GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((iter+1)!=vec.end())//Ҫһʱ + { + (*iter)->GetLineInRect(rect,DataPtLineVec); + } + } + } +} +//ȡline ཻн㵽PointVec +void CLayer::GetIntersectPoint(DbLine &line,vector &PointVec) +{ + m_ObjContainer->GetIntersectPoint(line,PointVec); +} +bool CLayer::HasObjIntersectWithLine(DbLine &line) +{ + return m_ObjContainer->HasObjIntersectWithLine(line); +} + +//¡ǰѡobj Vec +void CLayer::CloneObj(CObjContainer &ObjContainer,bool bNeedSel) +{ + m_ObjContainer->CloneObj(ObjContainer,bNeedSel); +} +#endif +#if 1//group +//ѡgroup 󶨵ָĶԻ +void CLayer::BindingSelObjToDlg() +{ + //ȳа + GetFrame()->UnBindingDlg(); + m_ObjContainer->BindingDlg(); +} +//ͼ +void CLayer::FillObj(SFillPar FillPar,bool bNeedSel) +{ + m_ObjContainer->FillObj(FillPar,bNeedSel); +} +#endif +#if 1 +//ȡеĵ +void CLayer::GetAllPointObjPt(vector &PtVec) +{ + m_ObjContainer->GetAllPointObjPt(PtVec); +} +//ѡobj ıʺ +void CLayer::SetSelObjPenNum(int num) +{ + if(!gPenParMgr->IsSpecialPen(num))//ʺ + { + m_ObjContainer->SetSelObjPenNum(num); + NotSelAllObj();//ȫѡ + } +} +void CLayer::SelborderObj(bool bNext) +{ + m_ObjContainer->SelborderObj(bNext); + GetCurViewPtr()->RefreshView(); +} +//ѡobj 뵽idx λ(ֶ) +void CLayer::SelectedObjInsertToIdx(int idx) +{ + m_ObjContainer->SelectedObjInsertToIdx(idx); + GetCurViewPtr()->RefreshView(); +} +//ѡobj +void CLayer::ReverseSelObj() +{ + m_ObjContainer->ReverseSelObj(); + GetCurViewPtr()->RefreshView(); +} +//ѡһobj +void CLayer::SelFirstObj() +{ + m_ObjContainer->SelFirstObj(); + GetCurViewPtr()->RefreshView(); +} +#endif + +#if 1 +void CLayer::ResetAllMarkObj() +{ + m_ObjContainer->ResetAllMarkObj(); +} +void CLayer::CreatCircleByThreePt() +{ + vector PtVec; + vector> &vec = m_ObjContainer->GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + PtVec.push_back((*iter)->GetCenterPt()); + } + int size = PtVec.size(); + if(size>=3) + { + CCirclePar CirclePar = CalCircleByThreePt(PtVec[0],PtVec[1],PtVec[2]); + CirclePar.DEdgeCnt = 100; + CObjCircle *pCircle = new CObjCircle; + pCircle->Creat(CirclePar); + AddObject(pCircle); + GetCurViewPtr()->RefreshView(); + } +} +//תƫobj (ԭΪ׼) +void CLayer::OffsetRotatoObj(COffsetRotatoPar OffsetRotatoPar) +{ + //ԭת + Dbxy pt; + SObjOperatePar par; + par.OpType = _OP_ROTATO; + par.BasePt = pt; + par.Angle = OffsetRotatoPar.m_RotatoAng; + m_ObjContainer->OperateObj(par,false); + //ԭת + par.OpType = _OP_MOVE; + par.MoveX = OffsetRotatoPar.m_Offset.x; + par.MoveY = OffsetRotatoPar.m_Offset.y; + m_ObjContainer->OperateObj(par,false); +} +#endif +#if 1 +//ɨ +void CLayer::CreatOneLineObj(double Len) +{ + Dbxy Pt1; + Dbxy Pt2; + CObjContainer &ObjContainer = GetObjContainer(); + //ԭλϴ + if(ObjContainer.GetObjCnt()==1) + { + DbRect Rect = ObjContainer.GetObjRect(false); + Pt1 = Rect.GetCenterPt(); + Pt2 = Rect.GetCenterPt(); + } + if(gLaser->IsbScanByDirX()) + { + Pt1.x -= Len/2; + Pt2.x += Len/2; + } + else + { + Pt1.y -= Len/2; + Pt2.y += Len/2; + } + DelAllObj(); + CObjPline * pObjPline = new CObjPline; + pObjPline->Creat(Pt1,Pt2); + AddObject(pObjPline); + NotSelAllObj(); + m_pView->RefreshView(); +} +//ƶ +void CLayer::MoveScanObj(DIRECTION dir,double Dis) +{ + CObjContainer &ObjContainer = GetObjContainer(); + SelAllObj(); + m_pView->MoveObjToPtByDir(dir,Dis); + NotSelAllObj(); + m_pView->RefreshView(); +} +//жɨ״̬ +void CLayer::ResetAllObjScaned() +{ + vector> &vec = m_ObjContainer->GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->SetbScaned(false); + } +} +#endif +#if 1 +bool CompareLineY(double y1,double y2) +{ + return y1>y2; +} +//ɨ,һԲֱ +void CLayer::QuickCreatScanArea(double AreaGap) +{ + vector LineCoordyVec; + vector PointObjVec;// + CObjBase *pCircle = NULL; + //ɾж + vector> &vec = m_ObjContainer->GetObjVec(); + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->GetType()==_TYPE_PLINE) + { + Dbxy pt = (*iter)->GetCenterPt(); + LineCoordyVec.push_back(pt.y); + } + if((*iter)->GetType()==_TYPE_POINT) + { + Dbxy pt = (*iter)->GetCenterPt(); + PointObjVec.push_back(pt); + } + //ҵԲ + if((*iter)->GetType()==_TYPE_CIRCLE) + { + pCircle = (*iter).GetPtr(); + } + } + if(pCircle == NULL) + { + CMsgBox MsgBox; + MsgBox.Show("ûԲ"); + return; + } + DbRect rect = pCircle->GetRect(); + if(pCircle)//¸1 + { + LineCoordyVec.push_back(rect.T+0.01); + LineCoordyVec.push_back(rect.B-0.01); + } + + CObjCircle CircleTem;//ʱ + CCirclePar ObjCirclePar; + Dbxy CenterPt = rect.GetCenterPt(); + double Radius =rect.GetSize().w /2; + int EdgeCnt = 300;//Բ + CircleTem.CreatByRadius(Radius,CenterPt,EdgeCnt); + + // + sort(LineCoordyVec.begin(),LineCoordyVec.end(),CompareLineY); + // + vector AreaObjVec; + int size = LineCoordyVec.size(); + for(int k=1;kRefreshView(); +} +CObjBase * CLayer::CreatScanAreaObj(CObjBase *pCircle,vector PointObjVec,double Coordy1,double Coordy2,double ChangeSizeY,DIRECTION Dir) +{ + if(!pCircle) + return NULL; + // + CObjPline *pPline = new CObjPline; + vector&PtContainer = pCircle->GetPtContainer(); + int size = PtContainer.size(); + CDataPoint FirstDataPoint; + bool bFirstPt = true; + for(int k=0;k=Coordy2 && Pt.y<=Coordy1) + { + int PointObjCnt = PointObjVec.size(); + for(int i=0;iAddDataPoint(DataPoint); + } + } + //պ + pPline->AddDataPoint(FirstDataPoint); + //Y + { + SObjOperatePar par; + par.OpType = _OP_STRETCH; + DbRect rect = pPline->GetRect(); + par.OldSize = rect.T - rect.B; + par.NewSize = (Coordy1-Coordy2)-ChangeSizeY; + par.Diff = par.NewSize-par.OldSize; + par.xy = _Y; + pPline->Operate(par); + } + //˶λ + { + SObjOperatePar par; + DbRect rect = pPline->GetRect(); + par.OpType = _OP_MOVE; + par.MoveX = 0; + if(Dir==_DIR_U) + { + par.MoveY = Coordy1-rect.T; + } + else if(Dir==_DIR_D) + { + par.MoveY = Coordy2-rect.B; + } + else + { + par.MoveY = ((Coordy1+Coordy2)/2)-(rect.GetCenterPt().y); + } + pPline->Operate(par); + } + return pPline; +} +#endif diff --git a/LaipuDrawing/Layer.h b/LaipuDrawing/Layer.h new file mode 100644 index 0000000..6267e7b --- /dev/null +++ b/LaipuDrawing/Layer.h @@ -0,0 +1,104 @@ +#pragma once + +#include "SmartPtr.h" +#include "ObjBase.h" +#include "GlobalDefine.h" +#include "ObjContainer.h" +#include "EnumDirection.h" + +//ɨIJ +class CCreatAreaPar +{ +public: + CCreatAreaPar() + { + m_CircleDia = 300;//Բֱ + }; +public: + double m_CircleDia;//Բֱ + vector m_LineCoordyVec;//Բֱ +}; + +class CLayer +{ +public: + CLayer(void); + ~CLayer(void); + CMFCPropertyGridProperty *CreatSpecialGridProperty(CModule *pModule); + + void Serialize(CArchive& ar); + void Draw(CDC* pDC); + void XorRedrawObj(CDC* pDC,bool bNeedSel = true); + void AddObject(CObjBase *pMarkObject); + void AddObject(Sptr p); + void AddObject(CObjContainer &ObjContainer); + void AddTmpObject(Sptr p); + void DelSelObj(); + void DelObj(Sptr p); + void DelObj(CObjContainer &ObjContainer); + + void ClearTmpObj(); + bool SelObjectInRect(DbRect rect,bool bNeedAllIn); + void SelAllObj(); + void DelAllObj(); + void NotSelAllObj(); + void RevSelAllObj(); + bool HasSelObjectInRect(DbRect rect); + bool HasObjSel(); + MOUSE_TOOL JudgeMouseToolType(Dbxy pt); + void OperateObj(SObjOperatePar &par,bool bAll); + DbRect GetSelObjRect(); + void OnRotato(double Angle); + void OnMirror(X_OR_Y xy); + void OnMove(double MoveX,double MoveY,bool bAddUndo = true); + void GetLineInRect(DbRect &rect,vector &DataPtLineVec,bool bCatchTemp); + void CloneObj(CObjContainer &ObjContainer,bool bNeedSel); + Sptr GetFirstObjInRect(DbRect &rect); + Sptr GetFirstNodeObjInRect(DbRect &rect); + bool HasObjectInRect(DbRect rect); + void GetIntersectPoint(DbLine &line,vector &PointVec); + bool HasObjIntersectWithLine(DbLine &line); + void OnReverseSelObj(); + bool OnJoin(); + void OnExplode(); + bool HasSelNodeInRect(DbRect rect); + void BindingSelObjToDlg(); + bool HasObj(){return !m_ObjContainer->Empty();}; + CObjContainer &GetObjContainer(){return *m_ObjContainer;}; + void FillObj(SFillPar FillPar,bool bNeedSel = true); + + void OnSpecialPropertyChanged(); + void BindObjContainer(CObjContainer &Container); + void GetAllPointObjPt(vector &PtVec); + void SetSelObjPenNum(int num); + void SelborderObj(bool bNext); + void SetbShowObjIdx(bool b){m_bShowObjIdx = b;}; + void SetbShowObjPtCoord(bool b){m_bShowObjPtCoord = b;}; + void SelectedObjInsertToIdx(int idx); + void ReverseSelObj(); + void SelFirstObj(); + void SetbDrawObj(bool b){m_bDrawObj = b;}; + bool IsbDrawObj(){return m_bDrawObj;}; + void ResetAllMarkObj(); + void Rotato(double Angle); + void CreatCircleByThreePt(); + void OffsetRotatoObj(COffsetRotatoPar OffsetRotatoPar); + void MoveScanObj(DIRECTION dir,double Dis); + void CreatOneLineObj(double Len); + void ResetAllObjScaned(); + void QuickCreatScanArea(double AreaGap); + void SetAreaCrossPtRange(double val){m_AreaCrossPtRange = val;}; +private: + void DrawAllObj(CDC* pDC); + CObjBase * CreatScanAreaObj(CObjBase *pCircle,vector PointObjVec,double Coordy1,double Coordy2,double ChangeSizeY,DIRECTION Dir); +private: + bool m_bShowObjIdx;//Ƿʾobj idx + bool m_bShowObjPtCoord;//Ƿʾobj Ľڵ + bool m_bDrawObj;//Ƿobj + CObjContainer *m_ObjContainer;//obj + CObjContainer m_TmpObjContainer;//ʱobj (Ҫڴʱ׽) + + + double m_AreaCrossPtRange;//ڴɨĽ㷶Χ +}; +extern CLayer gLayer; \ No newline at end of file diff --git a/LaipuDrawing/LogMgr.cpp b/LaipuDrawing/LogMgr.cpp new file mode 100644 index 0000000..3d680e3 --- /dev/null +++ b/LaipuDrawing/LogMgr.cpp @@ -0,0 +1,348 @@ +#include "StdAfx.h" +#include "LogMgr.h" +#include "MainFrm.h" +#include "FileMgr.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "BitOperation.h" +#include "AuthorityMgr.h" +#include "WorkTime.h" +#include "CStringFuc.h" +#include "CriticalSection.h" +#include "GlobalFunction.h" +#include "MyDlgView.h" +#include "DlgChildEventLog.h" + + +#define LOG_FILE_PATH _T("\\LogFile_DataMgr\\") +#define WNDS_NAME_LaipuLog "Laipu Log" +#define FILE_Name_LaipuLog ("\\LogMgrDlg.exe") + + +CLogMgr* gLogMgr = NULL;//־ +CLogMgr::CLogMgr(void) +{ + m_bWriteDebugLog = true; + m_LogListMaxLine = 1000;//־б,ʱ + m_bWriteToLogList = true;//־б + m_pPromptInfo = NULL;//ʾϢ + m_bNotWriteSameLog = true;//Ҫʾͬ־ + m_MaxWorkRecodCnt = 100;//ӹ¼IJѯ +} +CLogMgr::~CLogMgr(void) +{ +} +#if 1 +void CLogMgr::OnAppInitialize() +{ + //־ļĬ· + CreatLogFilePath(); + //LogFileStream + UpdateLogFileStream(); +} +CMFCPropertyGridProperty *CLogMgr::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = _T("LogMgr");;//洢· + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T("־"); + GroupName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Engineer)) + { + //Աӳ + Name = _T("bWriteDebugLog");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bWriteDebugLog); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("־ļ"); + Description = _T("Ƿ־ļ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bWriteDebugLog, Description); + pGroup->AddSubItem(p1); + + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Engineer)) + { + //Աӳ + Name = _T("m_bWriteToLogList");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bWriteToLogList); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("־б"); + Description = _T("Ƿ־б"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bWriteToLogList, Description); + pGroup->AddSubItem(p1); + + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Engineer)) + { + //Աӳ + Name = _T("m_bNotWriteSameLog");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bNotWriteSameLog); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ͬ־"); + Description = _T("Ƿͬ־"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bNotWriteSameLog, Description); + pGroup->AddSubItem(p1); + + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_LogListMaxLine");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_LogListMaxLine); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T(""); + Description = _T("־б,ʱ־б"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LogListMaxLine, Description); + pGroup->AddSubItem(p1); + + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_MaxWorkRecodCnt");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_MaxWorkRecodCnt); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ѯ¼"); + Description = _T("ѯӹ¼"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MaxWorkRecodCnt, Description); + pGroup->AddSubItem(p1); + + gDevicePropertieMgr.Insert(p1, pPropertie); + } +//-------------------------------------------------------------------------------// + return pGroup; +} +//־ļĬ· +void CLogMgr::CreatLogFilePath() +{ + CString DirPath = GetLogPath(); + CFileMgr FileMgr; + if(!FileMgr.IsDirectoryExists(DirPath)) + FileMgr.CreatDir(DirPath); +} +//LogFileStream +void CLogMgr::UpdateLogFileStream() +{ + CWorkTime WorkTime; + CString Date = WorkTime.GetCurDate("_"); + //ڻָ·仯ʱ + CString NewLogFilePath = GetLogFilePath(); + if(m_CurDebugLogFilePath != NewLogFilePath) + { + CString LogFilePath = NewLogFilePath; + //ر֮ǰ + m_LogFileStream.close(); + //׷ӵķʽ + m_LogFileStream.open(LogFilePath, ios::app); + m_CurDebugLogFilePath = NewLogFilePath; + + WriteDebugLog("Func---->UpdateLogFileStream"); + WriteDebugLog(LogFilePath); + } +} +CString CLogMgr::GetLogPath() +{ + CString DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(LOG_FILE_PATH); + return DirPath; +} +CString CLogMgr::GetLogFilePath() +{ + CFileMgr FileMgr; + CString LogFilePath = GetLogPath(); + //ǰļ + CWorkTime WorkTime; + LogFilePath += WorkTime.GetCurYear(); + if(!FileMgr.IsDirectoryExists(LogFilePath)) + { + FileMgr.CreatDir(LogFilePath); + } + //ǰµļ + LogFilePath += "\\"; + LogFilePath += WorkTime.GetCurMonth(); + if(!FileMgr.IsDirectoryExists(LogFilePath)) + { + FileMgr.CreatDir(LogFilePath); + } + //ϵǰ + LogFilePath += "\\"; + CString Date = WorkTime.GetCurDate("_"); + LogFilePath += Date; + //·򴴽Ŀ¼(ÿĿ¼) + if(!FileMgr.IsDirectoryExists(LogFilePath)) + { + FileMgr.CreatDir(LogFilePath); + } + CString CurTime = WorkTime.GetCurTime("_"); + LogFilePath += "\\log_"; + LogFilePath += CurTime.Left(2);//ÿСʱΪһļ + LogFilePath += ".txt"; + return LogFilePath; +} +//־Ŀ¼ +void CLogMgr::OpenLogFileDir() +{ + gLogMgr->WriteDebugLog("Func---->OpenLogFileDir"); + if(gAuthorityMgr->CheckAuthority(_Authority_Engineer,true)==false) + return; + CString DirPath = GetLogPath(); + CFileMgr FileMgr; + FileMgr.OpenDir(DirPath); +} +#endif +#if 1 +//д־ +void CLogMgr::WriteLog(CLog &Log) +{ + if(gExitApp) + return; + //Ҫظͬ־Ϣ + if(m_bNotWriteSameLog) + { + if(m_LastLogStr == Log.str) + return; + } + m_LastLogStr = Log.str; + CString strTime; //ǰʱ + strTime=gWorkTime.GetDateTime("/",":"); + //ǰ߳ID + CString ThreadId; + ThreadId.Format("<%ld>",GetCurrentThreadId()); + CString str = strTime + ThreadId; + str = str + " "+Log.str; + + CDlgChildEventLog *pDlgChild = dynamic_cast(gChildEventLog); + pDlgChild->InsertLogToList(str,_LogListType_LaipuDrawing); + + //д뵽log ļ + if(m_bWriteDebugLog) + { + m_LogFileStream<AddToList(Str,m_LogListMaxLine); +} +CString CLogMgr::GetLastLogStr() +{ + CString s; + return s; +} +//log app +void CLogMgr::OpenLogListApp() +{ +} +void CLogMgr::OpenLogListAppExt() +{ + +} +#endif +#if 1//һЩдlog ʽ +void CLogMgr::WriteDebugLog(CString Str,LOG_TYPE type) +{ + //˵̵̫־ + if(Str.GetLength()<3) + return; + if(m_bWriteDebugLog) + { + CLog log; + log.AddDebugLog(); + switch(type) + { + case _LOG_ERROR: + Str = "[Error]"+Str; + break; + case _LOG_FUNC: + Str = "[Function]"+Str; + break; + default: + break; + } + CString str1 = Str; + log.str = str1; + WriteLog(log); + } +} +// +void CLogMgr::WriteDebugLog(CString Str,CString ValName1,CString ValName2,double val1,double val2) +{ + +} +//һ +void CLogMgr::WriteDebugLog(CString Str,CString ValName,double val) +{ + +} + +void CLogMgr::WriteByte(BYTE bit) +{ + +} +void CLogMgr::WriteBuf(char *buf,int len) +{ + +} +#endif diff --git a/LaipuDrawing/LogMgr.h b/LaipuDrawing/LogMgr.h new file mode 100644 index 0000000..74211ce --- /dev/null +++ b/LaipuDrawing/LogMgr.h @@ -0,0 +1,81 @@ +#pragma once + +#include "Module.h" +#include "GlobalDefine.h" +#include "EnumPropertieType.h" + +//־ +enum LOG_TYPE +{ + _LOG_NORMAL=0,// + _LOG_ERROR,// + _LOG_FUNC,// +}; + +class COutputWnd; +class CLog +{ + friend class CLogMgr; +public: + CLog(void) + { + bCmdLog = false; + bDebugLog = false; + } + void AddCmdLog(){bCmdLog = true;}; + void AddDebugLog(){bDebugLog = true;}; +public: + CString str; +private: + bool bCmdLog; + bool bDebugLog; +}; +//־log +class CLogMgr:public CModule +{ +public: + CLogMgr(void); + ~CLogMgr(void); + virtual void OnAppInitialize(); + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual MODULE GetModuleType(){return _LOG_PROP;}; +public: + void WriteLog(CLog &Log); + ofstream *GetResultOfstream(){return &m_ResultFile;};// + void WriteCmd(CString Cmd,CString val1,CString val2); + void WriteDebugLog(CString Str,LOG_TYPE type = _LOG_NORMAL); + void WriteDebugLog(CString Str,CString ValName1,CString ValName2,double val1,double val2); + void WriteDebugLog(CString Str,CString ValName,double val); + void WriteByte(BYTE bit); + void SetbWriteDebugLog(bool b){m_bWriteDebugLog = b;}; + void WriteBuf(char *buf,int len); + CString GetLogFilePath(); + void UpdateLogFileStream(); + void OpenLogFileDir(); + void WritePromptInfo(CString Str); + int GetMaxWorkRecodCnt(){return m_MaxWorkRecodCnt;}; + CString GetLastLogStr(); + void OpenLogListApp(); +private: + void CreatLogFilePath(); + CString GetLogPath(); + void OpenLogListAppExt(); +private: + + COutputWnd * m_pOutputLog;//־ + COutputWnd * m_pPromptInfo;//ʾϢ + + bool m_bWriteDebugLog;//Ƿ־ļ + bool m_bWriteToLogList;//־б + int m_LogListMaxLine;//־б,ʱ + int m_MaxWorkRecodCnt;//ӹ¼IJѯ + ofstream m_LogFileStream;//debug ־ļ + ofstream m_ResultFile;//ڼ¼ļ + + CString m_LastLogStr;//һ־ + bool m_bNotWriteSameLog;//Ҫʾͬ־ + + CString m_CurDebugLogFilePath;//־ļ·,жǷҪ־· +}; + +extern CLogMgr* gLogMgr; \ No newline at end of file diff --git a/LaipuDrawing/MainFrm.cpp b/LaipuDrawing/MainFrm.cpp new file mode 100644 index 0000000..8e03a61 --- /dev/null +++ b/LaipuDrawing/MainFrm.cpp @@ -0,0 +1,570 @@ + +// MainFrm.cpp : CMainFrame ʵ +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "MainFrm.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" +#include "PltReader.h" +#include "GlobalFunction.h" +#include "MarkObjPropertieMgr.h" +#include "ModuleDeviceMgr.h" +#include "ModuleDrawMgr.h" +#include "DlgAuthorityLogin.h" +#include "AuthorityMgr.h" +#include "MsgBox.h" +#include "TemplateMgr.h" +#include "WorkFileMgr.h" +#include "PropertieMgr.h" +#include "DlgAuthorityAccount.h" +#include "WorkTime.h" +#include "ProgramLaserTuiHuo.h" +#include "FileMgr.h" +#include "DlgDeviceMain.h" +#include "DlgChildEventLog.h" + + +#define DLG_FACTORY_MODE_FILE _T("\\Factory_mode_0.bat") //ǷΪģʽļ +#define PAR_TempVal "PAR_TempVal"//¶ֵ +#define PAR_TempErrMsg "PAR_TempErrMsg"//ʹϢ + + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif +// CMainFrame + +IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWndEx) + +const int iMaxUserToolbars = 10; +const UINT uiFirstUserToolBarId = AFX_IDW_CONTROLBAR_FIRST + 40; +const UINT uiLastUserToolBarId = uiFirstUserToolBarId + iMaxUserToolbars - 1; + +BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWndEx) + ON_WM_CREATE() + ON_WM_COPYDATA()//Ӧ̼Ϣ + // ȫְ + ON_COMMAND(ID_HELP_FINDER, &CMDIFrameWndEx::OnHelpFinder) + ON_COMMAND(ID_HELP, &CMDIFrameWndEx::OnHelp) + ON_COMMAND(ID_DEFAULT_HELP, &CMDIFrameWndEx::OnHelpFinder) + ON_COMMAND(ID_WINDOW_MANAGER, &CMainFrame::OnWindowManager) + ON_COMMAND(ID_VIEW_CUSTOMIZE, &CMainFrame::OnViewCustomize) + ON_REGISTERED_MESSAGE(AFX_WM_CREATETOOLBAR, &CMainFrame::OnToolbarCreateNew) + ON_COMMAND_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_WINDOWS_7, &CMainFrame::OnApplicationLook) + ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_WINDOWS_7, &CMainFrame::OnUpdateApplicationLook) + ON_COMMAND(ID_VIEW_CAPTION_BAR, &CMainFrame::OnViewCaptionBar) + ON_UPDATE_COMMAND_UI(ID_VIEW_CAPTION_BAR, &CMainFrame::OnUpdateViewCaptionBar) + ON_COMMAND(ID_TOOLS_OPTIONS, &CMainFrame::OnOptions) + + ON_WM_SETTINGCHANGE() +END_MESSAGE_MAP() + +static UINT indicators[] = +{ + ID_SEPARATOR, // ״ָ̬ʾ + ID_INDICATOR_CAPS, + ID_INDICATOR_NUM, + ID_INDICATOR_SCRL, +}; + +// CMainFrame / + +CMainFrame::CMainFrame() +{ + theApp.m_nAppLook = theApp.GetInt(_T("ApplicationLook"), ID_VIEW_APPLOOK_VS_2008); +} + +CMainFrame::~CMainFrame() +{ +} + +int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) +{ + if (CMDIFrameWndEx::OnCreate(lpCreateStruct) == -1) + return -1; + + BOOL bNameValid; + // ڳ־ֵӾʽ + OnApplicationLook(theApp.m_nAppLook); + + CMDITabInfo mdiTabParams; + #if 0//Ҫѡʽĵ + mdiTabParams.m_style = CMFCTabCtrl::STYLE_3D_ONENOTE; // ʽ... + mdiTabParams.m_bActiveTabCloseButton = TRUE; // Ϊ FALSE ὫرհťѡҲ + mdiTabParams.m_bTabIcons = FALSE; // Ϊ TRUE MDI ѡĵͼ + mdiTabParams.m_bAutoColor = TRUE; // Ϊ FALSE MDI ѡԶɫ + mdiTabParams.m_bDocumentMenu = TRUE; // ѡұԵĵ˵ + EnableMDITabbedGroups(TRUE, mdiTabParams); + #endif + + if (!m_wndMenuBar.Create(this)) + { + TRACE0("δܴ˵\n"); + return -1; // δܴ + } + + m_wndMenuBar.SetPaneStyle(m_wndMenuBar.GetPaneStyle() | CBRS_SIZE_DYNAMIC | CBRS_TOOLTIPS | CBRS_FLYBY); + + // ֹ˵ڼʱý + CMFCPopupMenu::SetForceMenuFocus(FALSE); + + if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) || + !m_wndToolBar.LoadToolBar(theApp.m_bHiColorIcons ? IDR_MAINFRAME_256 : IDR_MAINFRAME)) + { + TRACE0("δܴ\n"); + return -1; // δܴ + } + CString strToolBarName; + bNameValid = strToolBarName.LoadString(IDS_TOOLBAR_STANDARD); + ASSERT(bNameValid); + m_wndToolBar.SetWindowText(strToolBarName); + CString strCustomize; + bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE); + ASSERT(bNameValid); + m_wndToolBar.EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize); + + // ûĹ: + InitUserToolbars(NULL, uiFirstUserToolBarId, uiLastUserToolBarId); + if (!m_wndStatusBar.Create(this)) + { + TRACE0("δܴ״̬\n"); + return -1; // δܴ + } + m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT)); + + // TODO: ϣͲ˵ͣɾ +#if 1 + // Visual Studio 2005 ʽͣΪ + CDockingManager::SetDockingMode(DT_SMART); + // Visual Studio 2005 ʽͣԶΪ + EnableAutoHidePanes(CBRS_ALIGN_ANY); + // 񽫴࣬˽ʱͣ: + EnableDocking(CBRS_ALIGN_TOP | CBRS_ALIGN_BOTTOM | CBRS_ALIGN_RIGHT); +#endif + // : + if (!CreateCaptionBar()) + { + TRACE0("δܴ\n"); + return -1; // δܴ + } + // Ѵ Outlook Ӧͣ + EnableDocking(CBRS_ALIGN_LEFT); + EnableAutoHidePanes(CBRS_ALIGN_RIGHT); + + // ͣ + if (!CreateDockingWindows()) + { + TRACE0("δܴͣ\n"); + return -1; + } + + EnableDocking(CBRS_ALIGN_ANY); + + m_wndMenuBar.EnableDocking(CBRS_ALIGN_ANY); + DockPane(&m_wndMenuBar); + m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY); + DockPane(&m_wndToolBar); + + m_GraphEditPane.EnableDocking(CBRS_ALIGN_TOP); + DockPane(&m_GraphEditPane); + #if 0 + m_DeviceMainPane.EnableDocking(CBRS_ALIGN_ANY); + DockPane(&m_DeviceMainPane); + #endif + // ǿĴڹԻ + EnableWindowsDialog(ID_WINDOW_MANAGER, ID_WINDOW_MANAGER, TRUE); + + // ùͣڲ˵滻 + EnablePaneMenu(TRUE, ID_VIEW_CUSTOMIZE, strCustomize, ID_VIEW_TOOLBAR); + + // ÿ(ס Alt ϶)Զ + CMFCToolBar::EnableQuickCustomization(); + + if (CMFCToolBar::GetUserImages() == NULL) + { + // ûĹͼ + if (m_UserImages.Load(_T(".\\UserImages.bmp"))) + { + CMFCToolBar::SetUserImages(&m_UserImages); + } + } + // ò˵Ի(ʹõ) + + CList lstBasicCommands; + + lstBasicCommands.AddTail(ID_FILE_NEW); + lstBasicCommands.AddTail(ID_FILE_OPEN); + lstBasicCommands.AddTail(ID_FILE_SAVE); + lstBasicCommands.AddTail(ID_FILE_PRINT); + lstBasicCommands.AddTail(ID_APP_EXIT); + lstBasicCommands.AddTail(ID_EDIT_CUT); + lstBasicCommands.AddTail(ID_EDIT_PASTE); + lstBasicCommands.AddTail(ID_EDIT_UNDO); + lstBasicCommands.AddTail(ID_APP_ABOUT); + lstBasicCommands.AddTail(ID_VIEW_STATUS_BAR); + lstBasicCommands.AddTail(ID_VIEW_TOOLBAR); + lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2003); + lstBasicCommands.AddTail(ID_VIEW_APPLOOK_VS_2005); + lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_BLUE); + lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_SILVER); + lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_BLACK); + lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_AQUA); + lstBasicCommands.AddTail(ID_VIEW_APPLOOK_WINDOWS_7); + + CMFCToolBar::SetBasicCommands(lstBasicCommands); + + // ĵӦóڴڱϵ˳н + // ĽĿԣΪʾĵͼ + //ModifyStyle(0, FWS_PREFIXTITLE); + + return 0; +} + +BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) +{ + if( !CMDIFrameWndEx::PreCreateWindow(cs) ) + return FALSE; + // CREATESTRUCT cs ޸Ĵʽ + return TRUE; +} +#if 1//ͣؼ +BOOL CMainFrame::CreateDockingWindows() +{ + + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,DLG_FACTORY_MODE_FILE);//ļ· + if(FileMgr.IsFileExist(FilePath)) + { + gbFactoryMode = true; + } + + { + m_GraphEditPane.SetDlg(&m_DlgGraphEdit); + if (!m_GraphEditPane.Create(_T("Drawing"), this, CRect(0, 0, 0, 0), TRUE, m_DlgGraphEdit.GetIDD(), + WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CBRS_LEFT | CBRS_FLOAT_MULTI)) + { + return FALSE; + } + m_GraphEditPane.EnableDocking(CBRS_ALIGN_ANY); + } + gDlgDeviceMain = new CDlgDeviceMain; + gDlgDeviceMain->Create(IDD_DEVICE_MAIN_DLG, this); + #if 0 + { + m_DeviceMainPane.SetDlg(&m_DlgDeviceMain); + if (!m_DeviceMainPane.Create(_T("Laipu Laser"), this, CRect(0, 0, 3000, 2000), TRUE, m_DlgDeviceMain.GetIDD(), + WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CBRS_LEFT | CBRS_FLOAT_MULTI)) + { + return FALSE; + } + m_DeviceMainPane.EnableDocking(CBRS_ALIGN_ANY); + } + #endif + + return TRUE; +} +#endif + +BOOL CMainFrame::CreateCaptionBar() +{ +#ifdef __CAPTION_BAR__ + if (!m_wndCaptionBar.Create(WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, this, ID_VIEW_CAPTION_BAR, -1, TRUE)) + { + TRACE0("δܴ\n"); + return FALSE; + } + ResetCaptionBar(); +#endif + return TRUE; +} + +// CMainFrame + +#ifdef _DEBUG +void CMainFrame::AssertValid() const +{ + CMDIFrameWndEx::AssertValid(); +} + +void CMainFrame::Dump(CDumpContext& dc) const +{ + CMDIFrameWndEx::Dump(dc); +} +#endif //_DEBUG + + +// CMainFrame Ϣ + +void CMainFrame::OnWindowManager() +{ + ShowWindowsDialog(); +} + +void CMainFrame::OnViewCustomize() +{ + CMFCToolBarsCustomizeDialog* pDlgCust = new CMFCToolBarsCustomizeDialog(this, TRUE /* ɨ˵*/); + pDlgCust->EnableUserDefinedToolbars(); + pDlgCust->Create(); +} + +LRESULT CMainFrame::OnToolbarCreateNew(WPARAM wp,LPARAM lp) +{ + LRESULT lres = CMDIFrameWndEx::OnToolbarCreateNew(wp,lp); + if (lres == 0) + { + return 0; + } + + CMFCToolBar* pUserToolbar = (CMFCToolBar*)lres; + ASSERT_VALID(pUserToolbar); + + BOOL bNameValid; + CString strCustomize; + bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE); + ASSERT(bNameValid); + + pUserToolbar->EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize); + return lres; +} + +void CMainFrame::OnApplicationLook(UINT id) +{ + CWaitCursor wait; + + theApp.m_nAppLook = id; + + switch (theApp.m_nAppLook) + { + case ID_VIEW_APPLOOK_WIN_2000: + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManager)); + break; + + case ID_VIEW_APPLOOK_OFF_XP: + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOfficeXP)); + break; + + case ID_VIEW_APPLOOK_WIN_XP: + CMFCVisualManagerWindows::m_b3DTabsXPTheme = TRUE; + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows)); + break; + + case ID_VIEW_APPLOOK_OFF_2003: + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOffice2003)); + CDockingManager::SetDockingMode(DT_SMART); + break; + + case ID_VIEW_APPLOOK_VS_2005: + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerVS2005)); + CDockingManager::SetDockingMode(DT_SMART); + break; + + case ID_VIEW_APPLOOK_VS_2008: + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerVS2008)); + CDockingManager::SetDockingMode(DT_SMART); + break; + + case ID_VIEW_APPLOOK_WINDOWS_7: + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows7)); + CDockingManager::SetDockingMode(DT_SMART); + break; + + default: + switch (theApp.m_nAppLook) + { + case ID_VIEW_APPLOOK_OFF_2007_BLUE: + CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_LunaBlue); + break; + + case ID_VIEW_APPLOOK_OFF_2007_BLACK: + CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_ObsidianBlack); + break; + + case ID_VIEW_APPLOOK_OFF_2007_SILVER: + CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_Silver); + break; + + case ID_VIEW_APPLOOK_OFF_2007_AQUA: + CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_Aqua); + break; + } + + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOffice2007)); + CDockingManager::SetDockingMode(DT_SMART); + } + + RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME | RDW_ERASE); + + theApp.WriteInt(_T("ApplicationLook"), theApp.m_nAppLook); +} + +void CMainFrame::OnUpdateApplicationLook(CCmdUI* pCmdUI) +{ + pCmdUI->SetRadio(theApp.m_nAppLook == pCmdUI->m_nID); +} + +void CMainFrame::OnViewCaptionBar() +{ +#ifdef __CAPTION_BAR__ + m_wndCaptionBar.ShowWindow(m_wndCaptionBar.IsVisible() ? SW_HIDE : SW_SHOW); + RecalcLayout(FALSE); +#endif +} + +void CMainFrame::OnUpdateViewCaptionBar(CCmdUI* pCmdUI) +{ +#ifdef __CAPTION_BAR__ + pCmdUI->SetCheck(m_wndCaptionBar.IsVisible()); +#endif +} + +void CMainFrame::OnOptions() +{ +} + +BOOL CMainFrame::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle, CWnd* pParentWnd, CCreateContext* pContext) +{ + // ཫִĹ + + if (!CMDIFrameWndEx::LoadFrame(nIDResource, dwDefaultStyle, pParentWnd, pContext)) + { + return FALSE; + } + + + // ΪûԶ尴ť + BOOL bNameValid; + CString strCustomize; + bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE); + ASSERT(bNameValid); + + for (int i = 0; i < iMaxUserToolbars; i ++) + { + CMFCToolBar* pUserToolbar = GetUserToolBarByIndex(i); + if (pUserToolbar != NULL) + { + pUserToolbar->EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize); + } + } + return TRUE; +} + + +void CMainFrame::OnSettingChange(UINT uFlags, LPCTSTR lpszSection) +{ + CMDIFrameWndEx::OnSettingChange(uFlags, lpszSection); +} +//˳Ϣ +LRESULT CMainFrame::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) +{ + switch(message) + { + //ϵͳϢ + case WM_SYSCOMMAND: + { + if(wParam==SC_CLOSE) + { + CMsgBox MsgBox; + if(gProgramLaserTuiHuo->CloseAppCheck()==false) + return 0; + + } + break; + } + } + return CMDIFrameWndEx::WindowProc(message, wParam, lParam); +} +#if 1 +//ʾλ +void CMainFrame::ShowMouseCoord(CPoint point) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + CString MouseX,MouseY; + MouseX.Format("%lf",pt.x); + MouseY.Format("%lf",pt.y); + CString str = "ǰ(λmm ):x = ["+MouseX+"]"+" y = ["+MouseY+"]"; + str += " "+m_StatusBarExtStr; + m_wndStatusBar.SetPaneText(0,(LPCTSTR)str,TRUE); +} +//ʾview ǰű +void CMainFrame::ShowViewScale(double s) +{ + CString Str; + Str.Format("%lf",s); + m_wndStatusBar.SetPaneText(0,(LPCTSTR)Str,TRUE); +} +void CMainFrame::SetCaptionCmdStr(CString str) +{ + m_CaptionCmdStr = str+STR_INPUT_SYMBOL; +} +void CMainFrame::SetCaptionInputStr(CString str) +{ + m_CaptionInputStr = str; +} +void CMainFrame::RefreashCaptionBar() +{ + +} +void CMainFrame::ResetCaptionBar() +{ + m_CaptionCmdStr = ""; + m_CaptionInputStr = ""; + RefreashCaptionBar(); + ResetStatusBarExtStr(); +} +void CMainFrame::ResetStatusBarExtStr() +{ + m_StatusBarExtStr = ""; +} +void CMainFrame::SetStatusBarExtStr(CString str,CString val1,CString val2) +{ + if(val1 != STR_NULL || val2 != STR_NULL) + { + str += " : "; + } + if(val1 != STR_NULL) + { + val1 = "<"+val1+">"; + } + if(val2 != STR_NULL) + { + val2 = "<"+val2+">"; + } + m_StatusBarExtStr = str+val1+val2; +} +//Ի󶨵obj +void CMainFrame::UnBindingDlg() +{ + +} +//Ƿ +void CMainFrame::LockPane(bool bLock) +{ + m_GraphEditPane.EnableGripper(!bLock); + m_DeviceMainPane.EnableGripper(!bLock); +} +// +void CMainFrame::ShowWindowMax() +{ + ShowWindow(SW_SHOWMAXIMIZED); +} +//С +void CMainFrame::ShowWindowMin() +{ + ShowWindow(SW_SHOWMINIMIZED); +} +//յ̼Ϣ +BOOL CMainFrame::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct) +{ + CString strRecievedText = (LPCSTR)(pCopyDataStruct->lpData); + if(gChildEventLog) + { + CDlgChildEventLog *pDlgChild = dynamic_cast(gChildEventLog); + pDlgChild->InsertLogToList(strRecievedText,_LogListType_LaipuLaser); + } + return CMDIFrameWndEx::OnCopyData(pWnd, pCopyDataStruct); +} + +#endif + + diff --git a/LaipuDrawing/MainFrm.h b/LaipuDrawing/MainFrm.h new file mode 100644 index 0000000..dd101eb --- /dev/null +++ b/LaipuDrawing/MainFrm.h @@ -0,0 +1,88 @@ + +// MainFrm.h : CMainFrame Ľӿ +// + +#pragma once +#include "OutputWnd.h" +#include "Resource.h" +#include "PaneDialogTmp.h" +#include "DlgGraphEdit.h" + + +class CMainFrame : public CMDIFrameWndEx +{ + DECLARE_DYNAMIC(CMainFrame) +public: + CMainFrame(); + +// +public: + +// +public: + void ShowMouseCoord(CPoint point); + void ShowViewScale(double s); + void ResetCaptionBar(); + void ResetStatusBarExtStr(); + void SetStatusBarExtStr(CString str,CString val1,CString val2); + void SetCaptionCmdStr(CString str); + void SetCaptionInputStr(CString str); + void RefreashCaptionBar(); + void UnBindingDlg(); + void LockPane(bool bLock); + void ShowWindowMax(); + void ShowWindowMin(); +// д +public: + virtual BOOL PreCreateWindow(CREATESTRUCT& cs); + virtual BOOL LoadFrame(UINT nIDResource, DWORD dwDefaultStyle = WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, CWnd* pParentWnd = NULL, CCreateContext* pContext = NULL); +// ʵ +public: + virtual ~CMainFrame(); +#ifdef _DEBUG + virtual void AssertValid() const; + virtual void Dump(CDumpContext& dc) const; +#endif + +public: // ؼǶԱ + CMFCMenuBar m_wndMenuBar; + CMFCToolBar m_wndToolBar; + CMFCStatusBar m_wndStatusBar; + CMFCToolBarImages m_UserImages; +#ifdef __CAPTION_BAR__ + CMFCCaptionBar m_wndCaptionBar;// +#endif +//ͣڶ----------------------------------------- + + CDlgGraphEdit m_DlgGraphEdit; + CPaneDialogTmp m_GraphEditPane; + + + CPaneDialogTmp m_DeviceMainPane; +// ɵϢӳ亯 +protected: + afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); + afx_msg void OnWindowManager(); + afx_msg void OnViewCustomize(); + afx_msg LRESULT OnToolbarCreateNew(WPARAM wp, LPARAM lp); + afx_msg void OnApplicationLook(UINT id); + afx_msg void OnUpdateApplicationLook(CCmdUI* pCmdUI); + afx_msg void OnViewCaptionBar(); + afx_msg void OnUpdateViewCaptionBar(CCmdUI* pCmdUI); + afx_msg void OnOptions(); + afx_msg void OnSettingChange(UINT uFlags, LPCTSTR lpszSection); + afx_msg LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam); + afx_msg BOOL OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct); + DECLARE_MESSAGE_MAP() + + BOOL CreateDockingWindows(); + BOOL CreateCaptionBar(); +private: + CString m_CaptionCmdStr;//ַ + CString m_CaptionInputStr;//ַ + CString m_StatusBarExtStr;//״̬Ϣ +public: + +}; + + diff --git a/LaipuDrawing/MarkArea.cpp b/LaipuDrawing/MarkArea.cpp new file mode 100644 index 0000000..223bd93 --- /dev/null +++ b/LaipuDrawing/MarkArea.cpp @@ -0,0 +1,221 @@ +#include "StdAfx.h" +#include "MarkArea.h" +#include "DrawSimpleShape.h" +#include "Layer.h" +#include "TemplateMgr.h" +#include "ObjComponentMgr.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "CommonFlowMgr.h" +#include "GlobalDrawMgr.h" + + +#define MIN_OBJ_CNT 5 //obj +CMarkArea::CMarkArea() +{ + UpdateSize(); + m_bSel = false;//ѡ״̬ + Init(); +} +CMarkArea::CMarkArea(Dbxy pt,DbSize size) +{ + m_RealBasePt = m_BasePt = pt;//׼ + m_Size = size;//ߴ + Init(); +} +void CMarkArea::Init() +{ + m_AreaIdx = 0;//ı + m_AreaPenNum = 0;//һobj ıʺ +} +CMarkArea::~CMarkArea(void) +{ +} +#if 1 +void CMarkArea::Serialize(CArchive& ar) +{ + if(ar.IsStoring()) + { + ar<>m_BasePt.x; + ar>>m_BasePt.y; + ar>>m_Size.w; + ar>>m_Size.h; + ar>>m_Offset.x; + ar>>m_Offset.y; + } +} +void CMarkArea::WriteWorkFile(vector &LabVec) +{ + LabVec.push_back(CLab(LAB_NULL,m_BasePt.x)); + LabVec.push_back(CLab(LAB_NULL,m_BasePt.y)); + LabVec.push_back(CLab(LAB_NULL,m_Size.w)); + LabVec.push_back(CLab(LAB_NULL,m_Size.h)); + LabVec.push_back(CLab(LAB_NULL,m_Offset.x)); + LabVec.push_back(CLab(LAB_NULL,m_Offset.y)); +} +void CMarkArea::ReadWorkFile(CLabVecRang &LabVecRang) +{ + int idx = LabVecRang.GetStart(); + m_BasePt.x = LabVecRang.GetDouble(idx++); + m_BasePt.y = LabVecRang.GetDouble(idx++); + m_Size.w = LabVecRang.GetDouble(idx++); + m_Size.h = LabVecRang.GetDouble(idx++); + m_Offset.x = LabVecRang.GetDouble(idx++); + m_Offset.y = LabVecRang.GetDouble(idx++); +} +//³ߴΪ񾵷Χ +void CMarkArea::UpdateSize() +{ +} +//ȡarea ۷Χ +DbRect CMarkArea::GetRect() +{ + DbRect rect(m_BasePt,m_Size); + return rect; +} +void CMarkArea::Draw(CDC* pDC,bool bSel) +{ + CPen pen; + if(bSel || m_bSel) + { + pen.CreatePen(PS_DOT,1,RGB_RED); + } + else + { + pen.CreatePen(PS_DOT,1,RGB_PINK); + } + double Gap = 0;//ʾһ + DbSize size = GetSize(); + size.w += Gap; + size.h += Gap; + + DbRect rect; + rect.Creat(m_BasePt,size); + // + DrawRect(pDC,pen,rect,false); + + //ѡ״̬ʱм + if(m_bSel) + { + double GridGap = gDraw->GetAreaGridGap();//mm + Drawgridding(pDC,pen,rect,GridGap); + } +} +bool CMarkArea::DrawObjComponentVec(vector> &vec,CDC* pDC,bool bSel) +{ + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->Draw(pDC); + } + return true; +} +//Ƿй +bool CMarkArea::HasWorkData() +{ + if(m_WorkData.Empty()) + return false; + return true; +} +bool CMarkArea::IsPtInArea(Dbxy pt) +{ + return IsPointInRect(pt,DbRect(m_BasePt,m_Size)); +} +void CMarkArea::SetBasePt(Dbxy pt) +{ + m_BasePt = pt; + SetRealBasePt(pt); +} +#endif +#if 1 +//ȡʵλ +Dbxy CMarkArea::GetRealBasePt() +{ + if(m_RealBasePt.Equal(Dbxy(0,0))) + m_RealBasePt = m_BasePt; + return m_RealBasePt; +} +//Ѽarea Χڵobj (Product ǵǰҪӹĹ,Ҫƫת) +void CMarkArea::CollectWorkData(bool bNeedSel) +{ + // + m_WorkData.Clear(); + vector> &WorkDataVec = m_WorkData.GetDataVec(); + //ѼԪ----------------------------------- + //CollectComponentObj(WorkDataVec,bNeedSel); + //ûռԭݲѼlayer obj + if(WorkDataVec.empty()) + { + //ҵarea ڵobj + CObjContainer ObjContainer; + CollectLayerObjExt(ObjContainer,bNeedSel); + int AreaCycleCnt = 1; + for(int k=0;k> &ObjVec = LayerObjContainer.GetObjVec(); + //жÿobj Ҫĸmarkarea + DbRect Rect = GetRect(); + vector>::iterator iter = ObjVec.begin(); + vector>::iterator iter_end = ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(!bNeedSel || (bNeedSel && (*iter)->IsSelected())) + { + if((*iter)->IsbMarkPt())//Ҫռmark + continue; + + if(!(*iter)->IsbFillObj())//˻豸ֻռ + continue; + if(!(*iter)->IsbCollected() && (*iter)->IsInRect(Rect,false))//ֻҪһݵrect ڶ + { + (*iter)->SetbCollected(true);//Ϊռ + ObjContainer.AddObject((*iter)); + m_AreaPenNum = (*iter)->GetPenNum();//obj ıʺ + } + } + } +} +//ѼԪ(ռobj ᱻ,ֹarea ظռ) +void CMarkArea::CollectComponentObj(vector> &vec,bool bNeedSel) +{ + //ռarea ڵ + gObjComponentMgr->CollectWorkData(GetRect(),vec,bNeedSel); +} +//ͨݷΧarea ĺͳߴ +void CMarkArea::AdjustByObj() +{ + //area ڵݷΧ + DbRect DataRect = gObjComponentMgr->SetMarkedStateRect(GetRect(),false); + DbSize size = DataRect.GetSize(); + if(size.w>0 && size.h>0) + { + m_BasePt = DataRect.GetCenterPt(); + m_Size = size; + } +} +#endif + diff --git a/LaipuDrawing/MarkArea.h b/LaipuDrawing/MarkArea.h new file mode 100644 index 0000000..d78a7be --- /dev/null +++ b/LaipuDrawing/MarkArea.h @@ -0,0 +1,64 @@ +#pragma once +#include "GlobalDefine.h" +#include "ObjContainer.h" +#include "WorkData.h" +#include "SmartPtr.h" +#include "ObjComponent.h" + + + +class CProduct; + +// +class CMarkArea +{ +public: + CMarkArea(); + CMarkArea(Dbxy pt,DbSize size); + ~CMarkArea(void); + void Serialize(CArchive& ar); + void WriteWorkFile(vector &LabVec); + void ReadWorkFile(CLabVecRang &LabVecRang); + void Draw(CDC* pDC,bool bSel); + DbRect GetRect(); + Dbxy GetBasePt(){return m_BasePt;}; + void SetBasePt(Dbxy pt); + DbSize GetSize(){return m_Size;}; + void CollectWorkData(bool bNeedSel); + bool HasWorkData(); + vector> &GetDataVec(){return m_WorkData.GetDataVec();}; + CWorkData &GetWorkData(){return m_WorkData;}; + void SetSelState(bool b){m_bSel = b;}; + bool IsSelected(){return m_bSel;}; + bool IsPtInArea(Dbxy pt); + void UpdateSize(); + void AdjustByObj(); + Dbxy GetRealBasePt();//ȡʵλ + void SetRealBasePt(Dbxy pt){m_RealBasePt = pt;}; + int GetAreaIdx(){return m_AreaIdx;}; + void SetAreaIdx(int n){m_AreaIdx = n;}; + int GetAreaPenNum(){return m_AreaPenNum;}; +private: + void CollectLayerObjExt(CObjContainer &ObjContainer,bool bNeedSel); + void CollectComponentObj(vector> &vec,bool bNeedSel); + bool DrawObjComponentVec(vector> &vec,CDC* pDC,bool bSel); + void CollectObjExt(Sptr &pObj,DbRect &rect); + void ResetObjCollectState(); + void Init(); +private: + Dbxy m_BasePt;//Ļ׼(ĵ) + Dbxy m_RealBasePt;//area ڵĵĻ׼,ڱ֤ʹ񾵵ӹ + DbSize m_Size;//ijߴ + Dbxy m_Offset;//ǿƫ,е + bool m_bSel;//ѡ״̬ + CWorkData m_WorkData;//(ռĵ) + CObjContainer m_ObjContainer;//ҲԼͼobj + int m_AreaIdx;//ı + + int m_AreaPenNum;//һobj ıʺ +}; + + + + + diff --git a/LaipuDrawing/MarkAreaMgr.cpp b/LaipuDrawing/MarkAreaMgr.cpp new file mode 100644 index 0000000..7b54b77 --- /dev/null +++ b/LaipuDrawing/MarkAreaMgr.cpp @@ -0,0 +1,518 @@ +#include "StdAfx.h" +#include "MarkAreaMgr.h" +#include "CStringFuc.h" +#include "GlobalDrawMgr.h" +#include "FileMgr.h" +#include "LogMgr.h" +#include "ObjComponentMgr.h" +#include "WorkFileLable.h" +#include "WorkFileMgr.h" +#include "Layer.h" +#include "WorkDataMgr.h" +#include "CommonFlowMgr.h" + +#define FILE_PATH _T("\\Parameter\\MarkArea\\MarkArea.par") +#define FIXED_FILE_PATH _T("\\Parameter\\MarkArea\\FixedMarkArea.par")//̶(ֻܶ) + + +CMarkAreaMgr *gMarkAreaMgr = new CMarkAreaMgr; +CMarkAreaMgr::CMarkAreaMgr(void) +{ + m_CurSelIdx = -1;//ǰѡ ֵ + m_bDraw = false;//Ƿ + m_bDrawIdx = false;//Ƿʾarea ֵ +} +CMarkAreaMgr::~CMarkAreaMgr(void) +{ +} +void CMarkAreaMgr::OnAppInitialize() +{ + SaveOrLoad(false);//ȡļ +} +void CMarkAreaMgr::Draw(CDC* pDC) +{ + if(!m_bDraw) + return; + int size = m_AreaVec.size(); + for(int i=0;iDrawTxt(pDC,str,m_AreaVec[i].GetBasePt()); + } + } +} +//ͨѡarea ,һֻѡһ +void CMarkAreaMgr::SelAreaByPt(Dbxy pt) +{ + int size = m_AreaVec.size(); + for(int i=0;iWriteDebugLog("MarkArea File Read Err", _LOG_ERROR); + } + } +} +void CMarkAreaMgr::SaveOrLoadExt(CArchive &ar) +{ + int size = 0; + if(ar.IsStoring()) + { + size = m_AreaVec.size();//area + ar<>size; + for(int i=0;i &LabVec) +{ + int size = m_AreaVec.size(); + for(int i=0;i LabVecRangVec; + CWorkFileMgr WorkFileMgr; + WorkFileMgr.SeparateStrVec(LabVecRang,LabVecRangVec,LAB_MARK_AREA_START,LAB_MARK_AREA_END); + + //ÿ + if(!LabVecRangVec.empty()) + { + m_AreaVec.clear(); + vector::iterator iter = LabVecRangVec.begin(); + vector::iterator iter_end = LabVecRangVec.end(); + for(;iter!=iter_end;iter++) + { + CMarkArea MarkArea; + MarkArea.ReadWorkFile(*iter); + m_AreaVec.push_back(MarkArea); + } + } +} +#endif + +#if 1//༭area õĺ +void CMarkAreaMgr::Add() +{ + if(m_AreaVec.empty())//½ + { + CMarkArea Area; + m_AreaVec.push_back(Area); + } + else//ѡе + { + if(IdxValid(m_CurSelIdx)) + { + CMarkArea Area(m_AreaVec[m_CurSelIdx]); + m_AreaVec.push_back(Area); + } + } +} +void CMarkAreaMgr::InsertList(CListCtrl &List) +{ + int size = m_AreaVec.size(); + for(int i=0;i= size) + return false; + return true; +} +void CMarkAreaMgr::DelSel(int &idx) +{ + if(!IdxValid(idx)) + return; + vector::iterator iter = m_AreaVec.begin(); + vector::iterator iter_end = m_AreaVec.end(); + int i=0; + for(;iter!=iter_end;iter++) + { + if(i==idx) + { + m_AreaVec.erase(iter); + idx = -1; + break; + } + i++; + } +} +void CMarkAreaMgr::DelAll() +{ + m_AreaVec.clear(); + m_CurSelIdx = -1;//ǰѡ ֵ +} +//idx +void CMarkAreaMgr::OpArea(int idx,CMarkArea &Area,bool bRead) +{ + if(!IdxValid(idx)) + return; + ResetAllAreaSelState(); + + int size = m_AreaVec.size(); + for(int i=0;iWriteDebugLog("Func---->CollectWorkData"); + //obj ռ״̬---------------------------------- + gObjComponentMgr->ResetObjCollectState(false); + CObjContainer &LayerObjContainer = gLayer.GetObjContainer(); + LayerObjContainer.ResetAllCollectedState(); + vector::iterator iter = m_AreaVec.begin(); + vector::iterator iter_end = m_AreaVec.end(); + for(int i=0;iter!=iter_end;iter++,i++) + { + (*iter).CollectWorkData(bNeedSel); + } +} +//Ƿмӹ +int CMarkAreaMgr::GetHasWorkDataAreaCnt() +{ + int Cnt = 0; + vector::iterator iter = m_AreaVec.begin(); + vector::iterator iter_end = m_AreaVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).HasWorkData())//ֻҪһarea ݼ + { + Cnt++; + } + } + if(Cnt == 0) + gLogMgr->WriteDebugLog("Err----> not have work data",_LOG_ERROR); + return Cnt; +} + +#endif +//д +void CMarkAreaMgr::ArrayCreat(int CntX,int CntY,double Offset) +{ + DelAll(); + //Ͻarea + Dbxy pt; + pt.x = ((CntX-1)*Offset)/2; + pt.y = ((CntY-1)*Offset)/2; + double flag = -1;//־ + for(int i=0;i::iterator iter = m_AreaVec.begin(); + vector::iterator iter_end = m_AreaVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetSelState(false); + } +} +int CMarkAreaMgr::GetCurSelIdx() +{ + int size = m_AreaVec.size(); + if(m_CurSelIdx::iterator iter = m_AreaVec.begin(); + vector::iterator iter_end = m_AreaVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).UpdateSize(); + } +} +void CMarkAreaMgr::ReReadFixMarkArea() +{ + //¶ȡmarkaera + DelAll(); + SaveOrLoad(false,true);//ӹ̶ļ +} +//ͨobj markarea ĵͷΧ +void CMarkAreaMgr::AdjustByObj() +{ + gLogMgr->WriteDebugLog("func : Adjust MarkArea By Obj"); + ReReadFixMarkArea(); + + double MaxSize = 0; + vector::iterator iter = m_AreaVec.begin(); + vector::iterator iter_end = m_AreaVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).AdjustByObj(); + DbSize size = (*iter).GetSize(); + if(size.w>MaxSize) + MaxSize = size.w; + if(size.h>MaxSize) + MaxSize = size.h; + } + + CString LogStr; + LogStr.Format(_T("[MaxAreaSize] = [%.3f]"),MaxSize); + gLogMgr->WriteDebugLog(LogStr); +} +#if 1 +//(ѻʱʹ) +//һвͬģ +//˳MarkArea ı +void CMarkAreaMgr::Adjust() +{ + gLogMgr->WriteDebugLog("func : CMarkAreaMgr---->Adjust"); + int idx = 0; + vector::iterator iter = m_AreaVec.begin(); + vector::iterator iter_end = m_AreaVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).HasWorkData())//ֻҪһarea ݼ + { + (*iter).SetAreaIdx(idx++); + } + } +} + +/*ݵѻ +DataVec +TempIdx ģ +TempCnt ģ +PenPar 񾵲 +CardIdx ѻı +*/ +void CMarkAreaMgr::SendDataToCard(int CardIdx) +{ + +} +//ǷȫΪ +bool CMarkAreaMgr::IsAllPtData(vector> &PtDataVec) +{ + int size = PtDataVec.size(); + for(int i=0;i &OneDataVec = PtDataVec[i]; + int size1 = OneDataVec.size(); + if(size1 > 1) + { + return false; + } + } + return true; +} +//תԪģݵĸʽ +void CMarkAreaMgr::ConvertTempData(vector> &DataVec,vector &TempDataVec) +{ + CPenPar &PenPar = gPenParMgr->GetCurPen(); + + int size = DataVec.size(); + for(int i=0;i &OneDataVec = DataVec[i]; + int size1 = OneDataVec.size(); + int WorkTimes = 1; + + if(size1 == 1)//ֻһ + { + TempDataVec.push_back((double)(size1*WorkTimes));// + for(int k=0;k> &DataVec,vector &PosVec) +{ + int size = DataVec.size(); + for(int i=0;i &OneDataVec = DataVec[i]; + int size1 = OneDataVec.size(); + if(size1 == 1)//ֻһݲΪԪ + { + PosVec.push_back(OneDataVec[0]); + } + } +} +//鴥ģİȫ +bool CMarkAreaMgr::CheckTempIdx(int idx) +{ + return true; + if(idx<0 || idx>=m_CurTempCnt) + { + CString LogStr; + LogStr.Format(_T("Err---->ģ[idx] = [%d]"),idx); + gLogMgr->WriteDebugLog(LogStr); + return false; + } + return true; +} +#endif diff --git a/LaipuDrawing/MarkAreaMgr.h b/LaipuDrawing/MarkAreaMgr.h new file mode 100644 index 0000000..d59d009 --- /dev/null +++ b/LaipuDrawing/MarkAreaMgr.h @@ -0,0 +1,62 @@ +#pragma once +#include "MarkArea.h" +#include "Module.h" +#include "EnumDirection.h" +// +class CMarkAreaMgr :public CModule +{ +public: + CMarkAreaMgr(void); + ~CMarkAreaMgr(void); + virtual void OnAppInitialize(); + virtual void Draw(CDC* pDC);//pDC һЩ + virtual MODULE GetModuleType(){return _MARK_AREA_PROP;}; + virtual void WriteWorkFileExt(vector &LabVec); + virtual void ReadWorkFile(CLabVecRang &LabVecRang); + + void Add(); + void AddArea(CMarkArea &Area){m_AreaVec.push_back(Area);}; + void InsertList(CListCtrl &List); + void DelSel(int &idx); + void DelAll(); + void OpArea(int idx,CMarkArea &Area,bool bRead); + void Order(int &idx,bool bMoveUp); + void SetCurSelIdx(int idx){m_CurSelIdx = idx;}; + int GetCurSelIdx(); + bool GetbDraw(){return m_bDraw;}; + void SetbDraw(bool b){m_bDraw = b;}; + void SaveOrLoad(bool bSave,bool bFixed = false); + void SaveOrLoadExt(CArchive &ar); + bool Empty(){return m_AreaVec.empty();}; + int GetHasWorkDataAreaCnt(); + vector &GetAreaVec(){return m_AreaVec;} + void ArrayCreat(int CntX,int CntY,double Offset); + void ResetAllAreaSelState(); + void MoveAllArea(double Val,DIRECTION dir); + void SelAreaByPt(Dbxy pt); + void SetAllMarkSize(); + void CollectWorkData(bool bNeedSe); + void SelFristArea(); + void SetbDrawIdx(bool b){m_bDrawIdx = b;}; + void AdjustByObj(); + void ReReadFixMarkArea(); + void Adjust(); + void SendDataToCard(int CardIdx); + bool CheckTempIdx(int idx); +private: + bool IdxValid(int idx); + void SwapArea(int &idx1,int idx2); + void ConvertTempData(vector> &DataVec,vector &TempDataVec); + void ConvertPosVec(vector> &DataVec,vector &PosVec); + bool IsAllPtData(vector> &PtDataVec); +private: + vector m_AreaVec; + int m_CurSelIdx;//ǰѡarea ֵ + bool m_bDraw;//Ƿ + bool m_bDrawIdx;//Ƿʾarea ֵ + int m_CurTempCnt;//ǰģ + + +}; + +extern CMarkAreaMgr *gMarkAreaMgr; \ No newline at end of file diff --git a/LaipuDrawing/MarkObjPropertieMgr.cpp b/LaipuDrawing/MarkObjPropertieMgr.cpp new file mode 100644 index 0000000..8a67091 --- /dev/null +++ b/LaipuDrawing/MarkObjPropertieMgr.cpp @@ -0,0 +1,231 @@ +#include "StdAfx.h" +#include "MarkObjPropertieMgr.h" +#include "MainFrm.h" +#include "GlobalFunction.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "CommandStretch.h" +#include "CommandMgr.h" + + + +CMarkObjPropertieMgr *gMarkObjPropertieMgr = new CMarkObjPropertieMgr; +CMarkObjPropertieMgr::CMarkObjPropertieMgr(void) +{ + m_PenNum = -1;//ѡobj ıʺ +} +CMarkObjPropertieMgr::~CMarkObjPropertieMgr(void) +{ +} +#if 1 +//ҳ +CMFCPropertyGridProperty *CMarkObjPropertieMgr::CreatGridProperty() +{ + //¹ֵ + UpdateCommonPropVal(); +//-------------------------------------------------------------------------------// + CString PropertyName;// + CString Description;// + CString Name; + //-------------------------------------------------------------------------------// + PropertyName = _T("ͼ"); + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); + + PropertyName = _T(""); + CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(PropertyName); + //-------------------------------------------------------------------------------// + { + //Աӳ + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_Coord.x); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + //ʾ + PropertyName = _T("x "); + Description = _T("ѡx ֵ(λ:mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_Coord.x, Description); + pGroup1->AddSubItem(p1); + gDrawPropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_Coord.y); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + //ʾ + PropertyName = _T("y "); + Description = _T("ѡy ֵ(λ:mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_Coord.y, Description); + pGroup1->AddSubItem(p1); + gDrawPropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_Size.w); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + //ʾ + PropertyName = _T("x ߴ"); + Description = _T("ѡĿֵ(λ:mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_Size.w, Description); + pGroup1->AddSubItem(p1); + gDrawPropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_Size.h); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + //ʾ + PropertyName = _T("y ߴ"); + Description = _T("ѡĸ߶ֵ(λ:mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_Size.h, Description); + pGroup1->AddSubItem(p1); + gDrawPropertieMgr.Insert(p1, pPropertie); + } + if(m_PenNum >=0) + { + //Աӳ + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_PenNum); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + //ʾ + PropertyName = _T("ʺ"); + Description = _T("ѡıʺ"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_PenNum, Description); + pGroup1->AddSubItem(p1); + gDrawPropertieMgr.Insert(p1, pPropertie); + } + + pGroup->AddSubItem(pGroup1); + + // + CMFCPropertyGridProperty* pSpecialGrid = CreatSpecialGridProperty(this); + if(pSpecialGrid != NULL) + { + pGroup->AddSubItem(pSpecialGrid); + } + return pGroup; +} +// +CMFCPropertyGridProperty *CMarkObjPropertieMgr::CreatSpecialGridProperty(CModule *pModule) +{ + CLayer &layer = gLayer; + return layer.CreatSpecialGridProperty(pModule); +} +//ӦԵĸı +void CMarkObjPropertieMgr::OnPropertyChanged() +{ + CLayer &layer = gLayer; + //ƶ + if(MoveSelObj()==false) + { + //ıߴ + if(ResizeSelObj()==false) + { + // + OnSpecialPropertyChanged(); + } + } + + //ֵ + UpdateSelMarkObjPropertie(); + //ˢ + GetCurViewPtr()->RefreshView(); +} +//ӦԵı仯 +void CMarkObjPropertieMgr::OnSpecialPropertyChanged() +{ + CLayer &layer = gLayer; + layer.OnSpecialPropertyChanged(); +} +#endif +//ѡ +void CMarkObjPropertieMgr::UpdateSelMarkObjPropertie() +{ + if(gbFactoryMode) + { + GetFrame()->m_DlgGraphEdit.UpdateObjPropList(); + } +} +//¹ֵ +void CMarkObjPropertieMgr::UpdateCommonPropVal() +{ + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + + DbRect rect = ObjContainer.GetSelObjRect(); + //ߴ + m_Size = rect.GetSize(); + // + m_Coord = rect.GetCenterPt(); + m_PenNum = ObjContainer.GetSelObjPenNum(); +} +//ͨ޸ƶobj +bool CMarkObjPropertieMgr::MoveSelObj() +{ + CLayer &layer = gLayer; + Dbxy CoordOld = layer.GetSelObjRect().GetCenterPt(); + if(!IsTwoDbEqual(m_Coord.x,CoordOld.x) || !IsTwoDbEqual(m_Coord.y,CoordOld.y)) + { + layer.OnMove(m_Coord.x-CoordOld.x,m_Coord.y-CoordOld.y); + return true; + } + return false; +} +//ıߴ +bool CMarkObjPropertieMgr::ResizeSelObj() +{ + CLayer &layer = gLayer; + DbRect rect = layer.GetSelObjRect(); + DbSize SizeOld = rect.GetSize(); + + Dbxy BasePt;//׼ + double OldSize,NewSize; + double Diff;//¾ɳߴIJ + X_OR_Y xy; + bool flg = false; + if(!IsTwoDbEqual(m_Size.w,SizeOld.w) && m_Size.w > 0) + { + BasePt = rect.GetCenterPt();//׼ + OldSize = SizeOld.w; + NewSize = m_Size.w; + Diff = m_Size.w-SizeOld.w;//ƶ + xy = _X; + flg = true; + } + if(!IsTwoDbEqual(m_Size.h,SizeOld.h) && m_Size.h > 0) + { + BasePt = rect.GetCenterPt();//׼ + OldSize = SizeOld.h; + NewSize = m_Size.h; + Diff = m_Size.h-SizeOld.h;//ƶ + xy = _Y; + flg = true; + } + if(flg) + { + SObjOperatePar par; + par.OpType = _OP_STRETCH; + par.BasePt = BasePt; + par.OldSize = OldSize; + par.NewSize = NewSize; + par.Diff = Diff; + par.xy = xy; + //undo õָ-----start + CCommandStretch *pCommand = new CCommandStretch; + pCommand->SetOperatePar(par); + gCommandMgr.AddUndoCommand(pCommand); + //undo õָ-----end + pCommand->Excute(); + + return true; + } + return false; +} diff --git a/LaipuDrawing/MarkObjPropertieMgr.h b/LaipuDrawing/MarkObjPropertieMgr.h new file mode 100644 index 0000000..d756bd7 --- /dev/null +++ b/LaipuDrawing/MarkObjPropertieMgr.h @@ -0,0 +1,27 @@ +#pragma once +#include "module.h" +#include "EnumPropertieType.h" + +class CMarkObjPropertieMgr :public CModule +{ +public: + CMarkObjPropertieMgr(void); + ~CMarkObjPropertieMgr(void); + virtual void OnAppInitialize(){}; + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual void OnPropertyChanged(); + virtual MODULE GetModuleType(){return _OBJ_PROP;}; + + void UpdateSelMarkObjPropertie(); +private: + CMFCPropertyGridProperty *CreatSpecialGridProperty(CModule *pModule); + void OnSpecialPropertyChanged(); + void UpdateCommonPropVal(); + bool MoveSelObj(); + bool ResizeSelObj(); +private: + Dbxy m_Coord;//ѡobj + DbSize m_Size;//ѡobj ijߴ + int m_PenNum;//ѡobj ıʺ +}; +extern CMarkObjPropertieMgr *gMarkObjPropertieMgr; \ No newline at end of file diff --git a/LaipuDrawing/MeasureMgr.cpp b/LaipuDrawing/MeasureMgr.cpp new file mode 100644 index 0000000..632f641 --- /dev/null +++ b/LaipuDrawing/MeasureMgr.cpp @@ -0,0 +1,34 @@ +#include "StdAfx.h" +#include "MeasureMgr.h" +#include "GlobalFunction.h" +#include "LogMgr.h" + +CMeasureMgr gMeasureMgr; +CMeasureMgr::CMeasureMgr(void) +{ + m_bSelFirstPt = false;//Ƿ˵һ +} +CMeasureMgr::~CMeasureMgr(void) +{ +} +//µIJɼ +void CMeasureMgr::SetNewPt(Dbxy pt) +{ + CString LogStr; + LogStr.Format(_T("MeasureMgr:[pt.x] = [%f] ,[pt.y] = [%f]"),pt.x,pt.y); + gLogMgr->WriteDebugLog(LogStr); + + if(!m_bSelFirstPt)//õһ + { + m_OldPt = pt; + m_bSelFirstPt = true; + return; + } + // + double Dis = CalDistance(m_OldPt,pt); + //Ƕ + double Ang = Cal360AngleByTwoPt(m_OldPt,pt); + + LogStr.Format(_T("MeasureMgr:[Dis] = [%f] ,[Ang] = [%f]"),Dis,Ang); + gLogMgr->WriteDebugLog(LogStr); +} \ No newline at end of file diff --git a/LaipuDrawing/MeasureMgr.h b/LaipuDrawing/MeasureMgr.h new file mode 100644 index 0000000..89b0491 --- /dev/null +++ b/LaipuDrawing/MeasureMgr.h @@ -0,0 +1,18 @@ +#pragma once +#include "GlobalDefine.h" + + +//(ʹƽ̨CCD ͽǶ) +class CMeasureMgr +{ +public: + CMeasureMgr(void); + ~CMeasureMgr(void); + void CatchPt(); + void SetNewPt(Dbxy pt); +private: + bool m_bSelFirstPt;//Ƿ˵һ + Dbxy m_OldPt;//֮ǰIJɼ +}; + +extern CMeasureMgr gMeasureMgr; \ No newline at end of file diff --git a/LaipuDrawing/Module.cpp b/LaipuDrawing/Module.cpp new file mode 100644 index 0000000..0b9a325 --- /dev/null +++ b/LaipuDrawing/Module.cpp @@ -0,0 +1,19 @@ +#include "StdAfx.h" +#include "Module.h" +#include "WorkFileLable.h" +#include "LogMgr.h" +#include "WarningMgr.h" + + +CModule::CModule(void) +{ +} +void CModule::SaveWorkFile(vector &LabVec) +{ + { + LabVec.push_back(CLab(LAB_MODULE_START)); + LabVec.push_back(CLab(LAB_MODULE_TYPE,(int)GetModuleType())); + WriteWorkFileExt(LabVec); + LabVec.push_back(CLab(LAB_MODULE_END)); + } +} diff --git a/LaipuDrawing/Module.h b/LaipuDrawing/Module.h new file mode 100644 index 0000000..258c747 --- /dev/null +++ b/LaipuDrawing/Module.h @@ -0,0 +1,35 @@ +#pragma once +#include "GlobalDefine.h" +#include "EnumPropertieType.h" + +#include "LabVecRang.h" + + +//ȫģĻ +//CreatGridProperty Ini ֮ǰ +class CModule +{ +public: + CModule(void); + virtual ~CModule(void){}; + virtual void OnAppInitialize(){};//ʱ + virtual void OnDeviceInit(){};//Ӧ豸ʼ + //ÿģԼĽṹҰֵ + virtual CMFCPropertyGridProperty *CreatGridProperty(){return NULL;}; + //ÿģԼӦԵĸı + virtual void OnPropertyChanged(){}; + virtual MODULE GetModuleType(){return _MODULE_NULL;};//뷵ģ + virtual void Draw(CDC* pDC){};//pDC һЩ + virtual void WriteWorkFileExt(vector &LabVec){}; + virtual void ReadWorkFile(CLabVecRang &LabVecRang){}; + virtual void OnExitApp(){};//˳ʱ + virtual void TestFunc(){};//Թ + virtual CString GetParDirName(){return "";}; + virtual void SwitchParameter(bool bRunAtDevice){};//һл(bRunAtDevice Ƿ豸) + virtual void OnClearWarningState(){};//Ӧ + void SaveWorkFile(vector &LabVec); + +protected: + +}; + diff --git a/LaipuDrawing/ModuleDeviceMgr.cpp b/LaipuDrawing/ModuleDeviceMgr.cpp new file mode 100644 index 0000000..77556b5 --- /dev/null +++ b/LaipuDrawing/ModuleDeviceMgr.cpp @@ -0,0 +1,86 @@ +#include "StdAfx.h" +#include "ModuleDeviceMgr.h" +#include "GlobalFunction.h" +#include "PropertieMgr.h" +#include "MarkObjPropertieMgr.h" +#include "GlobalFunction.h" +#include "PltReader.h" +#include "Laser.h" +#include "ApplicationPriority.h" +#include "WorkAreaMgr.h" +#include "AuthorityMgr.h" +#include "MarkAreaMgr.h" +#include "SocketMgr.h" +#include "LogMgr.h" +#include "CommonFlowMgr.h" +#include "WorkRecord.h" +#include "Ruler.h" +#include "ObjComponentMgr.h" +#include "EasyOperationMgr.h" +#include "TemplateMgr.h" +#include "GlobalDrawMgr.h" +#include "WorkFileMgr.h" +#include "EncryptionMgr.h" +#include "ProgramLaserTuiHuo.h" +#include "WarningMgr.h" +#include "LaserPowCheckMgr.h" +#include "WaferRecipeDataMgr.h" +#include "RecipeMgr.h" +#include "CommonParaMgr.h" +#include "LanguageMgr.h" +#include "WaferRecipeDataMgr.h" + + + +CModuleDeviceMgr gModuleDeviceMgr;//ȫʹõ +CModuleDeviceMgr::CModuleDeviceMgr(void) +{ +} +CModuleDeviceMgr::~CModuleDeviceMgr(void) +{ + DeleteAllModule(); +} +//ģ(עģʼ˳) +void CModuleDeviceMgr::CreatAllModule() +{ + + //־ģ + gLogMgr = new CLogMgr; + m_ModuleVec.push_back((CModule*)gLogMgr); + //̶ + m_ModuleVec.push_back((CModule*)gCommonParaMgr); + //Ȩ޹ + m_ModuleVec.push_back((CModule*)gAuthorityMgr); + + //ģ(Ҫǰ棬ΪҪΪlayer ģܻ) + m_ModuleVec.push_back((CModule*)gTemplateMgr); + //豸ܹ + m_ModuleVec.push_back((CModule*)gEncryptionMgr); + //ȫֻƹģ + m_ModuleVec.push_back((CModule*)gDraw); + // + m_ModuleVec.push_back((CModule*)gRuler); + //ʲ + m_ModuleVec.push_back((CModule*)gPenParMgr); + // + m_ModuleVec.push_back((CModule*)gWorkAreaMgr); + //Ԫ + m_ModuleVec.push_back((CModule*)gObjComponentMgr); + //ݲ + m_ModuleVec.push_back((CModule*)gEasyOperationMgr); + //ȼ + m_ModuleVec.push_back((CModule*)gAppPriorityMgr); + //ӹļ + m_ModuleVec.push_back((CModule*)gWorkFileMgr); + + m_ModuleVec.push_back((CModule*)gProgramLaserTuiHuo); + + m_ModuleVec.push_back((CModule*)gRecipeMgr); + + m_ModuleVec.push_back((CModule*)gWaferRecipeDataMgr); + +} +void CModuleDeviceMgr::InsertModuleGridProperty(int SelIdx,CMFCPropertyGridCtrl &PropertyGrid) +{ + +} diff --git a/LaipuDrawing/ModuleDeviceMgr.h b/LaipuDrawing/ModuleDeviceMgr.h new file mode 100644 index 0000000..83f33d0 --- /dev/null +++ b/LaipuDrawing/ModuleDeviceMgr.h @@ -0,0 +1,14 @@ +#pragma once +#include "modulemgr.h" + +//豸ص +class CModuleDeviceMgr :public CModuleMgr +{ +public: + CModuleDeviceMgr(void); + ~CModuleDeviceMgr(void); + virtual void InsertModuleGridProperty(int CombType,CMFCPropertyGridCtrl &PropertyGrid); + virtual void CreatAllModule(); +}; + +extern CModuleDeviceMgr gModuleDeviceMgr; \ No newline at end of file diff --git a/LaipuDrawing/ModuleDrawMgr.cpp b/LaipuDrawing/ModuleDrawMgr.cpp new file mode 100644 index 0000000..b51f6a3 --- /dev/null +++ b/LaipuDrawing/ModuleDrawMgr.cpp @@ -0,0 +1,32 @@ +#include "StdAfx.h" +#include "ModuleDrawMgr.h" + +#include "LogMgr.h" +#include "PropertieMgr.h" +#include "MarkObjPropertieMgr.h" +#include "GlobalFunction.h" + +CModuleDrawMgr gModuleDrawMgr; +CModuleDrawMgr::CModuleDrawMgr(void) +{ +} +CModuleDrawMgr::~CModuleDrawMgr(void) +{ + DeleteAllModule(); +} +//ģ(עģʼ˳) +void CModuleDrawMgr::CreatAllModule() +{ + //obj Թģ + m_ModuleVec.push_back((CModule*)gMarkObjPropertieMgr); +} +void CModuleDrawMgr::InsertModuleGridProperty(int CombType,CMFCPropertyGridCtrl &PropertyGrid) +{ + set ModuleSet; + ModuleSet.insert(_OBJ_PROP); + if(gbFactoryMode) + { + InsertPropertiesToGrid(ModuleSet,PropertyGrid); + } + +} \ No newline at end of file diff --git a/LaipuDrawing/ModuleDrawMgr.h b/LaipuDrawing/ModuleDrawMgr.h new file mode 100644 index 0000000..e9e3346 --- /dev/null +++ b/LaipuDrawing/ModuleDrawMgr.h @@ -0,0 +1,14 @@ +#pragma once +#include "modulemgr.h" + +//ͼλص +class CModuleDrawMgr :public CModuleMgr +{ +public: + CModuleDrawMgr(void); + ~CModuleDrawMgr(void); + virtual void InsertModuleGridProperty(int CombType,CMFCPropertyGridCtrl &PropertyGrid); + virtual void CreatAllModule(); +}; + +extern CModuleDrawMgr gModuleDrawMgr; \ No newline at end of file diff --git a/LaipuDrawing/ModuleMgr.cpp b/LaipuDrawing/ModuleMgr.cpp new file mode 100644 index 0000000..d25b4b7 --- /dev/null +++ b/LaipuDrawing/ModuleMgr.cpp @@ -0,0 +1,226 @@ +#include "StdAfx.h" +#include "MainFrm.h" +#include "ModuleMgr.h" +#include "LogMgr.h" +#include "PropertieMgr.h" +#include "GlobalDrawMgr.h" +#include "MarkObjPropertieMgr.h" +#include "GlobalFunction.h" +#include "PltReader.h" +#include "Laser.h" +#include "ApplicationPriority.h" +#include "WorkAreaMgr.h" +#include "Ruler.h" +#include "WorkFileLable.h" +#include "CStringFuc.h" +#include "WorkFileMgr.h" +#include "FileMgr.h" + + +CModuleMgr::CModuleMgr(void) +{ +} +CModuleMgr::~CModuleMgr(void) +{ + +} +void CModuleMgr::DeleteAllModule() +{ + //ͷԴ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)) + { + (*iter)->GetModuleType(); + delete (*iter); + (*iter) = NULL; + } + } +} +#if 1 +//¼еmodule ЩҪ +void CModuleMgr::SaveAllModuleProperty() +{ + gDevicePropertieMgr.SetSaveAllPropertie(true); + gDrawPropertieMgr.SetSaveAllPropertie(true); + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + CMFCPropertyGridProperty* pProp = (*iter)->CreatGridProperty(); + if(pProp) + { + delete pProp; + } + } + gDevicePropertieMgr.SetSaveAllPropertie(false); + gDrawPropertieMgr.SetSaveAllPropertie(false); +} +//ģʼ +void CModuleMgr::AllModuleOnAppInitialize() +{ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->OnAppInitialize(); + } + //GetCurViewPtr()->RefreshView(); +} +//ʼģ,Dzҳ +void CModuleMgr::PropertiesOnAppInitialize() +{ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + CMFCPropertyGridProperty* pProp = (*iter)->CreatGridProperty();//ģԼ𴴽 + if(pProp) + { + delete pProp; + } + } +} +//ָҳwnd +void CModuleMgr::InsertPropertiesToWnd(set &Set,CPanePropertiesWnd &Wnd) +{ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + if(Set.count((*iter)->GetModuleType())) + { + CMFCPropertyGridProperty* pProp = (*iter)->CreatGridProperty();//ģԼ𴴽 + if(pProp) + { + Wnd.InsertGridProperty(pProp); + } + } + } +} +void CModuleMgr::InsertPropertiesToGrid(set &Set,CMFCPropertyGridCtrl &PropertyGrid) +{ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + if(Set.count((*iter)->GetModuleType())) + { + CMFCPropertyGridProperty* pProp = (*iter)->CreatGridProperty();//ģԼ𴴽 + if(pProp) + { + PropertyGrid.AddProperty(pProp); + } + } + } +} +//ģIJϢļ +void CModuleMgr::ExportDevicePar(ofstream *pFile) +{ + +} +//ģдļ +void CModuleMgr::SaveWorkFile(vector &LabVec) +{ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->SaveWorkFile(LabVec); + } +} +//ǷҵӦĶȡģ +bool CModuleMgr::ReadWorkFile(CLabVecRang &LabVecRang) +{ + //ȡģ + CWorkFileMgr WorkFileMgr; + CLab StartLab = WorkFileMgr.FindLab(LabVecRang,LAB_MODULE_TYPE); + if(StartLab.m_ValType == _TYPE_NULL) + return false; + MODULE ModuleType = (MODULE)(StartLab.m_Int); + //ָָģ鴦 + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->GetModuleType()==ModuleType) + { + (*iter)->ReadWorkFile(LabVecRang); + return true; + } + } + return false; +} +#endif +#if 1 +//ʼ +void CModuleMgr::InitPar() +{ + //ģ + CreatAllModule(); + //鲢ڵļ + CreatModuleDir(); + //ʼģ + PropertiesOnAppInitialize(); + + //ģʼ + AllModuleOnAppInitialize(); + //Ĭͼ + //InsertModuleGridProperty(_COMB_OBJ_PROP); +} + +//ģԻһЩԼ +void CModuleMgr::Draw(CDC* pDC) +{ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->Draw(pDC); + } +} +//ÿģļǷڣԶ +void CModuleMgr::CreatModuleDir() +{ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + CString DirName = (*iter)->GetParDirName(); + if(DirName != "") + { + CString DirPath; + CString FileName = "\\Parameter\\"+DirName; + CFileMgr FileMgr; + FileMgr.GetFullFilePath(DirPath,FileName); + if(!FileMgr.IsDirectoryExists(DirPath)) + FileMgr.CreatDir(DirPath); + } + } +} +#endif +#if 1 +void CModuleMgr::OnExitApp() +{ + gExitApp = true; + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->OnExitApp(); + } + Sleep(1000); +} +//Ӧ豸ʼ +void CModuleMgr::OnDeviceInit() +{ + vector::iterator iter = m_ModuleVec.begin(); + vector::iterator iter_end = m_ModuleVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->OnDeviceInit(); + } +} +#endif \ No newline at end of file diff --git a/LaipuDrawing/ModuleMgr.h b/LaipuDrawing/ModuleMgr.h new file mode 100644 index 0000000..5200b65 --- /dev/null +++ b/LaipuDrawing/ModuleMgr.h @@ -0,0 +1,40 @@ +#pragma once + +#include "GlobalDefine.h" +#include "EnumPropertieType.h" +#include "PropertiesWnd.h" +#include "LabVecRang.h" + +//ǰ +class CModule; + +/* +1.ڹȫģ࣬Эģ֮Ĺϵ +2.ΪȫģṩһͳһʼĵطͳһڳʱͷԴ +3.ΪȫģṩԵĶȡͱ,Ա仯ʱ֪ͨӦģ +*/ +class CModuleMgr +{ +public: + CModuleMgr(void); + virtual ~CModuleMgr(void); + virtual void InsertModuleGridProperty(int CombType,CMFCPropertyGridCtrl &PropertyGrid){}; + virtual void CModuleMgr::CreatAllModule(){}; + void InitPar(); + void Draw(CDC* pDC); + void ExportDevicePar(ofstream *pFile); + void SaveAllModuleProperty(); + void SaveWorkFile(vector &LabVec); + bool ReadWorkFile(CLabVecRang &LabVecRang); + void OnExitApp(); + void OnDeviceInit(); +protected: + void DeleteAllModule(); + void AllModuleOnAppInitialize(); + void PropertiesOnAppInitialize(); + void CreatModuleDir(); + void InsertPropertiesToWnd(set &Set,CPanePropertiesWnd &Wnd); + void InsertPropertiesToGrid(set &Set,CMFCPropertyGridCtrl &PropertyGrid); +protected: + vector m_ModuleVec;//洢mgr ָ +}; \ No newline at end of file diff --git a/LaipuDrawing/MouseTool.cpp b/LaipuDrawing/MouseTool.cpp new file mode 100644 index 0000000..4eba6cb --- /dev/null +++ b/LaipuDrawing/MouseTool.cpp @@ -0,0 +1,139 @@ +#include "StdAfx.h" +#include "MouseTool.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" +#include "CommandCreat.h" +#include "CommandMgr.h" +#include "GlobalDrawMgr.h" + +CMouseTool::CMouseTool(void) +{ + m_Status = _STATUS_1;//ʼΪһ + ClearFirstPoint(); + m_bFirstMove = true;//ڱǵһƶ +} +CMouseTool::~CMouseTool(void) +{ +} +void CMouseTool::AddObject(CObjBase *p) +{ + Sptr sPtr(p); + m_TmpObjContainer.AddObject(sPtr); + gLayer.AddTmpObject(sPtr); +} +void CMouseTool::SaveDownPoint(CPoint point) +{ + SaveDownPoint(gDraw->CPoint2Dbxy(point)); +} +void CMouseTool::SaveDownPoint(Dbxy point) +{ + m_DownPoint = point; +} +bool CMouseTool::HasPreMovePt() +{ + if(m_PreMovePt.x == 0 && m_PreMovePt.y == 0) + return false; + else + return true; +} +void CMouseTool::ClearFirstPoint() +{ + m_DownPoint.x = 0; + m_DownPoint.y = 0; + m_PreMovePt.x = 0; + m_PreMovePt.y = 0; +} +void CMouseTool::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + //DZ༭ģʽز + if(!gDraw->IsbObjEditMode()) + return; + SaveDownPoint(point); +} +void CMouseTool::OnRButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + GetCurViewPtr()->OnEscape(); +} +void CMouseTool::OperateOver() +{ + ClearFirstPoint(); + m_bFirstMove = true; + //ɾlayer ʱ----------------------------------- + gLayer.ClearTmpObj(); +} +void CMouseTool::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + OperateOver(); +} +void CMouseTool::AddCreatCommand() +{ + if(!m_TmpObjContainer.Empty()) + { + //ָ-------start + CCommandCreat *p = new CCommandCreat; + gCommandMgr.AddUndoCommand(p,m_TmpObjContainer.GetObjVec()); + p->Excute(); + //ָ-------end + } + //ʱ + m_TmpObjContainer.Clear(); +} +void CMouseTool::OnEscapeKey() +{ + m_TmpObjContainer.Clear(); + OperateOver(); +} +//һ״̬ +void CMouseTool::ToNextStatus() +{ + switch(m_Status) + { + case _STATUS_1: + m_Status = _STATUS_2; + break; + case _STATUS_2: + m_Status = _STATUS_3; + break; + case _STATUS_3: + m_Status = _STATUS_4; + break; + case _STATUS_4: + m_Status = _STATUS_5; + break; + case _STATUS_5: + m_Status = _STATUS_6; + break; + default: + break; + } +} +bool CMouseTool::IsEndStatus() +{ + return (m_Status ==_STATUS_END); +} +bool CMouseTool::IsStartStatus() +{ + return (m_Status ==_STATUS_1); +} +//ģĶ +void CMouseTool::CreatOpSimulateObj() +{ + //ȡѡobj ľ + DbRect rect = gLayer.GetSelObjRect(); + m_OpSimulateObjBak.CreatRect(rect); +} +//ػģ +void CMouseTool::XorRedrawOpSimulateObj(CDC* pDC) +{ + int old_rop = pDC->SetROP2(R2_XORPEN); + m_OpSimulateObj.Draw(pDC,gDraw->GetSelObjectPen()); + pDC->SetROP2(old_rop); +} +//ģ +void CMouseTool::OpSimulateObj(SObjOperatePar &par) +{ + //ÿζӱݶȡֵ + m_OpSimulateObj.DelAllPt(); + m_OpSimulateObj.CopyPt(m_OpSimulateObjBak); + m_OpSimulateObj.Operate(par); +} \ No newline at end of file diff --git a/LaipuDrawing/MouseTool.h b/LaipuDrawing/MouseTool.h new file mode 100644 index 0000000..48e50f6 --- /dev/null +++ b/LaipuDrawing/MouseTool.h @@ -0,0 +1,76 @@ +#pragma once +#include "GlobalDefine.h" +#include "SmartPtr.h" +#include "ObjBase.h" +#include "ObjContainer.h" +#include "ObjPline.h" +#if 1// + +#define CMD_TOOL_CIRCLE_DIA_EDGE "_circle ָԲ[ֱ] []" +#define CMD_TOOL_CIRCLE_CENTER "_circle ָԲ[Բ] " +#define CMD_LINE_FIRST_PT "_line ָһ" +#define CMD_LINE_NEXT_PT "_line ָ߶ε[] [Ƕ]" +#define CMD_RECT_FIRST_PT "_rectang ָһ" +#define CMD_RECT_SIZE "_rectang ָε[][߶]" +#define CMD_TOOL_ROTATO_ANGLE "_rotato ָת[Ƕ]" +#define CMD_TOOL_ROTATO_CENTER "_rotatoָת" +#define CMD_TOOL_MOVE_FIRST_PT "_move ָ" +#define CMD_TOOL_MOVE_DIS "_moveָƶ[x ][y ]" +#define CMD_TOOL_MEASURE_FIRST_PT "_measure ָһ" +#define CMD_TOOL_MEASURE_SECOND_PT "_measure ָڶ" +#define CMD_TOOL_MEASURE_RESULT "_measure []" +#define CMD_TOOL_MEASURE_RESULT2 "_measure [x ƫ] [y ƫ]" +#define CMD_TOOL_MEASURE_RESULT3 "_measure [Ƕ]" +#define CMD_TOOL_MEASURE_RESULT4 "_measure [ԭǶ]" + +#define CMD_TOOL_COPY_BASE_PT "_copy ָ" + +#define REDRAW_CNT 5 +#endif + + +class CMouseTool +{ +public: + CMouseTool(void); + virtual ~CMouseTool(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnRButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnRButtonUp(UINT nFlags, CPoint point,CClientDC &dc){}; + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc){}; + virtual void OnEscapeKey(); + virtual void OperateOver(); + virtual bool OnSetCmd(CString str){return false;}; + virtual bool NeedToPointTool(){return false;};//߽ʱǷҪתΪָ빤 +public: + void SetOperatePar(SObjOperatePar par){m_Par = par;}; + bool IsEndStatus(); + bool IsStartStatus(); + STATUS GetStatus(){return m_Status;}; + Dbxy GetDownPoint(){return m_DownPoint;}; +protected: + virtual void OperateObj(Dbxy StartPt,Dbxy EndPt){}; + void SaveDownPoint(CPoint point); + void SaveDownPoint(Dbxy point); + void SavePreMovePt(CPoint point){m_PreMovePt = point;}; + bool HasPreMovePt(); + void ClearFirstPoint(); + void AddCreatCommand(); + void ToNextStatus(); + void AddObject(CObjBase *pMarkObject); + void CreatOpSimulateObj(); + void XorRedrawOpSimulateObj(CDC* pDC); + void OpSimulateObj(SObjOperatePar &par); +protected: + CObjContainer m_TmpObjContainer;//ʱobj + STATUS m_Status;//ȷÿһʲô + Dbxy m_DownPoint;//갴µĵ + CPoint m_PreMovePt;//һƶλ + bool m_bFirstMove;//ڱǵһƶ + + CObjPline m_OpSimulateObjBak;//ģĶԭʼ + CObjPline m_OpSimulateObj;//ģĶ + SObjOperatePar m_Par;// +}; + diff --git a/LaipuDrawing/MouseToolAddNode.cpp b/LaipuDrawing/MouseToolAddNode.cpp new file mode 100644 index 0000000..f72edff --- /dev/null +++ b/LaipuDrawing/MouseToolAddNode.cpp @@ -0,0 +1,55 @@ +#include "StdAfx.h" +#include "MouseToolAddNode.h" +#include "GlobalDrawMgr.h" +#include "Layer.h" +#include "GlobalFunction.h" +#include "CommandAddNode.h" +#include "CommandMgr.h" + +CMouseToolAddNode::CMouseToolAddNode(void) +{ +} +CMouseToolAddNode::~CMouseToolAddNode(void) +{ +} +void CMouseToolAddNode::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + DbRect rect = gDraw->GetCurPointRect(pt); + + CLayer &layer = gLayer; + if(!layer.HasObjectInRect(rect)) + return; + //ҵһrect obj ----------------------------------------------- + Sptr pObj = layer.GetFirstObjInRect(rect); + //obj rect еĵһ߶----------------------------------------------- + vector LineVec; + pObj->GetLineInRect(rect,LineVec,false); + Dbxy LinePt1 = LineVec[0].m_pt1.GetPt(); + Dbxy LinePt2 = LineVec[0].m_pt2.GetPt(); + + if(IsPointInRect(LinePt1,rect)||IsPointInRect(LinePt2,rect))//Ҫڶ˵㸽 + { + return; + } + //õrect ߶εĽ-------------------------------------------------- + Dbxy MousePt = IntersectionOfRectAndLine(LinePt1,LinePt2,rect); + + //LinePt1 obj + int idx = pObj->GetNodePtIdx(LinePt1); + if(idx!=-1) + { + //뵽LinePt1 ĺ------------------------- + pObj->InsertNode(idx+1,MousePt); + pObj->SetSelected(true); + + //ָ----------------------------------- + CCommandAddNode *p = new CCommandAddNode; + p->SetPar(idx+1,MousePt); + p->AddOpObj(pObj); + gCommandMgr.AddUndoCommand(p); + //ˢ + GetCurViewPtr()->RefreshView(); + } +} + diff --git a/LaipuDrawing/MouseToolAddNode.h b/LaipuDrawing/MouseToolAddNode.h new file mode 100644 index 0000000..77e2ba8 --- /dev/null +++ b/LaipuDrawing/MouseToolAddNode.h @@ -0,0 +1,10 @@ +#pragma once +#include "mousetool.h" +class CMouseToolAddNode :public CMouseTool +{ +public: + CMouseToolAddNode(void); + ~CMouseToolAddNode(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); +}; + diff --git a/LaipuDrawing/MouseToolBreakNode.cpp b/LaipuDrawing/MouseToolBreakNode.cpp new file mode 100644 index 0000000..cc17bcf --- /dev/null +++ b/LaipuDrawing/MouseToolBreakNode.cpp @@ -0,0 +1,79 @@ +#include "StdAfx.h" +#include "MouseToolBreakNode.h" +#include "GlobalDrawMgr.h" +#include "Layer.h" +#include "GlobalFunction.h" +#include "CommandDelNode.h" +#include "CommandBreakNode.h" +#include "ObjPline.h" +#include "CommandMgr.h" + + +CMouseToolBreakNode::CMouseToolBreakNode(void) +{ +} +CMouseToolBreakNode::~CMouseToolBreakNode(void) +{ +} +void CMouseToolBreakNode::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + DbRect rect = gDraw->GetCurPointRect(pt); + + CLayer &layer = gLayer; + if(!layer.HasObjectInRect(rect)) + return; + //ҵһrect obj ----------------------------------------------- + Sptr pObj = layer.GetFirstObjInRect(rect); + //obj rect еĵһnode ----------------------------------------------- + vector LineVec; + pObj->GetLineInRect(rect,LineVec,false); + Dbxy NodePt = LineVec[0].m_pt1.GetPt(); + if(!IsPointInRect(NodePt,rect)) + { + NodePt = LineVec[0].m_pt2.GetPt(); + } + if(!IsPointInRect(NodePt,rect)) + return; + //NodePt obj + int idx = pObj->GetNodePtIdx(NodePt); + if(idx!=-1 && idx!=0) + { + //ǰһ + CObjPline *pPline1 = new CObjPline; + pPline1->CopyPt(*(pObj.GetPtr())); + pPline1->SetSelected(true); + int ptCnt = pPline1->GetPtCnt(); + for(int i=0;i<(ptCnt-(idx+1));i++) + { + pPline1->DelLastDataPoint(); + } + //һ + CObjPline *pPline2 = new CObjPline; + pPline2->CopyPt(*(pObj.GetPtr())); + pPline2->SetSelected(true); + for(int i=0;iDelNodePtByIdx(0); + } + //ָ----------------------------------- + Sptr pObj1(pPline1); + Sptr pObj2(pPline2); + m_TmpObjContainer.AddObject(pObj1); + m_TmpObjContainer.AddObject(pObj2); + + m_TmpObjContainer.AllObjAddToLayer(); + m_TmpObjContainer.Clear();// + gLayer.DelObj(pObj); + + //ָ + CCommandBreakNode *pCmd = new CCommandBreakNode; + pCmd->AddOpObj(pObj); + pCmd->AddOpObj(pObj1); + pCmd->AddOpObj(pObj2); + gCommandMgr.AddUndoCommand(pCmd); + //ˢ + GetCurViewPtr()->RefreshView(); + } +} + diff --git a/LaipuDrawing/MouseToolBreakNode.h b/LaipuDrawing/MouseToolBreakNode.h new file mode 100644 index 0000000..a35e189 --- /dev/null +++ b/LaipuDrawing/MouseToolBreakNode.h @@ -0,0 +1,11 @@ +#pragma once +#include "mousetool.h" +//obj Ϊ߶ +class CMouseToolBreakNode :public CMouseTool +{ +public: + CMouseToolBreakNode(void); + ~CMouseToolBreakNode(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); +}; + diff --git a/LaipuDrawing/MouseToolCircle.cpp b/LaipuDrawing/MouseToolCircle.cpp new file mode 100644 index 0000000..94a1837 --- /dev/null +++ b/LaipuDrawing/MouseToolCircle.cpp @@ -0,0 +1,151 @@ +#include "StdAfx.h" +#include "MouseToolCircle.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +#include "ObjCircle.h" +#include "LogMgr.h" +#include "DrawSimpleShape.h" +#include "ObjArc.h" + + +#define DEFUALT_EDGE_CNT 100//ԲĬϱ +CMouseToolCircle::CMouseToolCircle(void) +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_CIRCLE_CENTER); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + m_Radius = 0; + m_EdgeCnt = DEFUALT_EDGE_CNT; +} +CMouseToolCircle::~CMouseToolCircle(void) +{ +} +void CMouseToolCircle::OperateOver() +{ + //------------------------------------־start + CString val1; + val1.Format("%lf",m_Radius*2); + CString val2; + val2.Format("%ld",m_EdgeCnt); + gLogMgr->WriteCmd(CMD_TOOL_CIRCLE_DIA_EDGE,val1,val2); + //------------------------------------־end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + AddCreatCommand(); + // + m_Status = _STATUS_END; + + CMouseTool::OperateOver(); +} +void CMouseToolCircle::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_1) + { + SaveDownPoint(point); + CObjCircle *pCircle = new CObjCircle; + CCirclePar ObjCirclePar; + ObjCirclePar.CenterPt = pt; + ObjCirclePar.Radius =m_Radius; + pCircle->Creat(ObjCirclePar); + AddObject(pCircle); + //------------------------------------־start + CString val1; + val1.Format("%lf",pt.x); + CString val2; + val2.Format("%lf",pt.y); + gLogMgr->WriteCmd(CMD_TOOL_CIRCLE_CENTER,val1,val2); + //------------------------------------־end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_CIRCLE_DIA_EDGE); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + //һ״̬ + ToNextStatus(); + } + else + { + OperateOver(); + } +} +void CMouseToolCircle::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ +} +void CMouseToolCircle::OnMouseMove(UINT nFlag, CPoint point,CClientDC &dc) +{ + Dbxy OldPt = gDraw->CPoint2Dbxy(m_PreMovePt); + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status!=_STATUS_1) + { + m_Radius = CalDistance(m_DownPoint,pt); + CObjBase *pCurOptObject = m_TmpObjContainer.GetCurOpObj(); + if(pCurOptObject) + { + CObjCircle *p = dynamic_cast(pCurOptObject); + m_TmpObjContainer.XorRedrawObj(&dc,false); + + CCirclePar ObjCirclePar; + ObjCirclePar.CenterPt = m_DownPoint; + ObjCirclePar.Radius =m_Radius; + ObjCirclePar.DEdgeCnt = m_EdgeCnt; + + p->Creat(ObjCirclePar); + m_TmpObjContainer.XorRedrawObj(&dc,false); + //״̬-----------------------------start + CString str1 = "Բ[ֱ] "; + CString str2; + str2.Format("%lf",m_Radius*2); + GetFrame()->ResetStatusBarExtStr(); + GetFrame()->SetStatusBarExtStr(str1,str2,STR_NULL); + //״̬-----------------------------end + } + SavePreMovePt(point); + } +} +bool CMouseToolCircle::OnSetCmd(CString str) +{ + if(m_Status==_STATUS_2)//Բ + { + double Val1=0;//뾶 + double Val2=0;// + int result = GetTwoNum(str,Val1,Val2); + if(result>0) + { + if(result == 1)//ֱֻ + { + Val2 = DEFUALT_EDGE_CNT; + } + if(Val1>0)//ֱҪ0 + { + m_Radius = Val1/2; + //EdgeCnt Ҫ4ı,СΪ4 + int min = 4; + m_EdgeCnt = (int)(Val2/min)*min; + if(m_EdgeCnt(pCurOptObject); + CCirclePar ObjCirclePar; + ObjCirclePar.CenterPt = m_DownPoint; + ObjCirclePar.Radius =m_Radius; + ObjCirclePar.DEdgeCnt = m_EdgeCnt; + + p->Creat(ObjCirclePar); + } + OperateOver(); + return true; + } + } + } + return false; +} + diff --git a/LaipuDrawing/MouseToolCircle.h b/LaipuDrawing/MouseToolCircle.h new file mode 100644 index 0000000..f7a6c0b --- /dev/null +++ b/LaipuDrawing/MouseToolCircle.h @@ -0,0 +1,19 @@ +#pragma once +#include "mousetool.h" +class CMouseToolCircle :public CMouseTool +{ +public: + CMouseToolCircle(void); + ~CMouseToolCircle(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual bool OnSetCmd(CString str); + virtual bool NeedToPointTool(){return true;}; +private: + void OperateOver(); +private: + double m_Radius; + int m_EdgeCnt; +}; + diff --git a/LaipuDrawing/MouseToolCopy.cpp b/LaipuDrawing/MouseToolCopy.cpp new file mode 100644 index 0000000..024a27d --- /dev/null +++ b/LaipuDrawing/MouseToolCopy.cpp @@ -0,0 +1,121 @@ +#include "StdAfx.h" +#include "MouseToolCopy.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" +#include "CommandCopy.h" +#include "DrawSimpleShape.h" +#include "CommandMgr.h" + + +CMouseToolCopy::CMouseToolCopy(void) +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_COPY_BASE_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end +} +CMouseToolCopy::~CMouseToolCopy(void) +{ +} +void CMouseToolCopy::OperateOver() +{ + //obj + SObjOperatePar par; + par.OpType = _OP_MOVE; + par.MoveX = m_MoveDisX; + par.MoveY = m_MoveDisY; + //ֻǰѡobj + m_TmpObjContainer.OperateObj(par,true); + + m_TmpObjContainer.DelSelObj(); + m_TmpObjContainer.AllObjAddToLayer(); + //ָ-------start + CCommandCopy *p = new CCommandCopy; + gCommandMgr.AddUndoCommand(p,m_TmpObjContainer.GetObjVec()); + //ָ-------end + CMouseTool::OperateOver(); + m_Status = _STATUS_END; +} +void CMouseToolCopy::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + + //obj + SObjOperatePar par; + par.OpType = _OP_MOVE; + par.MoveX = m_MoveDisX; + par.MoveY = m_MoveDisY; + //ֻǰѡobj + m_TmpObjContainer.OperateObj(par,true); + //¡ѡobj ʱ + //Ȱ֮ǰΪѡ״̬ + m_TmpObjContainer.NotSelAllObj(); + //ٵ뵱ǰѡobj + gLayer.CloneObj(m_TmpObjContainer,true); + if(m_Status==_STATUS_1)//ָ + { + m_BasePoint = pt; + //ģĶ + CreatOpSimulateObj(); + ToNextStatus(); + } + else + { + //ƶǰλ + m_MoveDisX = pt.x - m_BasePoint.x; + m_MoveDisY = pt.y - m_BasePoint.y; + //⽫һλò + m_bFirstMove = true; + } +} +void CMouseToolCopy::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + +} +void CMouseToolCopy::OnMouseMove(UINT nFlag, CPoint point,CClientDC &dc) +{ + Dbxy OldPt = gDraw->CPoint2Dbxy(m_PreMovePt); + Dbxy CurPt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_2) + { + if(m_bFirstMove==false) + { + //ػģ + XorRedrawOpSimulateObj(&dc); + } + m_bFirstMove = false; + + if(HasPreMovePt())//֮ǰ + { + XorDrawLine(&dc,gDraw->GetObjectPen(),m_BasePoint,OldPt); + } + XorDrawLine(&dc,gDraw->GetObjectPen(),m_BasePoint,CurPt);//һʱ + + //ƶ + m_MoveDisX = CurPt.x - m_BasePoint.x; + m_MoveDisY = CurPt.y - m_BasePoint.y; + //obj + SObjOperatePar par; + par.OpType = _OP_MOVE; + par.MoveX = m_MoveDisX; + par.MoveY = m_MoveDisY; + //ģ + OpSimulateObj(par); + + //ػģ + XorRedrawOpSimulateObj(&dc); + SavePreMovePt(point); + } +} +void CMouseToolCopy::OnEscapeKey() +{ + OperateOver(); +} +bool CMouseToolCopy::OnSetCmd(CString str) +{ + + return false; +} + diff --git a/LaipuDrawing/MouseToolCopy.h b/LaipuDrawing/MouseToolCopy.h new file mode 100644 index 0000000..6e1657f --- /dev/null +++ b/LaipuDrawing/MouseToolCopy.h @@ -0,0 +1,19 @@ +#pragma once +#include "mousetool.h" +class CMouseToolCopy :public CMouseTool +{ +public: + CMouseToolCopy(void); + ~CMouseToolCopy(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnEscapeKey(); + virtual bool OnSetCmd(CString str); + virtual void OperateOver(); +private: + Dbxy m_BasePoint;//׼ + double m_MoveDisX; + double m_MoveDisY; +}; + diff --git a/LaipuDrawing/MouseToolCut.cpp b/LaipuDrawing/MouseToolCut.cpp new file mode 100644 index 0000000..da217bb --- /dev/null +++ b/LaipuDrawing/MouseToolCut.cpp @@ -0,0 +1,303 @@ +#include "StdAfx.h" +#include "MouseToolCut.h" +#include "GlobalDrawMgr.h" +#include "Layer.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "ObjPline.h" +#include "CommandCut.h" +#include "CommandMgr.h" + + +#if 1//ñȽϺ +//ȷ0 һȣ>0ֵ 򷵻С0ֵ +bool CompareDbPointX(Dbxy pt1,Dbxy pt2) +{ + return pt1.x>pt2.x; +} +bool CompareDbPointY(Dbxy pt1,Dbxy pt2) +{ + return pt1.y>pt2.y; +} +#endif + + +CMouseToolCut::CMouseToolCut(void) +{ +} +CMouseToolCut::~CMouseToolCut(void) +{ +} +void CMouseToolCut::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + DbRect rect = gDraw->GetCurPointRect(pt); + CutLineInRect(rect); +} +//rect еline +void CMouseToolCut::CutLineInRect(DbRect &rect) +{ + CLayer &layer = gLayer; + if(!layer.HasObjectInRect(rect)) + return; + //ҵһrect obj ----------------------------------------------- + Sptr pObj = layer.GetFirstObjInRect(rect); + //obj rect еĵһline ----------------------------------------------- + Dbxy LinePt1,LinePt2; + GetFirstLineInRect(pObj,rect,LinePt1,LinePt2); + if(LinePt1.Equal(LinePt2)) + return; + //line γɵľе߶εLineVec ----------------------------------------------- + vector LineVec; + DbRect LineRect = GetLineRect(LinePt1,LinePt2); + layer.GetLineInRect(LineRect,LineVec,false); + //еĽ㵽PointVec ----------------------------------------------- + vector PointVec; + CalAllIntersection(LinePt1,LinePt2,LineRect,LineVec,PointVec); + //һûֻʣһ߶, ޼ + if(PointVec.empty()) + return; + //ݽobj ----------------------------------------------- + CutObj(LinePt1,LinePt2,pObj,PointVec,rect); +} +//ñи߶γɵľ +DbRect CMouseToolCut::GetLineRect(const Dbxy &LinePt1,const Dbxy &LinePt2) +{ + double MixGap = 0.01; + //ˮƽֱ + Dbxy RectPt1 = LinePt1; + Dbxy RectPt2 = LinePt2; + if(IsTwoDbEqual(LinePt1.x,LinePt2.x)) + { + RectPt1.x -= MixGap; + RectPt2.x += MixGap; + } + if(IsTwoDbEqual(LinePt1.y,LinePt2.y)) + { + RectPt1.y += MixGap; + RectPt2.y -= MixGap; + } + DbRect LineRect(RectPt1,RectPt2); + return LineRect; +} +//obj rect еĵһline +void CMouseToolCut::GetFirstLineInRect(Sptr &pObj,DbRect &rect,Dbxy &LinePt1,Dbxy &LinePt2) +{ + vector LineVec; + pObj->GetLineInRect(rect,LineVec); + LinePt1 = LineVec[0].m_pt1.GetPt(); + LinePt2 = LineVec[0].m_pt2.GetPt(); +} + +//н,浽PointVec +void CMouseToolCut::CalAllIntersection(Dbxy LinePt1,Dbxy LinePt2,DbRect &LineRect,vector &LineVec,vector &PointVec) +{ + vector::iterator iter = LineVec.begin(); + vector::iterator iter_end = LineVec.end(); + for(;iter!=iter_end;iter++) + { + Dbxy pt3 = (*iter).m_pt1.GetPt(); + Dbxy pt4 = (*iter).m_pt2.GetPt(); + if(pt3.Equal(pt4))//Ҫһ߶ + { + continue; + } + if(IsTwoLineIntersect(LinePt1,LinePt2,pt3,pt4)) + { + //ཻ + Dbxy pt = CalIntersection(LinePt1,LinePt2,pt3,pt4); + //rect 벶׽ + if(IsPointInRect(pt,LineRect)) + { + PointVec.push_back(pt); + } + } + } +} +//ݽ޼obj +//rect rect Χ +//pObj ǵǰеĶ +//PointVec ߶ν +void CMouseToolCut::CutObj(Dbxy LinePt1,Dbxy LinePt2,Sptr pObj,vector &PointVec,DbRect &rect) +{ + //ȡļе------------------------------------- + Dbxy CutPt1,CutPt2; + if(GetCutPoint(LinePt1,LinePt2,PointVec,rect,CutPt1,CutPt2)==false) + { + return; + } + //obj Ϊ------------------------------------------ + CObjPline *pObj1 = NULL; + CObjPline *pObj2 = NULL; + CutObjExt(LinePt1,LinePt2,pObj,CutPt1,CutPt2,pObj1,pObj2); + //ָ----------------------------------- + m_TmpObjContainer.Clear(); + CreatCommandCut(pObj,pObj1,pObj2); + GetCurViewPtr()->RefreshView(); +} +//޼ָ +//pObj ʱ޼ǰobj +//pObj1pObj2 ޼obj +void CMouseToolCut::CreatCommandCut(Sptr pObj,CObjPline *&pObj1,CObjPline *&pObj2) +{ + CCommandCut *p = new CCommandCut; + p->AddOpObj(pObj); + + AddToCmd(pObj1,p); + AddToCmd(pObj2,p); + + m_TmpObjContainer.AllObjAddToLayer(); + gCommandMgr.AddUndoCommand(p); + gLayer.DelObj(pObj); +} +void CMouseToolCut::AddToCmd(CObjPline *&pObj,CCommandCut *&pCommandCut) +{ + if(pObj) + { + //浽ָ + Sptr sPtr(pObj); + m_TmpObjContainer.AddObject(sPtr); + pCommandCut->AddOpObj(sPtr); + } + else + { + delete pObj; + } +} +//obj Ϊ +bool CMouseToolCut::CutObjExt(Dbxy LinePt1,Dbxy LinePt2,Sptr pObj,Dbxy CutPt1,Dbxy CutPt2,CObjPline *&pObj1,CObjPline *&pObj2) +{ + vector&Container = pObj->GetPtContainer(); + int size = Container.size(); + Dbxy NearPt;//һĵ + Dbxy FarPt;//ڶֵһ + //ָһ------------------------------------------------------------ + int i=0; + for(;iAddDataPoint(DataPoint); + } + else + { + pObj1->AddDataPoint(Container[i]); + } + //ǰ߶Ϊ߶Σһ + if(IsSelLine(LinePt1,LinePt2,pt,Nextpt)) + { + GetNearFarPoint(CutPt1,CutPt2,pt,NearPt,FarPt); + + Dbxy pt = Container[i].GetPt(); + if(!(pt == NearPt))//βظĵ2015-12-10 + { + CDataPoint DataPoint(NearPt); + DataPoint.SetIsNode(true); + pObj1->AddDataPoint(DataPoint); + } + i++;//break Ժi + break; + } + } + //ָڶ-------------------------------------------------------------- + if(!(i==size-1 && FarPt.Equal(Container[i].GetPt()))) + { + bool bflg = true; + for(;iAddDataPoint(DataPoint); + } + //ǰڶ + if(i==size-1)//һǽڵ + { + CDataPoint DataPoint(Container[i].GetPt()); + DataPoint.SetIsNode(true); + pObj2->AddDataPoint(DataPoint); + } + else + { + //FarPt ڵһҪظ + if(!(bflg && FarPt.Equal(Container[i].GetPt()))) + { + pObj2->AddDataPoint(Container[i]); + } + } + bflg = false; + } + } + return true; +} +//ȡļе +bool CMouseToolCut::GetCutPoint(Dbxy LinePt1,Dbxy LinePt2,vector &PointVec,DbRect &rect,Dbxy &CutPt1,Dbxy &CutPt2) +{ + //ȵõrect ߶εĽ-------------------------------------------------- + Dbxy MousePt = IntersectionOfRectAndLine(LinePt1,LinePt2,rect); + //MousePt ---------------------------------------------- + PointVec.push_back(MousePt); + PointVec.push_back(LinePt1); + PointVec.push_back(LinePt2); + if(IsTwoDbEqual(LinePt1.x,LinePt2.x))//ֱ + { + //y + sort(PointVec.begin(),PointVec.end(),CompareDbPointY); + } + else//ֱ + { + //x + sort(PointVec.begin(),PointVec.end(),CompareDbPointX); + } + vector::iterator MousePtIter = find(PointVec.begin(),PointVec.end(),MousePt); + //ֻMousePtIter м + if(MousePtIter==PointVec.end() || MousePtIter==PointVec.end()-1 || MousePtIter==PointVec.begin()) + return false; + + CutPt1 = (*(MousePtIter-1)); + CutPt2 = (*(MousePtIter+1)); + + if(CutPt1.Equal(CutPt2)) + return false; + return true; +} +//ǷΪǰ߶ +bool CMouseToolCut::IsSelLine(Dbxy LinePt1,Dbxy LinePt2,Dbxy pt,Dbxy Nextpt) +{ + return ((LinePt1.Equal(pt) && LinePt2.Equal(Nextpt))||(LinePt1.Equal(Nextpt) && LinePt2.Equal(pt))); +} +//pt Ͻĵ +void CMouseToolCut::GetNearFarPoint(Dbxy pt1,Dbxy pt2,Dbxy pt,Dbxy &NearPt,Dbxy &FarPt) +{ + if(CalDistance(pt1,pt) &LineVec,vector &PointVec); + void CutObj(Dbxy LinePt1,Dbxy LinePt2,Sptr pObj,vector &PointVec,DbRect &rect); + bool IsSelLine(Dbxy LinePt1,Dbxy LinePt2,Dbxy pt,Dbxy Nextpt); + void GetNearFarPoint(Dbxy pt1,Dbxy pt2,Dbxy pt,Dbxy &NearPt,Dbxy &FarPt); + DbRect GetLineRect(const Dbxy &LinePt1,const Dbxy &LinePt2); + bool GetCutPoint(Dbxy LinePt1,Dbxy LinePt2,vector &PointVec,DbRect &rect,Dbxy &CutPt1,Dbxy &CutPt2); + bool CutObjExt(Dbxy LinePt1,Dbxy LinePt2,Sptr pObj,Dbxy CutPt1,Dbxy CutPt2,CObjPline *&pObj1,CObjPline *&pObj2); + void CreatCommandCut(Sptr pObj,CObjPline *&pObj1,CObjPline *&pObj2); + void AddToCmd(CObjPline *&pObj,CCommandCut *&pCommandCut); + void GetFirstLineInRect(Sptr &pObj,DbRect &rect,Dbxy &LinePt1,Dbxy &LinePt2); +}; + diff --git a/LaipuDrawing/MouseToolDelNode.cpp b/LaipuDrawing/MouseToolDelNode.cpp new file mode 100644 index 0000000..d24eac1 --- /dev/null +++ b/LaipuDrawing/MouseToolDelNode.cpp @@ -0,0 +1,66 @@ +#include "StdAfx.h" +#include "MouseToolDelNode.h" +#include "GlobalDrawMgr.h" +#include "Layer.h" +#include "GlobalFunction.h" +#include "CommandDelNode.h" +#include "CommandMgr.h" +#include "LogMgr.h" + +CMouseToolDelNode::CMouseToolDelNode(void) +{ +} +CMouseToolDelNode::~CMouseToolDelNode(void) +{ +} +void CMouseToolDelNode::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + DbRect rect = gDraw->GetCurPointRect(pt); + + CLayer &layer = gLayer; + if(!layer.HasObjectInRect(rect)) + { + gLogMgr->WriteDebugLog("ڷΧ֮",_LOG_ERROR); + return; + } + //ҵһrect obj ----------------------------------------------- + Sptr pObj = layer.GetFirstObjInRect(rect); + if(pObj->GetPtCnt()<=2)//ֻɾ3 ϵĶ + { + gLogMgr->WriteDebugLog("ֻɾ3ϵĶ",_LOG_ERROR); + return; + } + //obj rect еĵһnode ----------------------------------------------- + vector LineVec; + pObj->GetLineInRect(rect,LineVec,false); + + if(LineVec.empty()) + return; + Dbxy NodePt = LineVec[0].m_pt1.GetPt(); + if(!IsPointInRect(NodePt,rect)) + { + NodePt = LineVec[0].m_pt2.GetPt(); + } + if(!IsPointInRect(NodePt,rect)) + { + gLogMgr->WriteDebugLog("ڵ㲻ڷΧ",_LOG_ERROR); + return; + } + //NodePt obj + int idx = pObj->GetNodePtIdx(NodePt); + if(idx!=-1 && idx!=0) + { + pObj->DelNodePtByIdx(idx); + + //ָ----------------------------------- + CCommandDelNode *p = new CCommandDelNode; + p->SetPar(idx,NodePt); + p->AddOpObj(pObj); + gCommandMgr.AddUndoCommand(p); + //ˢ + GetCurViewPtr()->RefreshView(); + } +} + + diff --git a/LaipuDrawing/MouseToolDelNode.h b/LaipuDrawing/MouseToolDelNode.h new file mode 100644 index 0000000..9dde869 --- /dev/null +++ b/LaipuDrawing/MouseToolDelNode.h @@ -0,0 +1,11 @@ +#pragma once +#include "mousetool.h" +class CMouseToolDelNode :public CMouseTool +{ +public: + CMouseToolDelNode(void); + ~CMouseToolDelNode(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + +}; + diff --git a/LaipuDrawing/MouseToolLaserCoord.cpp b/LaipuDrawing/MouseToolLaserCoord.cpp new file mode 100644 index 0000000..b85d3b7 --- /dev/null +++ b/LaipuDrawing/MouseToolLaserCoord.cpp @@ -0,0 +1,18 @@ +#include "StdAfx.h" +#include "MouseToolLaserCoord.h" +#include "LogMgr.h" +#include "GlobalFunction.h" +#include "Laser.h" +#include "GlobalDrawMgr.h" + +CMouseToolLaserCoord::CMouseToolLaserCoord(void) +{ +} +CMouseToolLaserCoord::~CMouseToolLaserCoord(void) +{ +} +void CMouseToolLaserCoord::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + +} + diff --git a/LaipuDrawing/MouseToolLaserCoord.h b/LaipuDrawing/MouseToolLaserCoord.h new file mode 100644 index 0000000..c41ff76 --- /dev/null +++ b/LaipuDrawing/MouseToolLaserCoord.h @@ -0,0 +1,13 @@ +#pragma once +#include "mousetool.h" + +class CMouseToolLaserCoord :public CMouseTool +{ +public: + CMouseToolLaserCoord(void); + ~CMouseToolLaserCoord(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); +private: + +}; + diff --git a/LaipuDrawing/MouseToolLine.cpp b/LaipuDrawing/MouseToolLine.cpp new file mode 100644 index 0000000..9fbfec7 --- /dev/null +++ b/LaipuDrawing/MouseToolLine.cpp @@ -0,0 +1,150 @@ +#include "StdAfx.h" +#include "MouseToolLine.h" +#include "LogMgr.h" +#include "ObjPLine.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +CMouseToolLine::CMouseToolLine(void) +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_LINE_FIRST_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + m_Length = 0;// + m_Angle = 0;//360 +} +CMouseToolLine::~CMouseToolLine(void) +{ +} +void CMouseToolLine::CreatOneLine(Dbxy pt) +{ + CObjPline *p = new CObjPline; + p->Creat(pt,pt); + AddObject(p); + //-------------------------------------------start + if(m_Status==_STATUS_1) + { + CString val1; + val1.Format("%lf",pt.x); + CString val2; + val2.Format("%lf",pt.y); + gLogMgr->WriteCmd(CMD_LINE_FIRST_PT,val1,val2); + ToNextStatus(); + } + else + { + CString val1; + val1.Format("%lf",m_Length); + CString val2; + val2.Format("%lf",m_Angle); + gLogMgr->WriteCmd(CMD_LINE_NEXT_PT,val1,val2); + } + //-------------------------------------------end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_LINE_NEXT_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + SaveDownPoint(pt); +} +void CMouseToolLine::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + //ÿһ´һֱ + Dbxy pt = gDraw->CPoint2Dbxy(point); + CreatOneLine(pt); +} +void CMouseToolLine::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + +} +void CMouseToolLine::OnRButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + // + m_TmpObjContainer.XorDrawLastObj(&dc); + //ɾһobj + m_TmpObjContainer.DeleteLastObj(); + //ָ + AddCreatCommand(); + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + // + m_Status = _STATUS_END; + OperateOver(); +} +void CMouseToolLine::OnMouseMove(UINT nFlag, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status!=_STATUS_1) + { + CObjBase *pCurOptObject = m_TmpObjContainer.GetCurOpObj(); + if(pCurOptObject) + { + CObjPline *p = dynamic_cast(pCurOptObject); + m_TmpObjContainer.XorDrawLastObj(&dc); + p->Creat(m_DownPoint,pt); + m_TmpObjContainer.XorDrawLastObj(&dc); + + m_Length = CalDistance(m_DownPoint,pt);// + m_Angle = Cal360AngleByTwoPt(m_DownPoint,pt);//360 + //״̬-----------------------------start + CString str1 = "߶[] [Ƕ]"; + CString str2; + str2.Format("%lf",m_Length); + CString str3; + str3.Format("%lf",m_Angle); + GetFrame()->ResetStatusBarExtStr(); + GetFrame()->SetStatusBarExtStr(str1,str2,str3); + //״̬-----------------------------end + } + } +} +void CMouseToolLine::OnEscapeKey() +{ + //ɾһobj + m_TmpObjContainer.DeleteLastObj(); + //ָ + AddCreatCommand(); + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + m_Status = _STATUS_END; + OperateOver(); +} +bool CMouseToolLine::OnSetCmd(CString str) +{ + if(m_Status==_STATUS_2) + { + double Val1=0;// + double Val2=0;//Ƕ + int result = GetTwoNum(str,Val1,Val2); + if(result>0) + { + if(result==1)//ֻ볤 + { + Val2 = m_Angle; + } + if(Val1>0)//Ҫ0 + { + m_Length = Val1; + m_Angle = Val2; + //ָ + Dbxy SetPoint = GetPoint2(m_DownPoint,Val1,_360ToAngle(Val2)); + //Ȱѵǰ߶ӵ + CObjBase *pCurOptObject = m_TmpObjContainer.GetCurOpObj(); + if(pCurOptObject) + { + CObjPline *p = dynamic_cast(pCurOptObject); + p->Creat(m_DownPoint,SetPoint); + } + //Ϊ㴴߶ + CreatOneLine(SetPoint); + //ǿˢ + GetCurViewPtr()->RefreshView(); + return true; + } + } + } + return false; +} \ No newline at end of file diff --git a/LaipuDrawing/MouseToolLine.h b/LaipuDrawing/MouseToolLine.h new file mode 100644 index 0000000..fed37a8 --- /dev/null +++ b/LaipuDrawing/MouseToolLine.h @@ -0,0 +1,20 @@ +#pragma once +#include "mousetool.h" +class CMouseToolLine :public CMouseTool +{ +public: + CMouseToolLine(void); + ~CMouseToolLine(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnRButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnEscapeKey(); + virtual bool OnSetCmd(CString str); +private : + void CreatOneLine(Dbxy pt); +private: + double m_Length;// + double m_Angle;//360 +}; + diff --git a/LaipuDrawing/MouseToolMeasure.cpp b/LaipuDrawing/MouseToolMeasure.cpp new file mode 100644 index 0000000..1fdb944 --- /dev/null +++ b/LaipuDrawing/MouseToolMeasure.cpp @@ -0,0 +1,123 @@ +#include "StdAfx.h" +#include "MouseToolMeasure.h" +#include "GlobalFunction.h" +#include "CommandMove.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" +#include "DrawSimpleShape.h" + +CMouseToolMeasure::CMouseToolMeasure(void) +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_MEASURE_FIRST_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + +} +CMouseToolMeasure::~CMouseToolMeasure(void) +{ +} +void CMouseToolMeasure::OperateOver() +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + CMouseTool::OperateOver(); + m_Status = _STATUS_END; +} +void CMouseToolMeasure::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_1) + { + SaveDownPoint(point); + //------------------------------------־start + CString val1; + val1.Format("%lf",pt.x); + CString val2; + val2.Format("%lf",pt.y); + gLogMgr->WriteDebugLog(CMD_TOOL_MEASURE_FIRST_PT,STR_NULL,STR_NULL,pt.x,pt.y); + //------------------------------------־end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_MEASURE_SECOND_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + ToNextStatus(); + } + else + { + //------------------------------------־start + { + CString val1; + val1.Format("%lf",pt.x); + CString val2; + val2.Format("%lf",pt.y); + gLogMgr->WriteDebugLog(CMD_TOOL_MEASURE_SECOND_PT,STR_NULL,STR_NULL,pt.x,pt.y); + } + { + // + m_Dis = CalDistance(m_DownPoint,pt); + gLogMgr->WriteDebugLog(CMD_TOOL_MEASURE_RESULT,STR_NULL,m_Dis); + } + { + gLogMgr->WriteDebugLog(CMD_TOOL_MEASURE_RESULT2,STR_NULL,STR_NULL,pt.x-m_DownPoint.x,pt.y-m_DownPoint.y); + } + //Ƕ + { + double Ang = Cal360AngleByTwoPt(pt,m_DownPoint); + gLogMgr->WriteDebugLog(CMD_TOOL_MEASURE_RESULT3,STR_NULL,Ang); + } + //(0,0)ļн + { + double Ang = Cal360AngleByTwoPt(pt,Dbxy(0,0)); + gLogMgr->WriteDebugLog(CMD_TOOL_MEASURE_RESULT4,STR_NULL,Ang); + } + { + double Ang = Cal360AngleByTwoPt(m_DownPoint,Dbxy(0,0)); + gLogMgr->WriteDebugLog(CMD_TOOL_MEASURE_RESULT4,STR_NULL,Ang); + } + //------------------------------------־end + ClearFirstPoint(); + m_Status = _STATUS_1; + } +} +void CMouseToolMeasure::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + +} +void CMouseToolMeasure::OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy OldPt = gDraw->CPoint2Dbxy(m_PreMovePt); + Dbxy CurPt = gDraw->CPoint2Dbxy(point); + CLayer &layer = gLayer; + if(m_Status!=_STATUS_1) + { + if(HasPreMovePt())//֮ǰ + { + XorDrawLine(&dc,gDraw->GetMeasurePen(),m_DownPoint,OldPt); + } + XorDrawLine(&dc,gDraw->GetMeasurePen(),m_DownPoint,CurPt); + + // + m_Dis = CalDistance(m_DownPoint,CurPt); + + //״̬-----------------------------start + CString str1 = "[]"; + CString str2; + str2.Format("%lf",m_Dis); + GetFrame()->ResetStatusBarExtStr(); + GetFrame()->SetStatusBarExtStr(str1,str2,STR_NULL); + //״̬-----------------------------end + SavePreMovePt(point); + } +} +void CMouseToolMeasure::OnEscapeKey() +{ + if(m_Status!=_STATUS_1)//ڶε + { + OperateOver(); + } +} + diff --git a/LaipuDrawing/MouseToolMeasure.h b/LaipuDrawing/MouseToolMeasure.h new file mode 100644 index 0000000..7027803 --- /dev/null +++ b/LaipuDrawing/MouseToolMeasure.h @@ -0,0 +1,16 @@ +#pragma once +#include "mousetool.h" +class CMouseToolMeasure :public CMouseTool +{ +public: + CMouseToolMeasure(void); + ~CMouseToolMeasure(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnEscapeKey(); + virtual void OperateOver(); +private: + double m_Dis;// +}; + diff --git a/LaipuDrawing/MouseToolMove.cpp b/LaipuDrawing/MouseToolMove.cpp new file mode 100644 index 0000000..49b7c0d --- /dev/null +++ b/LaipuDrawing/MouseToolMove.cpp @@ -0,0 +1,61 @@ +#include "StdAfx.h" +#include "MouseToolMove.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" + + +CMouseToolMove::CMouseToolMove(void) +{ + m_MoveDisX = 0; + m_MoveDisY = 0; +} +CMouseToolMove::~CMouseToolMove(void) +{ +} +void CMouseToolMove::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + if(m_Status==_STATUS_1) + { + SaveDownPoint(point); + //ģĶ + CreatOpSimulateObj(); + ToNextStatus(); + } +} +void CMouseToolMove::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + gLayer.OnMove(m_MoveDisX,m_MoveDisY); + OperateOver(); + m_Status = _STATUS_END; +} +void CMouseToolMove::OperateObj(Dbxy StartPt,Dbxy EndPt) +{ + //obj + SObjOperatePar par; + par.OpType = _OP_MOVE; + par.MoveX = EndPt.x - StartPt.x; + par.MoveY = EndPt.y - StartPt.y; + //ģ + OpSimulateObj(par); + + //¼ƶ--- + m_MoveDisX = par.MoveX; + m_MoveDisY = par.MoveY; +} +void CMouseToolMove::OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy CurPt = gDraw->CPoint2Dbxy(point); + CLayer &layer = gLayer; + if(nFlags&MK_LBUTTON && (m_Status!=_STATUS_1)) + { + if(m_bFirstMove==false) + { + //ػģ + XorRedrawOpSimulateObj(&dc); + } + m_bFirstMove = false; + OperateObj(m_DownPoint,CurPt);// + XorRedrawOpSimulateObj(&dc); + } +} + diff --git a/LaipuDrawing/MouseToolMove.h b/LaipuDrawing/MouseToolMove.h new file mode 100644 index 0000000..3535424 --- /dev/null +++ b/LaipuDrawing/MouseToolMove.h @@ -0,0 +1,17 @@ +#pragma once +#include "mousetool.h" +class CMouseToolMove :public CMouseTool +{ +public: + CMouseToolMove(void); + ~CMouseToolMove(void); + virtual void OperateObj(Dbxy StartPt,Dbxy EndPt); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual bool NeedToPointTool(){return true;}; +private: + double m_MoveDisX; + double m_MoveDisY; +}; + diff --git a/LaipuDrawing/MouseToolMove2.cpp b/LaipuDrawing/MouseToolMove2.cpp new file mode 100644 index 0000000..90f5f05 --- /dev/null +++ b/LaipuDrawing/MouseToolMove2.cpp @@ -0,0 +1,141 @@ +#include "StdAfx.h" +#include "MouseToolMove2.h" +#include "GlobalFunction.h" +#include "CommandMove.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" +#include "DrawSimpleShape.h" + +CMouseToolMove2::CMouseToolMove2(void) +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_MOVE_FIRST_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end +} +CMouseToolMove2::~CMouseToolMove2(void) +{ +} +void CMouseToolMove2::OperateOver() +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + + if(m_Status==_STATUS_2) + { + SObjOperatePar par; + par.OpType = _OP_MOVE; + par.MoveX = m_MoveDisX; + par.MoveY = m_MoveDisY; + //gLayer.OperateObj(par,true,true); + gLayer.OnMove(m_MoveDisX,m_MoveDisY); + } + CMouseTool::OperateOver(); + m_Status = _STATUS_END; +} +void CMouseToolMove2::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_1)//ָ + { + SaveDownPoint(point); + //------------------------------------־start + CString val1; + val1.Format("%lf",pt.x); + CString val2; + val2.Format("%lf",pt.y); + gLogMgr->WriteCmd(CMD_TOOL_MOVE_FIRST_PT,val1,val2); + //------------------------------------־end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_MOVE_DIS); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + ToNextStatus(); + //ѡobj Ƶm_TmpObjContainer + m_TmpObjContainer.Clear(); + gLayer.CloneObj(m_TmpObjContainer,true); + + //ģĶ + CreatOpSimulateObj(); + } + else + { + //Ҫ¼ƶ룬Ϊв׽λ + m_MoveDisX = pt.x - m_DownPoint.x; + m_MoveDisY = pt.y - m_DownPoint.y; + + OperateOver(); + } +} +void CMouseToolMove2::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + +} +void CMouseToolMove2::OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy OldPt = gDraw->CPoint2Dbxy(m_PreMovePt); + Dbxy CurPt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_2) + { + if(m_bFirstMove==false) + { + //ػģ + XorRedrawOpSimulateObj(&dc); + } + m_bFirstMove = false; + + if(HasPreMovePt())//֮ǰ + { + XorDrawLine(&dc,gDraw->GetObjectPen(),m_DownPoint,OldPt); + } + XorDrawLine(&dc,gDraw->GetObjectPen(),m_DownPoint,CurPt);//һʱ + + //ƶ + m_MoveDisX = CurPt.x - m_DownPoint.x; + m_MoveDisY = CurPt.y - m_DownPoint.y; + //obj + SObjOperatePar par; + par.OpType = _OP_MOVE; + par.MoveX = m_MoveDisX; + par.MoveY = m_MoveDisY; + //ģ + OpSimulateObj(par); + + XorRedrawOpSimulateObj(&dc); + + //״̬-----------------------------start + CString str1 = "ƶ[x ] [y ]"; + CString str2; + str2.Format("%lf",m_MoveDisX); + CString str3; + str3.Format("%lf",m_MoveDisY); + GetFrame()->ResetStatusBarExtStr(); + GetFrame()->SetStatusBarExtStr(str1,str2,str3); + //״̬-----------------------------end + SavePreMovePt(point); + } +} +bool CMouseToolMove2::OnSetCmd(CString str) +{ + if(m_Status==_STATUS_2) + { + double Val1=0;//x + double Val2=0;//y + int result = GetTwoNum(str,Val1,Val2); + if(result>0) + { + if(result == 2)//Ҫͬʱ + { + m_MoveDisX = Val1; + m_MoveDisY = Val2; + OperateOver(); + return true; + } + } + } + return false; +} + diff --git a/LaipuDrawing/MouseToolMove2.h b/LaipuDrawing/MouseToolMove2.h new file mode 100644 index 0000000..5e0efb1 --- /dev/null +++ b/LaipuDrawing/MouseToolMove2.h @@ -0,0 +1,20 @@ +#pragma once +#include "mousetool.h" + +//ָƶ +class CMouseToolMove2 :public CMouseTool +{ +public: + CMouseToolMove2(void); + ~CMouseToolMove2(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OperateOver(); + virtual bool OnSetCmd(CString str); + virtual bool NeedToPointTool(){return true;}; +private: + double m_MoveDisX; + double m_MoveDisY; +}; + diff --git a/LaipuDrawing/MouseToolMoveNode.cpp b/LaipuDrawing/MouseToolMoveNode.cpp new file mode 100644 index 0000000..bf62369 --- /dev/null +++ b/LaipuDrawing/MouseToolMoveNode.cpp @@ -0,0 +1,84 @@ +#include "StdAfx.h" +#include "MouseToolMoveNode.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" +#include "CommandMoveNode.h" +#include "CommandMgr.h" + +CMouseToolMoveNode::CMouseToolMoveNode(void) +{ + m_NodeIdx = -1; +} +CMouseToolMoveNode::~CMouseToolMoveNode(void) +{ +} +void CMouseToolMoveNode::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + if(m_Status==_STATUS_1) + { + Dbxy pt = gDraw->CPoint2Dbxy(point); + DbRect rect = gDraw->GetCurPointRect(pt); + + CLayer &layer = gLayer; + if(!layer.HasSelNodeInRect(rect)) + return; + //ҵһrect obj ----------------------------------------------- + Sptr pObj = layer.GetFirstNodeObjInRect(rect); + m_TmpObjContainer.AddObject(pObj); + //obj rect еĵһnode ----------------------------------------------- + vector LineVec; + pObj->GetLineInRect(rect,LineVec,false); + Dbxy NodePt = LineVec[0].m_pt1.GetPt(); + if(!IsPointInRect(NodePt,rect)) + { + NodePt = LineVec[0].m_pt2.GetPt(); + } + if(!IsPointInRect(NodePt,rect)) + return; + //NodePt obj + m_NodeIdx = pObj->GetNodePtIdx(NodePt); + if(m_NodeIdx!=-1) + { + //¼ɵ + m_OldPt = NodePt; + ToNextStatus(); + } + + } +} +void CMouseToolMoveNode::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + if(!m_TmpObjContainer.Empty()) + { + //ָ-------start + CCommandMoveNode *p = new CCommandMoveNode; + p->SetPar(m_NodeIdx,m_OldPt,m_NewPt); + gCommandMgr.AddUndoCommand(p,m_TmpObjContainer.GetObjVec()); + p->Excute(); + //ָ-------end + } + //ʱ + m_TmpObjContainer.Clear(); + + OperateOver(); + m_Status = _STATUS_END; +} +void CMouseToolMoveNode::OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy CurPt = gDraw->CPoint2Dbxy(point); + CLayer &layer = gLayer; + if(nFlags&MK_LBUTTON && (m_Status!=_STATUS_1)) + { + if(m_bFirstMove==false) + { + layer.XorRedrawObj(&dc);//֮ǰ + } + m_bFirstMove = false; + m_TmpObjContainer.SetNodePtByIdx(m_NodeIdx,CurPt); + //¼µ + m_NewPt = CurPt; + + layer.XorRedrawObj(&dc);//ػ + } +} + diff --git a/LaipuDrawing/MouseToolMoveNode.h b/LaipuDrawing/MouseToolMoveNode.h new file mode 100644 index 0000000..650dd06 --- /dev/null +++ b/LaipuDrawing/MouseToolMoveNode.h @@ -0,0 +1,18 @@ +#pragma once +#include "mousetool.h" +//ƶڵ㹤 +class CMouseToolMoveNode :public CMouseTool +{ +public: + CMouseToolMoveNode(void); + ~CMouseToolMoveNode(void); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual bool NeedToPointTool(){return true;}; +private: + int m_NodeIdx;//ǰnode ڵֵ + Dbxy m_OldPt;//ɵ + Dbxy m_NewPt;//µ +}; + diff --git a/LaipuDrawing/MouseToolOnePoint.cpp b/LaipuDrawing/MouseToolOnePoint.cpp new file mode 100644 index 0000000..6660e06 --- /dev/null +++ b/LaipuDrawing/MouseToolOnePoint.cpp @@ -0,0 +1,31 @@ +#include "StdAfx.h" +#include "MouseToolOnePoint.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +#include "CommandCreat.h" +#include "ObjPoint.h" +#include "CommandMgr.h" + +CMouseToolOnePoint::CMouseToolOnePoint(void) +{ +} +CMouseToolOnePoint::~CMouseToolOnePoint(void) +{ +} +void CMouseToolOnePoint::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_1) + { + CObjPoint *p = new CObjPoint; + p->SetPt(pt);//û׼ + + CObjContainer Container; + Container.AddObject(p); + //ָ-------start + CCommandCreat *pCmd = new CCommandCreat; + gCommandMgr.AddUndoCommand(pCmd,Container.GetObjVec()); + pCmd->Excute(); + } + GetCurViewPtr()->RefreshView(); +} \ No newline at end of file diff --git a/LaipuDrawing/MouseToolOnePoint.h b/LaipuDrawing/MouseToolOnePoint.h new file mode 100644 index 0000000..5d53587 --- /dev/null +++ b/LaipuDrawing/MouseToolOnePoint.h @@ -0,0 +1,11 @@ +#pragma once +#include "mousetool.h" +//㹤 +class CMouseToolOnePoint :public CMouseTool +{ +public: + CMouseToolOnePoint(void); + ~CMouseToolOnePoint(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); +}; + diff --git a/LaipuDrawing/MouseToolPline.cpp b/LaipuDrawing/MouseToolPline.cpp new file mode 100644 index 0000000..8144930 --- /dev/null +++ b/LaipuDrawing/MouseToolPline.cpp @@ -0,0 +1,182 @@ +#include "StdAfx.h" +#include "MouseToolPline.h" +#include "LogMgr.h" +#include "ObjPLine.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +CMouseToolPline::CMouseToolPline(void) +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_LINE_FIRST_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + m_Length = 0;// + m_Angle = 0;//360 +} +CMouseToolPline::~CMouseToolPline(void) +{ +} +void CMouseToolPline::CreatOneLine(Dbxy pt) +{ + CObjPline *p = new CObjPline; + p->Creat(pt,pt); + AddObject(p); + //-------------------------------------------start + if(m_Status==_STATUS_1) + { + CString val1; + val1.Format("%lf",pt.x); + CString val2; + val2.Format("%lf",pt.y); + gLogMgr->WriteCmd(CMD_LINE_FIRST_PT,val1,val2); + ToNextStatus(); + } + else + { + CString val1; + val1.Format("%lf",m_Length); + CString val2; + val2.Format("%lf",m_Angle); + gLogMgr->WriteCmd(CMD_LINE_NEXT_PT,val1,val2); + } + //-------------------------------------------end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_LINE_NEXT_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + SaveDownPoint(pt); +} +void CMouseToolPline::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + //ÿһ´һֱ + Dbxy pt = gDraw->CPoint2Dbxy(point); + CreatOneLine(pt); +} +void CMouseToolPline::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + +} +void CMouseToolPline::OnRButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + // + m_TmpObjContainer.XorDrawLastObj(&dc); + //ɾһobj + m_TmpObjContainer.DeleteLastObj(); + //еline ϳpline + AlllineCombToPline(); + //ָ + AddCreatCommand(); + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + // + m_Status = _STATUS_END; + OperateOver(); +} +void CMouseToolPline::OnMouseMove(UINT nFlag, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status!=_STATUS_1) + { + CObjBase *pCurOptObject = m_TmpObjContainer.GetCurOpObj(); + if(pCurOptObject) + { + CObjPline *p = dynamic_cast(pCurOptObject); + m_TmpObjContainer.XorDrawLastObj(&dc); + p->Creat(m_DownPoint,pt); + m_TmpObjContainer.XorDrawLastObj(&dc); + + m_Length = CalDistance(m_DownPoint,pt);// + m_Angle = Cal360AngleByTwoPt(m_DownPoint,pt);//360 + //״̬-----------------------------start + CString str1 = "߶[] [Ƕ]"; + CString str2; + str2.Format("%lf",m_Length); + CString str3; + str3.Format("%lf",m_Angle); + GetFrame()->ResetStatusBarExtStr(); + GetFrame()->SetStatusBarExtStr(str1,str2,str3); + //״̬-----------------------------end + } + } +} +void CMouseToolPline::OnEscapeKey() +{ + //ɾһobj + m_TmpObjContainer.DeleteLastObj(); + + //еline ϳpline + AlllineCombToPline(); + //ָ + AddCreatCommand(); + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + m_Status = _STATUS_END; + OperateOver(); +} +bool CMouseToolPline::OnSetCmd(CString str) +{ + if(m_Status==_STATUS_2) + { + double Val1=0;// + double Val2=0;//Ƕ + int result = GetTwoNum(str,Val1,Val2); + if(result>0) + { + if(result==1)//ֻ볤 + { + Val2 = m_Angle; + } + if(Val1>0)//Ҫ0 + { + m_Length = Val1; + m_Angle = Val2; + //ָ + Dbxy SetPoint = GetPoint2(m_DownPoint,Val1,_360ToAngle(Val2)); + //Ȱѵǰ߶ӵ + CObjBase *pCurOptObject = m_TmpObjContainer.GetCurOpObj(); + if(pCurOptObject) + { + CObjPline *p = dynamic_cast(pCurOptObject); + p->Creat(m_DownPoint,SetPoint); + } + //Ϊ㴴߶ + CreatOneLine(SetPoint); + //ǿˢ + GetCurViewPtr()->RefreshView(); + return true; + } + } + } + return false; +} +//еline ϳpline +void CMouseToolPline::AlllineCombToPline() +{ + if(m_TmpObjContainer.Empty()) + return; + CObjPline *p = NULL; + vector> &vec = m_TmpObjContainer.GetObjVec(); + int size = vec.size(); + for(int i=0;iCreat(vec[0]->GetFirstPt(),vec[0]->GetLastPt()); + } + else + { + CDataPoint DataPoint(vec[i]->GetLastPt()); + DataPoint.SetIsNode(true); + p->AddDataPoint(DataPoint); + } + } + //߶εмΪ׽ + p->CreatMidNode(); + m_TmpObjContainer.Clear(); + AddObject(p); +} diff --git a/LaipuDrawing/MouseToolPline.h b/LaipuDrawing/MouseToolPline.h new file mode 100644 index 0000000..4f3e14e --- /dev/null +++ b/LaipuDrawing/MouseToolPline.h @@ -0,0 +1,22 @@ +#pragma once +#include "mousetool.h" +//߶ι +class CMouseToolPline :public CMouseTool +{ +public: + CMouseToolPline(void); + ~CMouseToolPline(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnRButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnEscapeKey(); + virtual bool OnSetCmd(CString str); +private : + void CreatOneLine(Dbxy pt); + void AlllineCombToPline(); +private: + double m_Length;// + double m_Angle;//360 +}; + diff --git a/LaipuDrawing/MouseToolPointer.cpp b/LaipuDrawing/MouseToolPointer.cpp new file mode 100644 index 0000000..65841fc --- /dev/null +++ b/LaipuDrawing/MouseToolPointer.cpp @@ -0,0 +1,97 @@ +#include "StdAfx.h" +#include "MouseToolPointer.h" +#include "LogMgr.h" +#include "GlobalDrawMgr.h" +#include "DrawSimpleShape.h" +#include "GlobalFunction.h" +#include "MarkAreaMgr.h" + +#define PT_SEL_SCALE 0.1 //ѡrect ı +CMouseToolPointer::CMouseToolPointer(void) +{ +} +CMouseToolPointer::~CMouseToolPointer(void) +{ +} +void CMouseToolPointer::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + CLayer &layer = gLayer; + if(m_Status==_STATUS_1) + { + SaveDownPoint(point);//¼һ + ToNextStatus(); + } + else + { + DbRect rect; + Dbxy pt2 = gDraw->CPoint2Dbxy(point); + if(gDraw->IsbRectSel())//ֻпѡʱŻ + { + DrawRect(&dc,gDraw->GetMouseRectPen(),m_DownPoint,pt2); + } + //ѡ + rect.Creat(m_DownPoint,pt2); + if(rect.IsZero())//ѡ + { + if(gDraw->IsbPointSel()) + { + rect = gDraw->GetCurPointRect(pt2,PT_SEL_SCALE); + layer.SelObjectInRect(rect,false); + } + } + else + { + if(gDraw->IsbRectSel())//ѡ + { + //Ҫȫס + if(m_DownPoint.xSelAreaByPt(rect.GetCenterPt()); + } + } + GetCurViewPtr()->RefreshView(); + + m_Status = _STATUS_1; + } +} +void CMouseToolPointer::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + if(m_Status!=_STATUS_1)//ѡ + { + Dbxy pt2 = gDraw->CPoint2Dbxy(point); + DbRect rect; + rect = gDraw->GetCurPointRect(pt2,PT_SEL_SCALE); + if(gDraw->IsbPointSel()) + { + if(gLayer.SelObjectInRect(rect,false)) + { + GetCurViewPtr()->RefreshView(); + m_Status = _STATUS_1; + } + } + } +} +void CMouseToolPointer::OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt2 = gDraw->CPoint2Dbxy(m_PreMovePt); + Dbxy pt2New = gDraw->CPoint2Dbxy(point); + + if(m_Status!=_STATUS_1)//ѡͼ + { + if(gDraw->IsbRectSel())//ֻпѡʱŻ + { + if(HasPreMovePt())//֮ǰ + { + DrawRect(&dc,gDraw->GetMouseRectPen(),m_DownPoint,pt2); + } + DrawRect(&dc,gDraw->GetMouseRectPen(),m_DownPoint,pt2New); + } + SavePreMovePt(point); + } +} diff --git a/LaipuDrawing/MouseToolPointer.h b/LaipuDrawing/MouseToolPointer.h new file mode 100644 index 0000000..674bca1 --- /dev/null +++ b/LaipuDrawing/MouseToolPointer.h @@ -0,0 +1,15 @@ +#pragma once +#include "mousetool.h" +//ָ빤 +class CMouseToolPointer :public CMouseTool +{ +public: + CMouseToolPointer(void); + ~CMouseToolPointer(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); +private: + +}; + diff --git a/LaipuDrawing/MouseToolRect.cpp b/LaipuDrawing/MouseToolRect.cpp new file mode 100644 index 0000000..904cf86 --- /dev/null +++ b/LaipuDrawing/MouseToolRect.cpp @@ -0,0 +1,144 @@ +#include "StdAfx.h" +#include "MouseToolRect.h" +#include "ObjPline.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" + +CMouseToolRect::CMouseToolRect(void) +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_RECT_FIRST_PT); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + m_Width = 0; + m_Hight = 0; +} +CMouseToolRect::~CMouseToolRect(void) +{ +} +void CMouseToolRect::OperateOver() +{ + //------------------------------------־start + CString val1; + val1.Format("%lf",m_Width); + CString val2; + val2.Format("%lf",m_Hight); + gLogMgr->WriteCmd(CMD_RECT_SIZE,val1,val2); + //------------------------------------־end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + //ָ + AddCreatCommand(); + // + m_Status = _STATUS_END; + + CMouseTool::OperateOver(); +} + +void CMouseToolRect::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_1) + { + SaveDownPoint(point); + CObjPline *p = new CObjPline; + p->Creat(pt,m_Width,m_Hight); + AddObject(p); + //------------------------------------־start + CString val1; + val1.Format("%lf",pt.x); + CString val2; + val2.Format("%lf",pt.y); + gLogMgr->WriteCmd(CMD_RECT_FIRST_PT,val1,val2); + //------------------------------------־end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_RECT_SIZE); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + ToNextStatus(); + } + else + { + OperateOver(); + } +} +void CMouseToolRect::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + +} +void CMouseToolRect::OnMouseMove(UINT nFlag, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status!=_STATUS_1) + { + CObjBase *pCurOptObject = m_TmpObjContainer.GetCurOpObj(); + if(pCurOptObject) + { + CObjPline *p = dynamic_cast(pCurOptObject); + + m_Width = pt.x-m_DownPoint.x; + m_Hight = pt.y-m_DownPoint.y; + + m_TmpObjContainer.XorRedrawObj(&dc,false); + p->Creat(m_DownPoint,m_Width,m_Hight); + m_TmpObjContainer.XorRedrawObj(&dc,false); + + //״̬-----------------------------start + CString str1 = "[] [߶]"; + CString str2; + str2.Format("%lf",m_Width); + CString str3; + str3.Format("%lf",m_Hight); + GetFrame()->ResetStatusBarExtStr(); + GetFrame()->SetStatusBarExtStr(str1,str2,str3); + //״̬-----------------------------end + } + } +} +bool CMouseToolRect::OnSetCmd(CString str) +{ + if(m_Status==_STATUS_2) + { + double Val1=0;// + double Val2=0;//߶ + int result = GetTwoNum(str,Val1,Val2); + if(result>0) + { + if(result == 2 && Val1>0 && Val2>0)//ȸ߶Ҫ0 ,Ҫͬʱ + { + //λж + if(m_Width<0) + { + m_Width = Val1*(-1); + } + else + { + m_Width = Val1; + } + if(m_Hight<0) + { + m_Hight = Val2*(-1); + } + else + { + m_Hight = Val2; + } + + CObjBase *pCurOptObject = m_TmpObjContainer.GetCurOpObj(); + if(pCurOptObject) + { + CObjPline *p = dynamic_cast(pCurOptObject); + p->Creat(m_DownPoint,m_Width,m_Hight); + } + OperateOver(); + return true; + } + } + } + return false; +} + diff --git a/LaipuDrawing/MouseToolRect.h b/LaipuDrawing/MouseToolRect.h new file mode 100644 index 0000000..3cd11f9 --- /dev/null +++ b/LaipuDrawing/MouseToolRect.h @@ -0,0 +1,19 @@ +#pragma once +#include "mousetool.h" +class CMouseToolRect :public CMouseTool +{ +public: + CMouseToolRect(void); + ~CMouseToolRect(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual bool OnSetCmd(CString str); + virtual bool NeedToPointTool(){return true;}; +private: + void OperateOver(); +private: + double m_Width; + double m_Hight; +}; + diff --git a/LaipuDrawing/MouseToolRotate.cpp b/LaipuDrawing/MouseToolRotate.cpp new file mode 100644 index 0000000..a3c6278 --- /dev/null +++ b/LaipuDrawing/MouseToolRotate.cpp @@ -0,0 +1,141 @@ +#include "StdAfx.h" +#include "MouseToolRotate.h" +#include "GlobalFunction.h" +#include "CommandRotato.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" +#include "CommandMgr.h" + + +CMouseToolRotate::CMouseToolRotate(void) +{ + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_ROTATO_CENTER); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end +} +CMouseToolRotate::~CMouseToolRotate(void) +{ +} +void CMouseToolRotate::OperateOver() +{ + if(m_Status==_STATUS_2) + { + //------------------------------------־start + CString val1; + val1.Format("%lf",m_Angle); + gLogMgr->WriteCmd(CMD_TOOL_ROTATO_ANGLE,val1,STR_NULL); + //------------------------------------־end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + //ǩ-------------------------end + //ת + SObjOperatePar par; + par.OpType = _OP_ROTATO; + par.BasePt = m_CenterPt; + par.Angle = m_Angle; + + //undo õָ-----start + CCommandRotato *p = new CCommandRotato; + p->SetOperatePar(par); + gCommandMgr.AddUndoCommand(p); + p->Excute(); + //undo õָ-----end + CMouseTool::OperateOver(); + m_Status = _STATUS_END; + } +} +void CMouseToolRotate::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_1) + { + SaveDownPoint(point); + m_CenterPt = pt;//¼תĵ + m_DownPoint.x+=20; + //------------------------------------־start + CString val1; + val1.Format("%lf",pt.x); + CString val2; + val2.Format("%lf",pt.y); + gLogMgr->WriteCmd(CMD_TOOL_ROTATO_CENTER,val1,val2); + //------------------------------------־end + //ǩ-------------------------start + GetFrame()->ResetCaptionBar(); + GetFrame()->SetCaptionCmdStr(CMD_TOOL_ROTATO_ANGLE); + GetFrame()->RefreashCaptionBar(); + //ǩ-------------------------end + ToNextStatus(); + //ѡobj Ƶm_TmpObjContainer + m_TmpObjContainer.Clear(); + gLayer.CloneObj(m_TmpObjContainer,true); + + //ģĶ + CreatOpSimulateObj(); + } + else + { + //һΣⲶ׽Ӱ + double Angle=CalAngle(m_CenterPt,m_DownPoint,pt); + m_Angle = AngleTo360(Angle);//¼תǶ + OperateOver(); + } +} +void CMouseToolRotate::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + +} +void CMouseToolRotate::OperateObj(Dbxy StartPt,Dbxy EndPt) +{ + //㷴н + double Angle=CalAngle(m_CenterPt,StartPt,EndPt); + m_Angle = AngleTo360(Angle);//¼תǶ +} +void CMouseToolRotate::OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy CurPt = gDraw->CPoint2Dbxy(point); + if(m_Status==_STATUS_2) + { + if(m_bFirstMove==false) + { + //ػģ + XorRedrawOpSimulateObj(&dc); + } + m_bFirstMove = false; + //㷴н + double Angle=CalAngle(m_CenterPt,m_DownPoint,CurPt); + m_Angle = AngleTo360(Angle);//¼תǶ + + SObjOperatePar par; + par.OpType = _OP_ROTATO; + par.BasePt = m_CenterPt; + par.Angle = m_Angle; + + //ģ + OpSimulateObj(par); + + //ػģ + XorRedrawOpSimulateObj(&dc); + } +} +bool CMouseToolRotate::OnSetCmd(CString str) +{ + if(m_Status==_STATUS_2) + { + double Val1=0;//תǶ + double Val2=0; + int result = GetTwoNum(str,Val1,Val2); + if(result>0) + { + if(result == 1) + { + m_Angle = Val1; + OperateOver(); + return true; + } + } + } + return false; +} + diff --git a/LaipuDrawing/MouseToolRotate.h b/LaipuDrawing/MouseToolRotate.h new file mode 100644 index 0000000..51b74ed --- /dev/null +++ b/LaipuDrawing/MouseToolRotate.h @@ -0,0 +1,19 @@ +#pragma once +#include "mousetool.h" +class CMouseToolRotate :public CMouseTool +{ +public: + CMouseToolRotate(void); + ~CMouseToolRotate(void); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OperateObj(Dbxy StartPt,Dbxy EndPt); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OperateOver(); + virtual bool NeedToPointTool(){return true;}; + bool OnSetCmd(CString str); +private: + Dbxy m_CenterPt;//תĵ㲻ܱ + double m_Angle; +}; + diff --git a/LaipuDrawing/MouseToolStretch.cpp b/LaipuDrawing/MouseToolStretch.cpp new file mode 100644 index 0000000..15a6bd4 --- /dev/null +++ b/LaipuDrawing/MouseToolStretch.cpp @@ -0,0 +1,124 @@ +#include "StdAfx.h" +#include "MouseToolStretch.h" +#include "EnumDirection.h" +#include "EasyOperationMgr.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" +#include "CommandStretch.h" +#include "CommandMgr.h" + +CMouseToolStretch::CMouseToolStretch(void) +{ +} +CMouseToolStretch::~CMouseToolStretch(void) +{ +} +void CMouseToolStretch::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + if(m_Status==_STATUS_1) + { + SaveDownPoint(point); + //ģĶ + CreatOpSimulateObj(); + ToNextStatus(); + } +} +void CMouseToolStretch::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + //undo õָ-----start + CCommandStretch *pCmd = new CCommandStretch; + + //obj + DIRECTION dir = gEasyOperationMgr->GetOprDir(); + if(dir == _DIR_L || dir == _DIR_R) + { + pCmd->SetOperatePar(m_ParX); + } + else if(dir == _DIR_U || dir == _DIR_D) + { + pCmd->SetOperatePar(m_ParY); + } + else + { + pCmd->SetOperatePar(m_ParX); + pCmd->SetOperateParY(m_ParY); + } + gCommandMgr.AddUndoCommand(pCmd); + //undo õָ-----end + pCmd->Excute(); + + OperateOver(); + m_Status = _STATUS_END; +} +void CMouseToolStretch::OperateObj(Dbxy StartPt,Dbxy EndPt) +{ + m_OpSimulateObj.DelAllPt(); + m_OpSimulateObj.CopyPt(m_OpSimulateObjBak); + //obj + DIRECTION dir = gEasyOperationMgr->GetOprDir(); + //ֱ + if(dir == _DIR_LB || dir == _DIR_RB || dir == _DIR_LT || dir == _DIR_RT) + { + if(abs(EndPt.x - StartPt.x)StartPt.y) + { + EndPt.y = StartPt.y + abs(EndPt.x - StartPt.x); + } + else + { + EndPt.y = StartPt.y - abs(EndPt.x - StartPt.x); + } + } + else + { + if(EndPt.x>StartPt.x) + { + EndPt.x = StartPt.x + abs(EndPt.y - StartPt.y); + } + else + { + EndPt.x = StartPt.x - abs(EndPt.y - StartPt.y); + } + } + } + + if(dir != _DIR_U && dir != _DIR_D) + { + m_ParX.OpType = _OP_STRETCH; + m_ParX.BasePt = gEasyOperationMgr->GetBasePt(); + m_ParX.OldSize = gEasyOperationMgr->GetSize(_X); + m_ParX.Diff = gEasyOperationMgr->GetDiff(StartPt,EndPt).x; + m_ParX.NewSize = m_ParX.OldSize + m_ParX.Diff; + m_ParX.xy = _X; + //ģ + m_OpSimulateObj.Operate(m_ParX); + } + if(dir != _DIR_L && dir != _DIR_R) + { + m_ParY.OpType = _OP_STRETCH; + m_ParY.BasePt = gEasyOperationMgr->GetBasePt(); + m_ParY.OldSize = gEasyOperationMgr->GetSize(_Y); + m_ParY.Diff = gEasyOperationMgr->GetDiff(StartPt,EndPt).y; + m_ParY.NewSize = m_ParY.OldSize + m_ParY.Diff; + m_ParY.xy = _Y; + //ģ + m_OpSimulateObj.Operate(m_ParY); + } +} +void CMouseToolStretch::OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy CurPt = gDraw->CPoint2Dbxy(point); + CLayer &layer = gLayer; + if(nFlags&MK_LBUTTON && (m_Status!=_STATUS_1)) + { + if(m_bFirstMove==false) + { + //ػģ + XorRedrawOpSimulateObj(&dc); + } + m_bFirstMove = false; + OperateObj(m_DownPoint,CurPt);// + XorRedrawOpSimulateObj(&dc); + } +} \ No newline at end of file diff --git a/LaipuDrawing/MouseToolStretch.h b/LaipuDrawing/MouseToolStretch.h new file mode 100644 index 0000000..0d75757 --- /dev/null +++ b/LaipuDrawing/MouseToolStretch.h @@ -0,0 +1,19 @@ +#pragma once +#include "mousetool.h" + +//칤 +class CMouseToolStretch :public CMouseTool +{ +public: + CMouseToolStretch(void); + ~CMouseToolStretch(void); + virtual void OperateObj(Dbxy StartPt,Dbxy EndPt); + virtual void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + virtual void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + virtual bool NeedToPointTool(){return true;}; +private: + SObjOperatePar m_ParX;// + SObjOperatePar m_ParY;// +}; + diff --git a/LaipuDrawing/MouseToolmgr.cpp b/LaipuDrawing/MouseToolmgr.cpp new file mode 100644 index 0000000..cd64c38 --- /dev/null +++ b/LaipuDrawing/MouseToolmgr.cpp @@ -0,0 +1,274 @@ +#include "StdAfx.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" +#include "MouseToolmgr.h" +#include "MouseToolPointer.h" +#include "MouseToolRect.h" +#include "MouseToolLine.h" +#include "MouseToolCircle.h" +#include "MouseToolMove.h" +#include "MouseToolRotate.h" +#include "MarkObjPropertieMgr.h" +#include "MouseToolMove2.h" +#include "MouseToolMeasure.h" +#include "MouseToolCopy.h" +#include "MouseToolCut.h" +#include "MouseToolPline.h" +#include "MouseToolDelNode.h" +#include "MouseToolAddNode.h" +#include "MouseToolBreakNode.h" +#include "MouseToolMoveNode.h" +#include "MouseToolOnePoint.h" +#include "CatchMgr.h" +#include "MouseToolStretch.h" +#include "EasyOperationMgr.h" +#include "MouseToolLaserCoord.h" + +//ȫָ빤߹ +CMouseToolMgr gMouseToolMgr; + +CMouseToolMgr::CMouseToolMgr(void) +{ + m_MouseToolType = _TOOL_POINT; +} +CMouseToolMgr::~CMouseToolMgr(void) +{ + ReleseTool(); +} +void CMouseToolMgr::ReleseTool() +{ + if(m_pMouseTool) + delete m_pMouseTool; +} +//깤 +void CMouseToolMgr::SetMouseTool(MOUSE_TOOL MouseToolType) +{ + GetCurViewPtr()->SetCursorStyle(MouseToolType); + //֮ǰĹ + m_OldMouseToolType = m_MouseToolType; + m_MouseToolType = MouseToolType; + //ɾԭĹ + ReleseTool(); + //¹ + m_pMouseTool = CreatMouseTool(MouseToolType); + //ˢ + if(GetFrame()) + { + //һЩ߽view + if(m_MouseToolType != _TOOL_POINT) + { + GetCurViewPtr()->LimitCursor(); + } + else + { + GetCurViewPtr()->ReleseLimitCursor(); + } + } +} +CMouseTool * CMouseToolMgr::CreatMouseTool(MOUSE_TOOL MouseToolType) +{ + CMouseTool *pMouseTool = NULL; + switch(MouseToolType) + { + case _TOOL_POINT: + pMouseTool = new CMouseToolPointer; + break; + case _TOOL_RECT: + pMouseTool = new CMouseToolRect; + break; + case _TOOL_CIRCLE: + pMouseTool = new CMouseToolCircle; + break; + case _TOOL_LINE: + pMouseTool = new CMouseToolLine; + break; + case _TOOL_PLINE: + pMouseTool = new CMouseToolPline; + break; + case _TOOL_MOVE: + pMouseTool = new CMouseToolMove; + break; + case _TOOL_MOVE2: + pMouseTool = new CMouseToolMove2; + break; + case _TOOL_ROTATO: + pMouseTool = new CMouseToolRotate; + break; + case _TOOL_MEASURE: + pMouseTool = new CMouseToolMeasure; + break; + case _TOOL_COPY: + pMouseTool = new CMouseToolCopy; + break; + case _TOOL_CUT: + pMouseTool = new CMouseToolCut; + break; + case _TOOL_DEL_NODE: + pMouseTool = new CMouseToolDelNode; + break; + case _TOOL_ADD_NODE: + pMouseTool = new CMouseToolAddNode; + break; + case _TOOL_BREAK_NODE: + pMouseTool = new CMouseToolBreakNode; + break; + case _TOOL_MOVE_NODE: + pMouseTool = new CMouseToolMoveNode; + break; + case _TOOL_ONE_POINT: + pMouseTool = new CMouseToolOnePoint; + break; + case _TOOL_STRETCH: + pMouseTool = new CMouseToolStretch; + break; + case _TOOL_LASER_COORD: + pMouseTool = new CMouseToolLaserCoord; + break; + default: + break; + } + return pMouseTool; +} +void CMouseToolMgr::OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + //в,ʹò + CPoint CatchPoint; + if(gCatchMgr.GetCatchPoint(CatchPoint)) + { + point = CatchPoint; + } + m_pMouseTool->OnLButtonDown(nFlags,point,dc); +} +void CMouseToolMgr::OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + m_pMouseTool->OnLButtonUp(nFlags,point,dc); + + if(m_pMouseTool->NeedToPointTool()) + { + GetCurViewPtr()->RefreshView(); + if(m_pMouseTool->IsEndStatus()) + { + SetMouseTool(_TOOL_POINT); + ResetCatchPoint(&dc); + } + } + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); +} +void CMouseToolMgr::OnRButtonDown(UINT nFlags, CPoint point,CClientDC &dc) +{ + m_pMouseTool->OnRButtonDown(nFlags,point,dc); + if(m_MouseToolType == _TOOL_LINE + ||m_MouseToolType == _TOOL_PLINE) + { + SetMouseTool(_TOOL_POINT); + ResetCatchPoint(&dc); + } +} +void CMouseToolMgr::OnRButtonUp(UINT nFlags, CPoint point,CClientDC &dc) +{ + m_pMouseTool->OnRButtonUp(nFlags,point,dc); +} +void CMouseToolMgr::OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc) +{ + //׽point ĵ + CatchPoint(point,dc); + //в׽ʹò׽ + CPoint CatchPoint; + if(gCatchMgr.GetCatchPoint(CatchPoint)) + { + point = CatchPoint; + } + //λøı乤ߵ + ChangeMouseTool(nFlags,point); + m_pMouseTool->OnMouseMove(nFlags,point,dc); +} +void CMouseToolMgr::CatchPoint(CPoint point,CClientDC &dc) +{ + Dbxy pt = gDraw->CPoint2Dbxy(point); + Dbxy DownPt = m_pMouseTool->GetDownPoint(); + //һЩ߲긽ĵ(ʱ) + if(m_MouseToolType==_TOOL_LINE + ||m_MouseToolType==_TOOL_PLINE) + { + gCatchMgr.Catch(DownPt,pt,&dc,true); + } + //Ҫʱ + else if(m_MouseToolType==_TOOL_RECT + ||m_MouseToolType==_TOOL_CIRCLE + ||m_MouseToolType==_TOOL_MEASURE + ||m_MouseToolType==_TOOL_ADD_NODE + ||m_MouseToolType==_TOOL_DEL_NODE + ||m_MouseToolType==_TOOL_ONE_POINT + ||m_MouseToolType==_TOOL_LASER_COORD + ||m_MouseToolType==_TOOL_MOVE_NODE + ||m_MouseToolType==_TOOL_PT_MOVE_TO_CCD + ||m_MouseToolType==_TOOL_SET_MARK_PT + ||m_MouseToolType==_TOOL_BREAK_NODE) + { + gCatchMgr.Catch(DownPt,pt,&dc,false); + } + else if(m_MouseToolType==_TOOL_MOVE2 + ||m_MouseToolType==_TOOL_COPY + ||m_MouseToolType==_TOOL_ROTATO) + { + //Щֻڳʼ״̬׽ʱ + if(m_pMouseTool->GetStatus()==_STATUS_1) + { + gCatchMgr.Catch(DownPt,pt,&dc,true); + } + else + { + gCatchMgr.Catch(DownPt,pt,&dc,false); + } + } +} +void CMouseToolMgr::ResetCatchPoint(CDC* pDC) +{ + gCatchMgr.ResetCatchPoint(pDC); +} +void CMouseToolMgr::OnEscapeKey(CDC* pDC) +{ + ResetCatchPoint(pDC); + m_pMouseTool->OnEscapeKey(); +} +//λøı乤ߵ +void CMouseToolMgr::ChangeMouseTool(UINT nFlags, CPoint point) +{ + if((m_MouseToolType==_TOOL_POINT && m_pMouseTool->IsStartStatus()) + ||(m_MouseToolType==_TOOL_MOVE||m_MouseToolType==_TOOL_STRETCH||m_MouseToolType==_TOOL_MOVE_NODE) && !(nFlags&MK_LBUTTON )) + { + //жϵǰ + MOUSE_TOOL type = gLayer.JudgeMouseToolType(gDraw->CPoint2Dbxy(point)); + if(type == _TOOL_POINT) + { + type = gEasyOperationMgr->JudgeMouseToolType(gDraw->CPoint2Dbxy(point)); + } + SetMouseTool(type); + } +} +bool CMouseToolMgr::OnSetCmd(CString str) +{ + if(m_pMouseTool->OnSetCmd(str)) + { + if(m_MouseToolType == _TOOL_CIRCLE + ||m_MouseToolType == _TOOL_MOVE2 + ||m_MouseToolType == _TOOL_ROTATO + ||m_MouseToolType == _TOOL_RECT) + { + if(m_pMouseTool->IsEndStatus()) + { + SetMouseTool(_TOOL_POINT); + GetCurViewPtr()->RefreshView(); + } + } + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); + return true; + } + else + { + return false; + } +} \ No newline at end of file diff --git a/LaipuDrawing/MouseToolmgr.h b/LaipuDrawing/MouseToolmgr.h new file mode 100644 index 0000000..fd49aea --- /dev/null +++ b/LaipuDrawing/MouseToolmgr.h @@ -0,0 +1,34 @@ +#pragma once +#include "GlobalDefine.h" +#include "MouseTool.h" + + +class CMouseTool; +//깤߹ +class CMouseToolMgr +{ +public: + CMouseToolMgr(void); + ~CMouseToolMgr(void); + void ReleseTool(); + void SetMouseTool(MOUSE_TOOL MouseTool); + void OnLButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + void OnLButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + void OnRButtonDown(UINT nFlags, CPoint point,CClientDC &dc); + void OnRButtonUp(UINT nFlags, CPoint point,CClientDC &dc); + void OnMouseMove(UINT nFlags, CPoint point,CClientDC &dc); + MOUSE_TOOL GetToolType(){return m_MouseToolType;};//ȡ + void ResetMouseToolPoint(); + void OnEscapeKey(CDC* pDC); + void ResetCatchPoint(CDC* pDC); + bool OnSetCmd(CString str); +private: + CMouseTool * CreatMouseTool(MOUSE_TOOL MouseTool); + void ChangeMouseTool(UINT nFlags, CPoint point); + void CatchPoint(CPoint point,CClientDC &dc); +private: + MOUSE_TOOL m_MouseToolType;//ǰĹ + MOUSE_TOOL m_OldMouseToolType;//֮ǰĹ + CMouseTool *m_pMouseTool;//ǰĹ +}; +extern CMouseToolMgr gMouseToolMgr; \ No newline at end of file diff --git a/LaipuDrawing/MsgBox.cpp b/LaipuDrawing/MsgBox.cpp new file mode 100644 index 0000000..66c9c9b --- /dev/null +++ b/LaipuDrawing/MsgBox.cpp @@ -0,0 +1,31 @@ +#include "StdAfx.h" +#include "MsgBox.h" +#include "LogMgr.h" + +CMsgBox gMsgBox; + +CMsgBox::CMsgBox(void) +{ + m_bShowing = false; +} +CMsgBox::~CMsgBox(void) +{ +} +void CMsgBox::Show(CString str,bool bError) +{ + CString Log = "MsgBox---->"+str; + //־ + gLogMgr->WriteDebugLog(Log); + AfxMessageBox(str); +} +bool CMsgBox::ConfirmOkCancel(CString str) +{ + return (AfxMessageBox(str,MB_OKCANCEL)==IDOK); +} +void CMsgBox::ShowSetMsg() +{ + m_bShowing = true; + Show(m_Msg); + + m_bShowing = false; +} \ No newline at end of file diff --git a/LaipuDrawing/MsgBox.h b/LaipuDrawing/MsgBox.h new file mode 100644 index 0000000..02c4e64 --- /dev/null +++ b/LaipuDrawing/MsgBox.h @@ -0,0 +1,18 @@ +#pragma once + +// +class CMsgBox +{ +public: + CMsgBox(void); + ~CMsgBox(void); + void Show(CString str,bool bError = false); + bool ConfirmOkCancel(CString str); + void SetMsg(CString s){m_Msg = s;}; + void ShowSetMsg(); + bool IsbShowing(){return m_bShowing;}; +private: + CString m_Msg; + bool m_bShowing; +}; +extern CMsgBox gMsgBox; \ No newline at end of file diff --git a/LaipuDrawing/MyBttom.cpp b/LaipuDrawing/MyBttom.cpp new file mode 100644 index 0000000..851d6c4 --- /dev/null +++ b/LaipuDrawing/MyBttom.cpp @@ -0,0 +1,107 @@ + +#include "stdafx.h" +#include "MyBttom.h" +#include "GlobalDefine.h" + +IMPLEMENT_DYNAMIC(CMyBottom, CMFCButton) + +CMyBottom::CMyBottom() +{ + m_font.CreatePointFont(120,"",NULL); + m_TextColor = RGB_BLACK; + m_DownColor = RGB_GRAY1; + m_UpColor = RGB_GRAY2;//Ĭɫ + +} +CMyBottom::~CMyBottom() +{ +} + +BEGIN_MESSAGE_MAP(CMyBottom, CMFCButton) +END_MESSAGE_MAP() + +// m_MyImgBtn Ϣ + +//btn ʾʽTooltip ڰťϵʾ +void CMyBottom::SetButtonStyle(CString Tooltip) +{ + EnableFullTextTooltip(true); + // Use the application menu font at the button text font. + EnableMenuFont(); + // Use the current Windows theme to draw the button borders. + EnableWindowsTheming(false); + // Set the button to auto-repeat mode. + SetAutorepeatMode(); + // Set the background color for the button text. + //m_CtrlDoorBtn.SetFaceColor(RGB(255,0,0),true); + + SetFontStyle(); + // Set the tooltip of the button. + SetTooltip(Tooltip); + SizeToContent(); + +} +void CMyBottom::SetFontStyle() +{ + SetFont(&m_font); +} +void CMyBottom::Refreash() +{ + //SetFontStyle(); +} +void CMyBottom::SetDownColor(COLORREF color) +{//CMyButtonĺ + m_DownColor = color; + +} +void CMyBottom::SetUpColor(COLORREF color) +{ + if(color != m_UpColor)//ɫ仯ʱˢʾ + { + m_UpColor = color; + SetFontStyle(); + } +} +void CMyBottom::SetTextColor(COLORREF color) +{ + m_TextColor = color; +} +void CMyBottom::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) +{ + CDC dc; + dc.Attach(lpDrawItemStruct->hDC);//õƵ豸CDC + VERIFY(lpDrawItemStruct->CtlType==ODT_BUTTON); + //õButton,IJ:1,ȵõԴ༭İť, + + //Ȼ󽫴»Ƶť, + //ͬʱֵıɫΪ͸,,ťϽʾ + const int bufSize = 512; + TCHAR buffer[bufSize]; + GetWindowText(buffer, bufSize); + int size=strlen(buffer);//õ + DrawText(lpDrawItemStruct->hDC,buffer,size,&lpDrawItemStruct->rcItem,DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_TABSTOP);// + SetBkMode(lpDrawItemStruct->hDC,TRANSPARENT);//͸ + if (lpDrawItemStruct->itemState&ODS_SELECTED)//°ťʱĴ + {////ػ + + CBrush brush(m_DownColor); + dc.FillRect(&(lpDrawItemStruct->rcItem),&brush);//ûˢbrushο + //Ϊػ,ҲҪػ + DrawText(lpDrawItemStruct->hDC,buffer,size,&lpDrawItemStruct->rcItem,DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_TABSTOP); + SetBkMode(lpDrawItemStruct->hDC,TRANSPARENT); + } + else//ťߵʱ + { + CBrush brush(m_UpColor); + dc.FillRect(&(lpDrawItemStruct->rcItem),&brush);// + dc.SetTextColor(m_TextColor); + DrawText(lpDrawItemStruct->hDC,buffer,size,&lpDrawItemStruct->rcItem,DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_TABSTOP); + SetBkMode(lpDrawItemStruct->hDC,TRANSPARENT); + } + //Ʊ߿ + { + COLORREF fc=RGB(255-GetRValue(m_UpColor),255-GetGValue(m_UpColor),255-GetBValue(m_UpColor)); + CBrush brush(fc); + dc.FrameRect(&(lpDrawItemStruct->rcItem),&brush);//ûˢbrushα߿ + } +} \ No newline at end of file diff --git a/LaipuDrawing/MyBttom.h b/LaipuDrawing/MyBttom.h new file mode 100644 index 0000000..218a35e --- /dev/null +++ b/LaipuDrawing/MyBttom.h @@ -0,0 +1,29 @@ +#pragma once + + +// m_MyImgBtn + +class CMyBottom : public CMFCButton +{ + DECLARE_DYNAMIC(CMyBottom) +public: + CMyBottom(); + virtual ~CMyBottom(); + void SetButtonStyle(CString Tooltip); + void SetFontStyle(); + void Refreash(); + virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct); + void SetDownColor(COLORREF color); + void SetUpColor(COLORREF color); + void SetTextColor(COLORREF color); +protected: + DECLARE_MESSAGE_MAP() +private: + CFont m_font; + //ɫֱΪ֣Button DownıɫButton Upıɫ + COLORREF m_TextColor; + COLORREF m_DownColor; + COLORREF m_UpColor; +}; + + diff --git a/LaipuDrawing/MyDlgView.cpp b/LaipuDrawing/MyDlgView.cpp new file mode 100644 index 0000000..2e7915f --- /dev/null +++ b/LaipuDrawing/MyDlgView.cpp @@ -0,0 +1,255 @@ + +#include "stdafx.h" +#include "MyDlgView.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" + + +IMPLEMENT_DYNAMIC(CMyDlgView, CDialogEx) +BEGIN_MESSAGE_MAP(CMyDlgView, CDialogEx) + ON_WM_CTLCOLOR() +END_MESSAGE_MAP() + +CMyDlgView *gChildPCS = NULL; +CMyDlgView *gChildWorkPrepare = NULL; +CMyDlgView *gChildWorkWaferCnt = NULL; + +CMyDlgView *gChildRecipe = NULL; + +CMyDlgView *gChildLaserPathState = NULL; +CMyDlgView *gChildLaserDeviceState = NULL; +CMyDlgView *gChildRobot = NULL; +CMyDlgView *gChildIOState = NULL; +CMyDlgView *gChildLaserPowCheck = NULL; + +CMyDlgView *gChildDeviceMaintenance = NULL; +CMyDlgView *gChildSysParaSet = NULL; + +CMyDlgView *gChildEventLog = NULL; +CMyDlgView *gChildWaferHistory = NULL; +CMyDlgView *gChildCheckHistory = NULL; +CMyDlgView *gDlgChildRealTimeDataHistory = NULL; +CMyDlgView *gDlgChildBeamDataHistory = NULL; +CMyDlgView *gDlgChildConfigHistory = NULL; +CMyDlgView *gDlgChildJobHistory = NULL; + +CMyDlgView *gChildParaHistory = NULL; + +CMyDlgView *gDlgChildLoginHistory = NULL; + +CMyDlgView *gChildDataAnalysis = NULL; + +CMyDlgView *gChildAlarmLog = NULL; + +CMyDlgView *gChildPCS_WaferInfo = NULL; +CMyDlgView *gChildPCS_WaferTransfer = NULL; +CMyDlgView *gChildPCS_AnnealCh = NULL; + + +CMyDlgView::CMyDlgView(UINT nIDTemplate, CWnd* pParent /*=NULL*/) +: CDialogEx(nIDTemplate, pParent) +{ + m_IDD = nIDTemplate; + m_pCurActiveView = NULL;//ǰview + m_bFirstOpen = true;//Ƿһδ +} +CMyDlgView::~CMyDlgView() +{ +} +BOOL CMyDlgView::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + SetTextCtrlItemID(); + + return TRUE; +} + +void CMyDlgView::SetItemText(int ID,CString Str,bool bFillEdit) +{ + //仯ʱˢ,˸ + if(IsDlgItemStrChange(ID,Str,m_DlgItemStrVec)) + { + if(bFillEdit) + Str += " ";//ѿؼ + GetDlgItem(ID)->SetWindowText(Str); + } +} +HBRUSH CMyDlgView::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) +{ + HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor); + if(m_CtrlColorIDSet.count(pWnd->GetDlgCtrlID())) + { + CFont font; + font.CreatePointFont(gDraw->GetEditFontSize(),"Arial"); + pDC->SelectObject(&font); + pDC->SetTextColor(gDraw->GetEditTextColor());//ñ༭ɫ + //pDC-> SetBkMode(TRANSPARENT);//屳Ϊ͸ + pDC->SetBkColor(gDraw->GetEditBkColor());//屳ɫ + return (HBRUSH)::GetStockObject(RGB_BLACK);//RGB_BLACK + } + return hbr; +} +//ػһּ +BOOL CMyDlgView::PreTranslateMessage(MSG* pMsg) +{ + if(pMsg->message==WM_KEYDOWN) + { + char c = pMsg->wParam; + if(c==VK_RETURN || c==VK_ESCAPE) + { + return TRUE; + } + } + //Ҽ + if( pMsg->message == WM_RBUTTONUP ) + return TRUE; + return CDialogEx::PreTranslateMessage(pMsg); +} +CMyDlgView *CMyDlgView::GetChildView(EChildViewType ChildViewType) +{ + CMyDlgView *pChildView = NULL; + switch(ChildViewType) + { + case _ChildView_PCS: + pChildView = gChildPCS; + break; + case _ChildView_WorkPrepare: + pChildView = gChildWorkPrepare; + break; + case _ChildView_WorkWaferCnt: + pChildView = gChildWorkWaferCnt; + break; + case _ChildView_Recipe: + pChildView = gChildRecipe; + break; + case _ChildView_LaserPathState: + pChildView = gChildLaserPathState; + break; + case _ChildView_LaserDeviceState: + pChildView = gChildLaserDeviceState; + break; + case _ChildView_Robot: + pChildView = gChildRobot; + break; + case _ChildView_IOState: + pChildView = gChildIOState; + break; + case _ChildView_DeviceMaintenance: + pChildView = gChildDeviceMaintenance; + break; + case _ChildView_LaserPowCheck: + pChildView = gChildLaserPowCheck; + break; + case _ChildView_SysParaSet: + pChildView = gChildSysParaSet; + break; + case _ChildView_EventLog: + pChildView = gChildEventLog; + break; + case _ChildView_WaferHistory: + pChildView = gChildWaferHistory; + break; + case _ChildView_CheckHistory: + pChildView = gChildCheckHistory; + break; + case _ChildView_RealTimeDataHistory: + pChildView = gDlgChildRealTimeDataHistory; + break; + case _ChildView_BeamDataHistory: + pChildView = gDlgChildBeamDataHistory; + break; + case _ChildView_ConfigHistory: + pChildView = gDlgChildConfigHistory; + break; + case _ChildView_JobHistory: + pChildView = gDlgChildJobHistory; + break; + case _ChildView_ParHistory: + pChildView = gChildParaHistory; + break; + case _ChildView_LoginHistory: + pChildView = gDlgChildLoginHistory; + break; + case _ChildView_DataAnalysis: + pChildView = gChildDataAnalysis; + break; + case _ChildView_PCS_WaferInfo: + pChildView = gChildPCS_WaferInfo; + break; + case _ChildView_PCS_WaferTransfer: + pChildView = gChildPCS_WaferTransfer; + break; + case _ChildView_PCS_AnnealCh: + pChildView = gChildPCS_AnnealCh; + break; + case _ChildView_AlarmLog: + pChildView = gChildAlarmLog; + break; + default: + break; + } + return pChildView; +} +//õǰview +void CMyDlgView::SetActiveView(EChildViewType ChildViewType) +{ + //ʾǰview + CMyDlgView *pActiveView = GetChildView(ChildViewType); + if(pActiveView == m_pCurActiveView) + { + if(pActiveView != NULL) + { + //ûб仯ʱҲҪˢ + pActiveView->OnViewOpen(); + } + return; + } + //֮ǰ + if(m_pCurActiveView != NULL) + { + m_pCurActiveView->ShowWindow(SW_HIDE); + } + if(pActiveView != NULL) + { + pActiveView->SetParent(this); + pActiveView->ShowWindow(SW_SHOW); + pActiveView->OnViewOpen(); + // λ + pActiveView->MoveWindow(m_rChildRect.left, m_rChildRect.top,m_rChildRect.right - m_rChildRect.left, m_rChildRect.bottom - m_rChildRect.top, TRUE); + } + m_pCurActiveView = pActiveView; + m_CurChildViewType = ChildViewType; +} + +//չнڵ +void CMyDlgView::ExpandTree(CTreeCtrl* pTreeCtrl,HTREEITEM hItem) +{ + HTREEITEM hChild,hNext,hParent; + + if((!hItem)||(!pTreeCtrl)) + return; + //չڵ + pTreeCtrl->Expand(hItem,TVE_EXPAND); + + hChild = pTreeCtrl->GetNextItem(hItem,TVGN_CHILD); + if(hChild) + {//ӽڵ㣬չӽڵ + ExpandTree(pTreeCtrl,hChild); + } + else + {//ûӽڵ㣬Ѱֵܽڵ + hNext = pTreeCtrl->GetNextItem(hItem,TVGN_NEXT); + if(hNext) + {//ֵܽڵ + ExpandTree(pTreeCtrl,hNext); + } + else + {//ֵܽڵ㣬Ҹڵ + hParent = pTreeCtrl->GetParentItem(hItem); + hNext = pTreeCtrl->GetNextItem(hParent,TVGN_NEXT); + if(hNext) + ExpandTree(pTreeCtrl,hNext); + } + } +} + diff --git a/LaipuDrawing/MyDlgView.h b/LaipuDrawing/MyDlgView.h new file mode 100644 index 0000000..487d74d --- /dev/null +++ b/LaipuDrawing/MyDlgView.h @@ -0,0 +1,115 @@ +#pragma once +#include "GlobalDefine.h" +#include "ProgramLaserTuiHuo.h" + +//ӽ(˳ν) +enum EChildViewType +{ + _ChildView_NULL = 0, + _ChildView_PCS,// + _ChildView_WorkPrepare,//Ԥ׼ + _ChildView_WorkWaferCnt,//ӹƬͳ + + _ChildView_Recipe,//recipe + + _ChildView_LaserPathState,//·״̬ + _ChildView_LaserDeviceState,//״̬ + _ChildView_Robot,//Ƭе(׼ֱ) + _ChildView_IOState,//IO + + _ChildView_EventLog,//¼¼ + _ChildView_AlarmLog,//¼ + _ChildView_WaferHistory,//wafer ӹ¼ + _ChildView_CheckHistory,//¼ + _ChildView_RealTimeDataHistory,//ʵʱݼ¼ + _ChildView_BeamDataHistory,//ݼ¼ + _ChildView_ConfigHistory,//ݼ¼ + _ChildView_ParHistory,//޸ļ¼ + _ChildView_DataAnalysis,//ݷ + + _ChildView_DeviceMaintenance,//豸ά + _ChildView_LaserPowCheck,//ʵ + _ChildView_SysParaSet,//ϵͳ + + _ChildView_PCS_WaferInfo,//ѡport wafer Ϣ + _ChildView_PCS_WaferTransfer,//ֶWafer + _ChildView_PCS_AnnealCh,//˻ǻϢ + + _ChildView_RecipeScanAreaEdit,//˻ͼ༭ + + _ChildView_LoginHistory, + _ChildView_JobHistory,//ݼ¼ +}; + + +class CMyDlgView : public CDialogEx +{ + DECLARE_DYNAMIC(CMyDlgView) +public: + CMyDlgView(UINT nIDTemplate, CWnd* pParent = NULL); // ׼캯 + virtual ~CMyDlgView(); + virtual void OnViewOpen(){};//Ӧview 򿪵ʱ + virtual void ChangeItemState(){};//ǷҪϵĿؼ + virtual void SetTextCtrlItemID(){};//ʼEdit ؼID + virtual void UpdateLanguageTxt(){};//лʾ + + void SetItemText(int ID,CString Str,bool bFillEdit = true); + int GetIDD(){return m_IDD;}; +protected: + DECLARE_MESSAGE_MAP() + virtual BOOL OnInitDialog(); + afx_msg HBRUSH OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor); + afx_msg BOOL PreTranslateMessage(MSG* pMsg); + + CMyDlgView *GetChildView(EChildViewType ChildViewType); + void SetActiveView(EChildViewType ChildViewType); + void ExpandTree(CTreeCtrl* pTreeCtrl,HTREEITEM hItem); +protected: + int m_IDD; + vector m_DlgItemStrVec;//жʾǷ仯 + set m_CtrlColorIDSet;//edit ɫ + bool m_bFirstOpen;//Ƿһδ + // Ӵλ + CRect m_rChildRect; + CEdit m_EditChild; + CDialogEx *m_pCurActiveView;//ǰview + EChildViewType m_CurChildViewType;//ǰӽ + EChildViewType m_SwitchChildViewType;//лӽ +}; + + +extern CMyDlgView *gChildPCS; +extern CMyDlgView *gChildWorkPrepare; +extern CMyDlgView *gChildWorkWaferCnt; + +extern CMyDlgView *gChildRecipe; + +extern CMyDlgView *gChildLaserPathState; +extern CMyDlgView *gChildLaserDeviceState; +extern CMyDlgView *gChildRobot; +extern CMyDlgView *gChildIOState; +extern CMyDlgView *gChildLaserPowCheck; + +extern CMyDlgView *gChildDeviceMaintenance; +extern CMyDlgView *gChildSysParaSet; + +extern CMyDlgView *gChildEventLog; +extern CMyDlgView *gChildAlarmLog; + +extern CMyDlgView *gChildWaferHistory; +extern CMyDlgView *gChildCheckHistory; +extern CMyDlgView *gDlgChildRealTimeDataHistory; +extern CMyDlgView *gDlgChildBeamDataHistory; +extern CMyDlgView *gDlgChildConfigHistory; +extern CMyDlgView *gDlgChildJobHistory; + + +extern CMyDlgView *gChildParaHistory; +extern CMyDlgView *gDlgChildLoginHistory; + +extern CMyDlgView *gChildDataAnalysis; + +extern CMyDlgView *gChildPCS_WaferInfo; +extern CMyDlgView *gChildPCS_WaferTransfer; +extern CMyDlgView *gChildPCS_AnnealCh; + diff --git a/LaipuDrawing/MyPictrueBttom.cpp b/LaipuDrawing/MyPictrueBttom.cpp new file mode 100644 index 0000000..10ee0dc --- /dev/null +++ b/LaipuDrawing/MyPictrueBttom.cpp @@ -0,0 +1,82 @@ + +#include "stdafx.h" +#include "MyPictrueBttom.h" +#include "GlobalDefine.h" + +IMPLEMENT_DYNAMIC(CMyPictrueBttom, CMFCButton) + +BEGIN_MESSAGE_MAP(CMyPictrueBttom, CMFCButton) +END_MESSAGE_MAP() + +CMyPictrueBttom::CMyPictrueBttom() +{ + m_CurPicType = _EPicType_1;//ǰ + m_PictrueId1 = 0; + m_PictrueId2 = 0; + m_PictrueId3 = 0; + m_PictrueId4 = 0; + m_font.CreatePointFont(100,"",NULL); +} +CMyPictrueBttom::~CMyPictrueBttom() +{ +} +void CMyPictrueBttom::Refresh() +{ + SetFont(&m_font); +} +void CMyPictrueBttom::SetCurPicType(EPicType t) +{ + //ޱ仯 + if(m_CurPicType == t) + return; + m_CurPicType = t; + int PictrueId = 0; + switch(t) + { + case _EPicType_1: + PictrueId = m_PictrueId1; + break; + case _EPicType_2: + PictrueId = m_PictrueId2; + break; + case _EPicType_3: + PictrueId = m_PictrueId3; + break; + case _EPicType_4: + PictrueId = m_PictrueId4; + break; + default: + break; + } + if(PictrueId!=0) + { + SetImage(PictrueId); + //ˢʾ + Refresh(); + } +} +//μ̲ +BOOL CMyPictrueBttom::PreTranslateMessage(MSG* pMsg) +{ + if(pMsg->message==WM_KEYDOWN) + { + char c = pMsg->wParam; + if(c==VK_RETURN || c==VK_ESCAPE) + { + return TRUE; + } + } + return CMFCButton::PreTranslateMessage(pMsg); +} +//ֻON/OFFİť +void CMyPictrueBttom::SetPictrueByBool(bool b) +{ + if(b) + { + SetCurPicType(_EPicType_2); + } + else + { + SetCurPicType(_EPicType_1); + } +} \ No newline at end of file diff --git a/LaipuDrawing/MyPictrueBttom.h b/LaipuDrawing/MyPictrueBttom.h new file mode 100644 index 0000000..c222509 --- /dev/null +++ b/LaipuDrawing/MyPictrueBttom.h @@ -0,0 +1,38 @@ +#pragma once + +enum EPicType +{ + _EPicType_1 = 0, + _EPicType_2, + _EPicType_3, + _EPicType_4, +}; + + + +class CMyPictrueBttom : public CMFCButton +{ + DECLARE_DYNAMIC(CMyPictrueBttom) +public: + CMyPictrueBttom(); + virtual ~CMyPictrueBttom(); + void Refresh(); + void SetPictrueByBool(bool b); + void SetCurPicType(EPicType t); + void SetPictrueId1(int id){m_PictrueId1 = id;}; + void SetPictrueId2(int id){m_PictrueId2 = id;}; + void SetPictrueId3(int id){m_PictrueId3 = id;}; + void SetPictrueId4(int id){m_PictrueId4 = id;}; +protected: + DECLARE_MESSAGE_MAP() + afx_msg BOOL PreTranslateMessage(MSG* pMsg); +private: + CFont m_font; + EPicType m_CurPicType;//ǰ + int m_PictrueId1; + int m_PictrueId2; + int m_PictrueId3; + int m_PictrueId4; +}; + + diff --git a/LaipuDrawing/MyXmlMgr.cpp b/LaipuDrawing/MyXmlMgr.cpp new file mode 100644 index 0000000..8d41f15 --- /dev/null +++ b/LaipuDrawing/MyXmlMgr.cpp @@ -0,0 +1,260 @@ +#include "StdAfx.h" +#include "MyXmlMgr.h" +#include "GlobalDefine.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "GlobalFunction.h" + + + +CMyXmlMgr::CMyXmlMgr(void) +{ +} +CMyXmlMgr::~CMyXmlMgr(void) +{ + +} +/*ɸʽ + + + + + Double + 1000 + + + Double + 0 + + + + + Double + 0 + + + Double + 0 + + + + +*/ +//ݹ麯 +void CMyXmlMgr::SaveXmlItem(TiXmlElement *RootElement,CMyXmlItem &XmlItem) +{ + int size = XmlItem.m_XmlItemVec.size(); + if(size==0)//ӽڵ,ݹյ + { + TiXmlText *XmlValContent = new TiXmlText(XmlItem.m_XmlItemName); + RootElement->LinkEndChild(XmlValContent); + } + else + { + TiXmlElement *ItemElement = new TiXmlElement(XmlItem.m_XmlItemName); + if(XmlItem.m_XmlItemAttributeName!="")//ֵ + { + ItemElement->SetAttribute(XmlItem.m_XmlItemAttributeName, XmlItem.m_XmlItemAttributeVal); + } + RootElement->LinkEndChild(ItemElement); + for(int k=0;kLinkEndChild(pDeclaration); + + //Ԫزӡ + TiXmlElement *RootElement = new TiXmlElement(XmlItem.m_XmlItemName); + myDocument->LinkEndChild(RootElement); + + //ݹ + int size = XmlItem.m_XmlItemVec.size(); + for(int k=0;kSaveFile(CStringToLPCSTR(FilePath)); + + delete myDocument; + } + catch (string& e) + { + CString log =e.c_str(); + log = "ReadXmlErr-->" + log; + gLogMgr->WriteDebugLog(log); + return; + } +} +//ݹ麯 +void CMyXmlMgr::ReadXmlItem(TiXmlElement *RootElement,CMyXmlItem &XmlItem) +{ + XmlItem.m_XmlItemName = RootElement->Value(); + TiXmlAttribute* XmlItemAttribute = RootElement->FirstAttribute();//ֻȡһֵ + if(XmlItemAttribute!=NULL) + { + XmlItem.m_XmlItemAttributeName = XmlItemAttribute->Name(); + XmlItem.m_XmlItemAttributeVal = XmlItemAttribute->Value(); + } + //һӽڵ + TiXmlElement *XmlElement = RootElement->FirstChildElement(); + if(XmlElement==NULL)//һ + { + CMyXmlItem XmlChildItem; + XmlChildItem.m_XmlItemName = RootElement->GetText(); + XmlItem.AddXmlItem(XmlChildItem); + } + else + { + //ǰ + for(;XmlElement != NULL;XmlElement = XmlElement->NextSiblingElement()) + { + CMyXmlItem XmlChildItem; + XmlItem.AddXmlItem(XmlChildItem); + vector&XmlItemVec = XmlItem.m_XmlItemVec; + int size = XmlItemVec.size(); + //ݹ + ReadXmlItem(XmlElement,XmlItemVec[size-1]); + } + } +} +//xml ļлָXmlItem +bool CMyXmlMgr::ReadXmlItemFromFile(CString FilePath,CMyXmlItem &XmlItem) +{ + try + { + XmlItem.m_XmlItemVec.clear(); + + //ļֱ˳ⱨ + CFileMgr FileMgr; + if(!FileMgr.IsFileExist(FilePath)) + { + return false; + } + + //һXMLĵ + TiXmlDocument *myDocument = new TiXmlDocument(CStringToLPCSTR(FilePath)); + myDocument->LoadFile(); + //øԪ + TiXmlElement *RootElement = myDocument->RootElement(); + //ݹ + ReadXmlItem(RootElement,XmlItem); + + delete myDocument; + } + catch (string& e) + { + CString log =e.c_str(); + log = "ReadXmlErr-->" + log; + gLogMgr->WriteDebugLog(log); + return false; + } + return true; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/LaipuDrawing/MyXmlMgr.h b/LaipuDrawing/MyXmlMgr.h new file mode 100644 index 0000000..ed20477 --- /dev/null +++ b/LaipuDrawing/MyXmlMgr.h @@ -0,0 +1,34 @@ +#pragma once +#include "GlobalDefine.h" +#include "tinyxml.h" + + + +//tinyxmlװ + +//ԶXML +class CMyXmlItem +{ +public: + void AddXmlItem(CMyXmlItem &XmlItem){m_XmlItemVec.push_back(XmlItem);}; +public: + CString m_XmlItemName; + CString m_XmlItemAttributeName;//(û) + CString m_XmlItemAttributeVal;//ֵ + vector m_XmlItemVec; +}; + + +class CMyXmlMgr +{ +public: + CMyXmlMgr(void); + ~CMyXmlMgr(void); + void SaveXmlItemToFile(CString FilePath,CMyXmlItem &XmlItem); + bool ReadXmlItemFromFile(CString FilePath,CMyXmlItem &XmlItem); +private: + void SaveXmlItem(TiXmlElement *RootElement,CMyXmlItem &XmlItem); + void ReadXmlItem(TiXmlElement *RootElement,CMyXmlItem &XmlItem); +private: + +}; diff --git a/LaipuDrawing/ObjArc.cpp b/LaipuDrawing/ObjArc.cpp new file mode 100644 index 0000000..ccff698 --- /dev/null +++ b/LaipuDrawing/ObjArc.cpp @@ -0,0 +1,110 @@ +#include "StdAfx.h" +#include "ObjArc.h" +#include "GlobalDrawMgr.h" +#include "DataPoint.h" +#include "GlobalFunction.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "CommandModifiCircle.h" +#include "CommandMgr.h" +#include "WorkFileMgr.h" +#include "DrawSimpleShape.h" + + +CObjArc::CObjArc(void) +{ + m_bDir = true;//Բķ +} +CObjArc::~CObjArc(void) +{ +} +CString CObjArc::GetStr() +{ + CString str = "Բ"; + return str; +} +void CObjArc::Draw(CDC* pDC,CPen &Pen) +{ + //Բĵ + DrawSolidRect(pDC,gDraw->GetObjFirstNodeColor(),gDraw->GetCurPointRect(m_CenterPt.GetPt())); + + CObjBase::Draw(pDC,Pen); +} +void CObjArc::WriteWorkFileExt(vector &LabVec) +{ + CObjBase::WriteWorkFileExt(LabVec); + Dbxy pt = m_CenterPt.GetPt(); + LabVec.push_back(CLab(LAB_OBJ_ARC_CENTER_X,pt.x)); + LabVec.push_back(CLab(LAB_OBJ_ARC_CENTER_Y,pt.y)); + LabVec.push_back(CLab(LAB_OBJ_ARC_EDGE_CNT,m_EdgeCnt)); + LabVec.push_back(CLab(LAB_OBJ_ARC_DIR,m_bDir)); +} +void CObjArc::ReadWorkFileExt(CLabVecRang &LabVecRang) +{ + CObjBase::ReadWorkFileExt(LabVecRang); + + CWorkFileMgr WorkFileMgr; + Dbxy pt; + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_OBJ_ARC_CENTER_X); + if(Lab.m_ValType != _TYPE_NULL) + { + pt.x = Lab.m_Double; + } + } + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_OBJ_ARC_CENTER_Y); + if(Lab.m_ValType != _TYPE_NULL) + { + pt.y = Lab.m_Double; + } + } + m_CenterPt.SetPt(pt); + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_OBJ_ARC_EDGE_CNT); + if(Lab.m_ValType != _TYPE_NULL) + { + m_EdgeCnt = Lab.m_Int; + } + } + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_OBJ_ARC_DIR); + if(Lab.m_ValType != _TYPE_NULL) + { + m_bDir = Lab.m_Bool; + } + } +} +//Բĵ +void CObjArc::SetCenterPt(Dbxy pt) +{ + m_CenterPt.SetPt(pt); +} +void CObjArc::Operate(SObjOperatePar &par) +{ + m_CenterPt.Operate(par);//ԲĵҲҪ + CObjBase::Operate(par); +} +//ȡӹ +void CObjArc::GetPtData(vector> &vec) +{ + CObjBase::GetPtData(vec); + //ԲϢ + int size = vec.size(); + if(size>0) + { + vector &Vec1 = vec[size-1]; + int size1 = Vec1.size(); + if(size1>1) + { + for(int k=0;k &LabVec); + virtual void ReadWorkFileExt(CLabVecRang &LabVecRang); + virtual void Operate(SObjOperatePar &par); + virtual void Draw(CDC* pDC,CPen &Pen); + virtual void GetPtData(vector> &vec); + void SetCenterPt(Dbxy pt); + void SetbDir(bool b){m_bDir = b;}; +private: + CDataPoint m_CenterPt;//Բĵ + int m_EdgeCnt;// + bool m_bDir;//Բķ +}; + diff --git a/LaipuDrawing/ObjBase.cpp b/LaipuDrawing/ObjBase.cpp new file mode 100644 index 0000000..e3f98a3 --- /dev/null +++ b/LaipuDrawing/ObjBase.cpp @@ -0,0 +1,375 @@ +#include "StdAfx.h" +#include "ObjBase.h" +#include "LogMgr.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +#include "PenParMgr.h" +#include "WorkFileLable.h" +#include "WorkFileMgr.h" +#include "CommonFlowMgr.h" +#include "DrawSimpleShape.h" +#include "ProgramLaserTuiHuo.h" +#include "WaferRecipeDataMgr.h" +#include "CStringFuc.h" + + +CObjBase::CObjBase(void) +{ + SetSelected(false);//Ƿѡ + SetLock(false);//Ƿ + m_bDraw = true;//Ƿ + m_bMarkPt = false;//ǷΪmark λ + m_bCollected = false;//Ƿռ + m_bFillObj = false;//ǷΪobj + m_bScaned = false;//Ƿɨ + OnCreat(); +} +CObjBase::~CObjBase(void) +{ +} +//ʱ +void CObjBase::OnCreat() +{ + SetPenNum(gPenParMgr->GetCurPenNum()); +} +void CObjBase::SetPenNum(int n) +{ + m_PenNum = n; +} +#if 1 +//캯 +CObjBase::CObjBase(CObjBase &rhs) +{ + m_bSelected = rhs.m_bSelected;//Ƿѡ + m_PtContainer.Load(rhs.m_PtContainer);//ݵ + m_NodePtContainer.Load(rhs.m_NodePtContainer); + m_PenNum = rhs.m_PenNum; + m_bLocked = rhs.m_bLocked; + m_bDraw = rhs.m_bDraw;//Ƿ + m_bMarkPt = false;//ǷΪmark λ + m_bFillObj = rhs.m_bFillObj;//ǷΪobj + m_bScaned = rhs.m_bScaned;//Ƿɨ +} +//rhs ݵ +void CObjBase::CopyPt(CObjBase &rhs) +{ + m_PtContainer.Load(rhs.m_PtContainer); +} +#endif + +#if 1 +void CObjBase::WriteWorkFileBase(vector &LabVec) +{ + LabVec.push_back(CLab(LAB_OBJ_TYPE,(int)GetType()));//obj + LabVec.push_back(CLab(LAB_PEN_NUM,m_PenNum));//obj ıʺ + LabVec.push_back(CLab(LAB_OBJ_IS_MARK,m_bMarkPt));//ǷΪmark +} +void CObjBase::ReadWorkFileBase(CLabVecRang &LabVecRang) +{ + CWorkFileMgr WorkFileMgr; + //ȡʺ------------------------------------------------ + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_PEN_NUM); + if(Lab.m_ValType != _TYPE_NULL) + { + m_PenNum = Lab.m_Int; + } + } + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_OBJ_IS_MARK); + if(Lab.m_ValType != _TYPE_NULL) + { + m_bMarkPt = Lab.m_Bool; + } + } +} +void CObjBase::WriteWorkFile(vector &LabVec) +{ + //д빫Ϣ + WriteWorkFileBase(LabVec); + + WriteWorkFileExt(LabVec); +} +void CObjBase::ReadWorkFile(CLabVecRang &LabVecRang) +{ + //ȡϢ + ReadWorkFileBase(LabVecRang); + + ReadWorkFileExt(LabVecRang); +} +void CObjBase::WriteWorkFileExt(vector &LabVec) +{ + m_PtContainer.WriteWorkFile(LabVec); +} +void CObjBase::ReadWorkFileExt(CLabVecRang &LabVecRang) +{ + //ȡݵ-------------------------------------------- + m_PtContainer.ReadWorkFile(LabVecRang); +} +#endif + +#if 1 +void CObjBase::Draw(CDC* pDC,CPen &Pen) +{ + if(!m_bDraw) + return; + //ͼ + m_PtContainer.Draw(pDC,Pen); + //ڵ + if(gDraw->IsbShowObjNode() && IsSelected()) + { + m_PtContainer.DrawNode(pDC); + } + // + DrawFill(pDC,Pen); +} +void CObjBase::Draw(CDC* pDC) +{ + if(!m_bDraw) + return; + + CPen Pen; + COLORREF color = gPenParMgr->GetPenColor(m_PenNum); + + if(IsbFillObj())//ɨߵɫ + { + if(gWaferRecipeDataMgr->IsbScanEnd()) + color = RGB_RED; + else + color = RGB_BLUE1; + if(gPenParMgr->IsSpecialPen(m_PenNum)) + return; + } + Pen.CreatePen(PS_INSIDEFRAME,0.5,color); + Draw(pDC,Pen); +} +//һ߶ +void CObjBase::DrawLastLine(CDC* pDC,CPen &Pen) +{ + if(!m_bDraw) + return; + m_PtContainer.DrawLastLine(pDC,Pen); +} +#endif +//һݵ +void CObjBase::AddDataPoint(CDataPoint pt) +{ + m_PtContainer.AddDataPoint(pt); +} +//Ӷڲĵ +void CObjBase::AddNodePt(CDataPoint pt) +{ + m_NodePtContainer.AddDataPoint(pt); +} +bool CObjBase::Empty() +{ + return (m_PtContainer.GetPtCnt()<2) ; +} +void CObjBase::DelAllPt()//ɾݵ +{ + m_PtContainer.DelAllPt(); + m_NodePtContainer.DelAllPt(); +} +//ȡĸ +int CObjBase::GetPtCnt() +{ + return m_PtContainer.GetPtCnt(); +} +void CObjBase::DelLastDataPoint()//ɾһڵ +{ + m_PtContainer.DelLastDataPoint(); +} +int CObjBase::GetNodePtIdx(Dbxy pt) +{ + return m_PtContainer.GetNodePtIdx(pt); +} +void CObjBase::DelNodePtByIdx(int idx) +{ + m_PtContainer.DelNodePtByIdx(idx); +} +void CObjBase::SetNodePtByIdx(int idx,Dbxy pt) +{ + m_PtContainer.SetNodePtByIdx(idx,pt); +} +void CObjBase::InsertNode(int idx,Dbxy pt) +{ + m_PtContainer.InsertNode(idx,pt); +} +void CObjBase::SetLastPoint(CDataPoint &pt) +{ + m_PtContainer.SetLastPoint(pt); +} + +bool CObjBase::IsSelected() +{ + return m_bSelected; +} +void CObjBase::SetSelected(bool bSelected) +{ + if(m_bLocked)//״̬ܱѡ + return; + + m_bSelected = bSelected; +} +DbRect CObjBase::GetRect() +{ + return m_PtContainer.GetRect(); +} +Dbxy CObjBase::GetFirstPt() +{ + return m_PtContainer.GetFirstPt(); +} +Dbxy CObjBase::GetLastPt() +{ + return m_PtContainer.GetLastPt(); +} +//Ƿнڵrect +bool CObjBase::HasNodeInRect(DbRect rect) +{ + return m_PtContainer.HasNodeInRect(rect); +} +//Ƿline ཻ +bool CObjBase::IntersectWithLine(DbLine &line) +{ + return m_PtContainer.IntersectWithLine(line); +} +#if 1 +void CObjBase::Operate(SObjOperatePar &par) +{ + m_GeometryPorp.Operate(par);//¼ + m_PtContainer.Operate(par);//ݵ + m_NodePtContainer.Operate(par);//ڵ + OperateFill(par);// +} +#endif +#if 1//غ +//ȡobj rect ཻ߶(bGetCatchNode ʾǷöIJ׽) +void CObjBase::GetLineInRect(DbRect &rect,vector &DataPtLineVec,bool bGetCatchNode) +{ + m_PtContainer.GetLineInRect(rect,DataPtLineVec); + if(bGetCatchNode) + { + m_NodePtContainer.GetNodePtLineInRect(rect,DataPtLineVec); + } +} +#endif +#if 1 +//Ѽobj ݵvec +void CObjBase::GetPtData(vector> &vec) +{ + if(m_bMarkPt)//Ҫռmark + return; + m_PtContainer.GetPtData(vec,m_PenNum); + //-------------------------------------------------- + vector::iterator iter = m_FillDataVec.begin(); + vector::iterator iter_end = m_FillDataVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).GetPtData(vec,m_PenNum); + } +} +#endif +#if 1//غ +// +void CObjBase::CreatFillData(SFillPar FillPar) +{ + m_FillDataVec.clear(); + + if(!FillPar.bFill) + return; + //Ѽobj ݵvec + vector> vec; + GetPtData(vec); + + // + CObjFill Fill(m_FillDataVec); + Fill.SetPar(FillPar); + Fill.CreatFill(vec,GetRect()); +} +void CObjBase::DrawFill(CDC* pDC,CPen &Pen) +{ + vector::iterator iter = m_FillDataVec.begin(); + vector::iterator iter_end = m_FillDataVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).Draw(pDC,Pen); + } +} +// +void CObjBase::OperateFill(SObjOperatePar &par) +{ + vector::iterator iter = m_FillDataVec.begin(); + vector::iterator iter_end = m_FillDataVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).Operate(par); + } +} +//ȡ +void CObjBase::GetFillData(vector> &vec) +{ + // + vector::iterator iter = m_FillDataVec.begin(); + vector::iterator iter_end = m_FillDataVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).GetPtData(vec); + } +} +#endif +#if 1 +void CObjBase::AddDataPointVec(vector &Vec) +{ + vector &DataPointVec = GetPtContainer(); + + vector::iterator iter = Vec.begin(); + vector::iterator iter_end = Vec.end(); + for(;iter!=iter_end;iter++) + { + DataPointVec.push_back(*iter); + } +} +//ʾtxt +void CObjBase::DrawPtCoord(CDC* pDC) +{ + if(m_bFillObj)//ʾ + return; + vector &DataPointVec = GetPtContainer(); + bool bShowPerPt = false;//ǰһǷʾ + int size = DataPointVec.size(); + for(int k=0;k0) + { + Dbxy PerPt = DataPointVec[k-1].GetPt();//ǰһ + //ǰһֵָʱʾ + if(CalDistance(PerPt,pt)>30) + { + bShow = true; + if(!bShowPerPt)//ǰһûʾʱ + { + DrawPtCoordExt(pDC,PerPt); + } + } + } + + if(bShow) + { + DrawPtCoordExt(pDC,pt); + } + //¼ǰǷʾ + bShowPerPt = bShow; + } +} +void CObjBase::DrawPtCoordExt(CDC* pDC,Dbxy &pt) +{ + CString str= "X"+Db2CString(pt.x,3)+"Y"+Db2CString(pt.y,3); + gDraw->DrawTxt(pDC,str,pt); +} +#endif diff --git a/LaipuDrawing/ObjBase.h b/LaipuDrawing/ObjBase.h new file mode 100644 index 0000000..c0670c3 --- /dev/null +++ b/LaipuDrawing/ObjBase.h @@ -0,0 +1,107 @@ +#pragma once +#include "GlobalDefine.h" +#include "DataPoint.h" +#include "SequentialPoint.h" +#include "SmartPtr.h" +#include "ObjFill.h" +#include "PenParMgr.h" +#include "LabVecRang.h" +#include "ObjGeometryPorp.h" + + + +class CModule; +class CObjPline; +class CObjBase +{ +public: + CObjBase(void); + CObjBase(CObjBase &rhs); + virtual void WriteWorkFileExt(vector &LabVec); + virtual void ReadWorkFileExt(CLabVecRang &LabVecRang); + virtual ~CObjBase(void); + virtual CString GetStr(){return "objbase";}; + virtual CObjBase * Clone(){return new CObjBase;}; + virtual void Draw(CDC* pDC,CPen &Pen); + virtual void Draw(CDC* pDC); + virtual bool IsInRect(DbRect rect,bool bNeedAllIn){return m_PtContainer.IsInRect(rect,bNeedAllIn);};//obj ĵǷrect + virtual OBJ_TYPE GetType(){return _TYPE_BASE;}; + //----------------------------------------------------------------------- + virtual CMFCPropertyGridProperty *CreatSpecialGridProperty(CModule *pModule){return NULL;}; + virtual void OnSpecialPropertyChanged(){}; + virtual void SetSelected(bool bSelected); + virtual void Operate(SObjOperatePar &par); + virtual DbRect GetRect(); + virtual Dbxy GetCenterPt(){return GetRect().GetCenterPt();}; + virtual void BindingDlg(){}; + virtual void GetPtData(vector> &vec); + virtual void GetFillData(vector> &vec); + virtual void CreatFillData(SFillPar FillPar); + virtual void GetLineInRect(DbRect &rect,vector &DataPtLineVec,bool bGetCatchNode = true); + virtual void DrawPtCoord(CDC* pDC); +public: + void WriteWorkFile(vector &LabVec); + void ReadWorkFile(CLabVecRang &LabVecRang); + void AddDataPoint(CDataPoint pt); + void CopyPt(CObjBase &rhs); + void AddNodePt(CDataPoint pt); + bool Empty(); + void DelAllPt();//ɾݵ + void DelLastDataPoint();//ɾһڵ + void DrawLastLine(CDC* pDC,CPen &Pen); + bool IsSelected(); + bool HasNodeInRect(DbRect rect); + vector& GetPtContainer(){return m_PtContainer.GetPtContainer();}; + void SetLastPoint(CDataPoint &pt); + Dbxy GetFirstPt(); + Dbxy GetLastPt(); + int GetNodePtIdx(Dbxy pt); + void DelNodePtByIdx(int idx); + void InsertNode(int idx,Dbxy pt); + void SetNodePtByIdx(int idx,Dbxy pt); + int GetPtCnt(); + SFillPar GetFillPar(){return m_FillPar;}; + bool IntersectWithLine(DbLine &line); + void SetLock(bool b){m_bLocked = b;}; + void SetbDraw(bool b){m_bDraw = b;}; + void SetPenNum(int n); + int GetPenNum(){return m_PenNum;}; + bool IsbMarkPt(){return m_bMarkPt;}; + void SetbMarkPt(bool b){m_bMarkPt = b;}; + bool IsbCollected(){return m_bCollected;}; + void SetbCollected(bool b){m_bCollected = b;}; + bool IsbFillObj(){return m_bFillObj;}; + void SetbFillObj(bool b){m_bFillObj = b;}; + void SetbScaned(bool b){m_bScaned = b;}; + bool IsbScaned(){return m_bScaned;}; +protected: + void OnCreat(); + void DrawFill(CDC* pDC,CPen &Pen); + void OperateFill(SObjOperatePar &par); + void SaveSequentialPoint(ofstream *pfile); + void SaveObjType(ofstream *pfile,CString s); +private: + void WriteWorkFileBase(vector &LabVec); + void ReadWorkFileBase(CLabVecRang &LabVecRang); + COLORREF GetColor(); + void AddDataPointVec(vector &DataPointVec); + void DrawPtCoordExt(CDC* pDC,Dbxy &pt); +protected: + CSequentialPoint m_PtContainer;//ݵ(һ߶) + CSequentialPoint m_NodePtContainer;//洢ڲĵ(Բĵ) + + vector m_FillDataVec;// + SFillPar m_FillPar;// + + bool m_bSelected;//Ƿѡ + bool m_bLocked;//Ƿ,޸ + bool m_bDraw;//Ƿ + bool m_bMarkPt;//ǷΪmark λ + bool m_bCollected;//Ƿռ + bool m_bFillObj;//ǷΪobj + bool m_bScaned;//Ƿɨ + + int m_PenNum;//ʺ + CObjGeometryPorp m_GeometryPorp;//obj ļ +}; + diff --git a/LaipuDrawing/ObjChar.cpp b/LaipuDrawing/ObjChar.cpp new file mode 100644 index 0000000..7f52739 --- /dev/null +++ b/LaipuDrawing/ObjChar.cpp @@ -0,0 +1,117 @@ +#include "StdAfx.h" +#include "ObjChar.h" +#include "ObjPline.h" +#include "DataPoint.h" +#include "FontTypeMgr.h" +#include "LogMgr.h" +#include "GlobalFunction.h" + + +CObjChar::CObjChar(char *p) +{ + m_pChar = p; +} +CObjChar::~CObjChar(void) +{ + +} +CString CObjChar::GetStr() +{ + CString str = "ַ"; + return str; +} +void CObjChar::Creat() +{ + CFontTypeMgr &pFontTypeMgr = CFontTypeMgr::Instance(); + //ȶȡm_PonitVec + vector m_PonitVec; + //õǰַ + pFontTypeMgr.CreatCharVec(m_pChar,m_PonitVec); + //תΪobj + CreatObjData(m_PonitVec); +} + +//ȡobj +void CObjChar::CreatObjData(vector &m_PonitVec) +{ + if(m_PonitVec.size() <= 1)//ûȡ򴴽һ + { + CObjPline *pPline = new CObjPline; + + DbRect rect(0,100,100,0); + pPline->CreatRect(rect); + m_ObjContainer.AddObject(pPline); + } + else + { + int size = m_PonitVec.size(); + + //ȥĩβҪƫ----------------------------------- + if(m_PonitVec[size-1].second == TRUE) + { + m_PonitVec.pop_back(); + size--; + } + //m_PonitVec obj + CObjPline *pPline = NULL; + for(int i=0;iAddDataPoint(DataPoint); + } + } + } + //ɾ߶ + m_ObjContainer.DelNullLine(); +} +void CObjChar::Operate(SObjOperatePar &par) +{ + if(par.OpType == _OP_SCALE) + { + DbRect rect = m_ObjContainer.GetObjRect(false); + DbSize s = rect.GetSize(); + + SObjOperatePar parX; + { + parX.OpType = _OP_STRETCH; + parX.BasePt = rect.GetCenterPt(); + + parX.OldSize = s.w; + parX.NewSize = s.w*par.Scale; + parX.Diff = parX.NewSize-parX.OldSize; + parX.xy = _X; + } + SObjOperatePar parY; + { + parY.OpType = _OP_STRETCH; + parX.BasePt = rect.GetCenterPt(); + + parY.OldSize = s.h; + parY.NewSize = s.h*par.Scale; + parY.Diff = parY.NewSize-parY.OldSize; + parY.xy = _Y; + } + + int size = m_ObjContainer.GetSize(); + for(int i=0;i &m_PonitVec); +private: + char *m_pChar; +}; diff --git a/LaipuDrawing/ObjCircle.cpp b/LaipuDrawing/ObjCircle.cpp new file mode 100644 index 0000000..b9a13ac --- /dev/null +++ b/LaipuDrawing/ObjCircle.cpp @@ -0,0 +1,268 @@ +#include "StdAfx.h" +#include "ObjCircle.h" +#include "GlobalDrawMgr.h" +#include "DataPoint.h" +#include "GlobalFunction.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "CommandModifiCircle.h" +#include "CommandMgr.h" +#include "WorkFileMgr.h" +#include "DrawSimpleShape.h" +#include "WorkDataMgr.h" +#include "CStringFuc.h" + +CObjCircle::CObjCircle(void) +{ + m_bOnlyDrawCenterPt = false;//ֻԲʮ +} +CObjCircle::~CObjCircle(void) +{ +} +CString CObjCircle::GetStr() +{ + CString str = "Բ"; + return str; +} +CMFCPropertyGridProperty *CObjCircle::CreatSpecialGridProperty(CModule *pModule) +{ + CString PropertyName;// + CString Description;// + CString Name; + //-------------------------------------------------------------------------------// + PropertyName = _T(""); + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); + //-------------------------------------------------------------------------------// + { + //Աӳ + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_Radius); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(pModule); + //ʾ + PropertyName = _T("뾶"); + Description = _T("Բİ뾶(λ:mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_Radius, Description); + pGroup->AddSubItem(p1); + gDrawPropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_Diameter); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(pModule); + //ʾ + PropertyName = _T("ֱ"); + Description = _T("Բֱ(λ:mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_Diameter, Description); + pGroup->AddSubItem(p1); + gDrawPropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_EdgeCnt); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(pModule); + //ʾ + PropertyName = _T(""); + Description = _T("Բı(3)(λ:mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_EdgeCnt, Description); + pGroup->AddSubItem(p1); + gDrawPropertieMgr.Insert(p1, pPropertie); + } + return pGroup; +} +//ӦԵı仯 +void CObjCircle::OnSpecialPropertyChanged() +{ + //ޱ仯 + if(IsTwoDbEqual(m_OldRadius,m_Radius)&&IsTwoDbEqual(m_OldEdgeCnt,m_EdgeCnt)&&IsTwoDbEqual(m_OldDiameter,m_Diameter)) + return; + //ֱ仯 + if(!IsTwoDbEqual(m_OldDiameter,m_Diameter)) + { + m_Radius = m_Diameter/2; + } + + //ָ + CCommandModifiCircle *pCmd = new CCommandModifiCircle; + pCmd->SetPar(m_OldRadius,m_OldEdgeCnt,true);//ɵIJ + pCmd->SetPar(m_Radius,m_EdgeCnt,false);//µIJ + gCommandMgr.AddUndoCommand(pCmd); + pCmd->Excute(); + + // + ReCreat(m_Radius,m_EdgeCnt); +} +void CObjCircle::WriteWorkFileExt(vector &LabVec) +{ + CObjBase::WriteWorkFileExt(LabVec); + LabVec.push_back(CLab(LAB_CIRCLE_R,m_Radius)); + LabVec.push_back(CLab(LAB_CIRCLE_D,m_Diameter)); + LabVec.push_back(CLab(LAB_CIRCLE_EDGE_CNT,m_EdgeCnt)); +} +void CObjCircle::ReadWorkFileExt(CLabVecRang &LabVecRang) +{ + CObjBase::ReadWorkFileExt(LabVecRang); + + CWorkFileMgr WorkFileMgr; + //뾶 + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_CIRCLE_R); + if(Lab.m_ValType != _TYPE_NULL) + { + m_Radius = Lab.m_Double; + } + } + //ֱ + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_CIRCLE_D); + if(Lab.m_ValType != _TYPE_NULL) + { + m_Diameter = Lab.m_Double; + } + } + // + { + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_CIRCLE_EDGE_CNT); + if(Lab.m_ValType != _TYPE_NULL) + { + m_EdgeCnt = Lab.m_Int; + } + } +} +//ԭλ +void CObjCircle::ReCreat(double Radius,int DEdgeCnt) +{ + Dbxy CenterPt = GetRect().GetCenterPt(); + CCirclePar ObjCirclePar; + ObjCirclePar.CenterPt = CenterPt; + ObjCirclePar.Radius =Radius; + ObjCirclePar.DEdgeCnt = DEdgeCnt; + Creat(ObjCirclePar); +} +void CObjCircle::CreatByRadius(double Radius,Dbxy CenterPt,int EdgeCnt) +{ + CCirclePar ObjCirclePar; + ObjCirclePar.CenterPt = CenterPt; + ObjCirclePar.Radius = Radius; + ObjCirclePar.DEdgeCnt = EdgeCnt; + Creat(ObjCirclePar); +} +//CenterPt Բ +//R뾶 +//DEdgeCnt +//bMerge Ƿͷβϲ +//StartAng,EndAng ʼǶȺͽǶ360 Ƚ +void CObjCircle::Creat(CCirclePar ObjCirclePar) +{ + Dbxy CenterPt = ObjCirclePar.CenterPt; + double Radius = ObjCirclePar.Radius; + int DEdgeCnt = ObjCirclePar.DEdgeCnt; + bool bMerge = ObjCirclePar.bMerge; + double StartAng = ObjCirclePar.StartAng; + double EndAng = ObjCirclePar.EndAng; + + if(DEdgeCnt == 0) + { + DEdgeCnt = gDraw->GetCirclePtCnt(Radius); + } + + //ɾݵ + DelAllPt(); + + m_OldRadius = m_Radius = Radius; + m_OldEdgeCnt = m_EdgeCnt = DEdgeCnt; + m_OldDiameter = m_Diameter = Radius*2; + + //뾶 + double EachAngle = 360/DEdgeCnt; + bool Flg = true;//һı־ + double CurrAngle = StartAng; + + Dbxy pt; + Dbxy FirstPt; + while(CurrAngleGetCatchNodeSize()*0.5); + DrawCrossX(pDC,Pen,Rect); + } + else + { + CObjBase::Draw(pDC,Pen); + } +} +void CObjCircle::GetPtData(vector> &vec) +{ + if(m_bOnlyDrawCenterPt) + { + if(m_bMarkPt)//Ҫռmark + return; + vector TempVec; + TempVec.push_back(GetRect().GetCenterPt()); + vec.push_back(TempVec); + } + else + { + CObjBase::GetPtData(vec); + } +} + +void CObjCircle::DrawPtCoord(CDC* pDC) +{ + //Բ + Dbxy CenterPt = GetCenterPt(); + CString str= "X"+Db2CString(CenterPt.x,3)+"Y"+Db2CString(CenterPt.y,3); + gDraw->DrawTxt(pDC,str,CenterPt); + //뾶 + Dbxy Pt1(CenterPt.x,CenterPt.y-m_Radius); + Dbxy Pt2(CenterPt.x,CenterPt.y-m_Radius/2);//뾶е + str= "R"+Db2CString(m_Radius,3); + gDraw->DrawTxt(pDC,str,Pt2); + + DrawLine(pDC,gDraw->GetScanLine(),Pt1,CenterPt); +} + diff --git a/LaipuDrawing/ObjCircle.h b/LaipuDrawing/ObjCircle.h new file mode 100644 index 0000000..5d34ad5 --- /dev/null +++ b/LaipuDrawing/ObjCircle.h @@ -0,0 +1,37 @@ +#pragma once +#include "ObjBase.h" + +class CModule; + +class CObjCircle :public CObjBase +{ +public: + CObjCircle(void); + ~CObjCircle(void); + virtual CObjCircle * Clone(){return new CObjCircle(*this);}; + virtual CString GetStr(); + virtual OBJ_TYPE GetType(){return _TYPE_CIRCLE;}; + virtual CMFCPropertyGridProperty *CreatSpecialGridProperty(CModule *pModule); + virtual void OnSpecialPropertyChanged(); + virtual void WriteWorkFileExt(vector &LabVec); + virtual void ReadWorkFileExt(CLabVecRang &LabVecRang); + virtual void CreatByRadius(double Radius,Dbxy CenterPt,int EdgeCnt); + virtual void Draw(CDC* pDC,CPen &Pen); + virtual void GetPtData(vector> &vec); + virtual void DrawPtCoord(CDC* pDC); + + void Creat(CCirclePar ObjCirclePar); + void ReCreat(double Radius,int DEdgeCnt); + void OnlyDrawCenterPt(){m_bOnlyDrawCenterPt = true;}; +private: + double m_OldRadius;//뾶(жǷ仯) + double m_OldDiameter;//ֱ(жǷ仯) + int m_OldEdgeCnt;//(жǷ仯) + + double m_Radius;//뾶 + double m_Diameter;//ֱ + int m_EdgeCnt;// + + bool m_bOnlyDrawCenterPt;//ֻԲʮ +}; + diff --git a/LaipuDrawing/ObjComponent.cpp b/LaipuDrawing/ObjComponent.cpp new file mode 100644 index 0000000..692c952 --- /dev/null +++ b/LaipuDrawing/ObjComponent.cpp @@ -0,0 +1,190 @@ +#include "StdAfx.h" +#include "ObjComponent.h" +#include "DrawSimpleShape.h" +#include "GlobalFunction.h" +#include "TemplateMgr.h" +#include "ObjComponentMgr.h" +#include "CommonFlowMgr.h" + + +CObjComponent::CObjComponent() +{ + m_Size.w = 5; + m_Size.h = 4.2; + Reset(); +} +CObjComponent::CObjComponent(Dbxy pt,DbSize size) +{ + m_BasePt = pt;//ԪĻ׼ + m_Size = size;//Ԫijߴ + Reset(); +} +void CObjComponent::Reset() +{ + m_bBase = false;//ǷΪ׼Ԫ + m_bSel = false;//Ƿѡ + m_TempIdx = 0;//ʹõģ + m_bMarked = false;//Ƿ񱻼ӹ + + m_bCollected = false; + m_bCircle = false;//ǷΪԲ + m_bMarkObj = false;//ǷΪǵobj + m_bMarkSidewardObj = false;//ǷΪobj Աߵobj + m_ColorIdx = -1;//ɫֵ + m_ObjMarkIdx = -1;//obj ,Ƿ񿪿 + m_bAutoCreatObj = false;//ǷΪԶobj + m_ObjLineIdx = 0;//obj line ϵֵ,ȷline obj Ĺϵ + m_bView = false;//Ƿڹ۲ + m_bViewed = false;//Ƿ񱻹۲ + m_bCollecteData = true;//ǷҪռӹ(false ʱռobj ) + + m_Val1 = 0;//¼ֵ1(w) + m_Val2 = 0;//¼ֵ2(¶) +} +CObjComponent::~CObjComponent(void) +{ +} +DbRect CObjComponent::GetRect() +{ + DbRect rect(m_BasePt,m_Size); + return rect; +} +void CObjComponent::Draw(CDC* pDC) +{ +//ɫ----------------------------------------------- + COLORREF c; + c = m_Color; + +//------------------------------------------------- + Dbxy pt = m_BasePt; + DbSize size = m_Size; + DbRect rect = GetRect(); + + DrawSolidRect(pDC,c,rect); + + +} +COLORREF CObjComponent::GetObjColorByIdx(int Idx) +{ + COLORREF c = RGB_GREEN; + //ɫ + int r = GetRValue(c)+30*Idx; + int g = GetGValue(c)+30*Idx; + int b = GetBValue(c)+30*Idx; + COLORREF Color = RGB(r,g,b); + return Color; +} +//ǷѡΧ(bCenterIn ʾĵrect Χ) +bool CObjComponent::IsInRect(DbRect rect,bool bCenterIn) +{ + if(bCenterIn && !m_bCollecteData)//ռݵʱҪ + return false; + + DbRect ObjRect = GetRect(); + bool ret; + if(bCenterIn) + ret = IsPointInRect(ObjRect.GetCenterPt(),rect);//obj ĵrect + else + ret = IsTwoRectIntersect(ObjRect,rect)||IsTwoRectIntersect(rect,ObjRect);//ҵobj ı߾ + + return ret; +} +//mark +void CObjComponent::SetObjMarkIdx(bool b) +{ + m_ObjMarkIdx = b?1:2; +} +//Ӱ󶨵layer obj +void CObjComponent::AddObjShape(Sptr p) +{ + m_ObjShapeVec.push_back(p); +} +//ѡ״̬ +void CObjComponent::SetSelected(bool b) +{ + m_bSel = b; + #if 0 + //ͬʱðlayer obj ѡ״̬ + vector>::iterator iter = m_ObjShapeVec.begin(); + vector>::iterator iter_end = m_ObjShapeVec.end(); + { + (*iter)->SetSelected(b); + } + #endif +} +//ðlayer obj ״̬ +void CObjComponent::SetShapeLockState(bool b) +{ + vector>::iterator iter = m_ObjShapeVec.begin(); + vector>::iterator iter_end = m_ObjShapeVec.end(); + { + (*iter)->SetLock(b); + } +} +//ռ(Ŀǰ㷨Ƚ) +void CObjComponent::CollectWorkData(DbRect &rect,vector> &vec) +{ + if(!m_bCollecteData) + return; + if(m_bCollected)//Ҫظռ + return; + + //ǷռΧ + if(!IsInRect(rect,true))//Ѽݵʱĵж + return; + + //ռģ + vector> VecTmp;// + bool bUseTemplateData = m_ObjShapeVec.empty();//Ƿʹģ(0,0 ģ) + if(bUseTemplateData) + { + gTemplateMgr->CollectWorkData(m_TempIdx,VecTmp);//ģ + } + else//layer obj ʱ + { + vector>::iterator iter = m_ObjShapeVec.begin(); + vector>::iterator iter_end = m_ObjShapeVec.end(); + { + (*iter)->GetPtData(VecTmp); + } + } + + int cnt = 1;//Ԫӹ + vector PointVec; + bool bConnectObj = gCommonFlowMgr->IsbConnectObj();//ǷӶobj + for(int i=0;i>::iterator iter = VecTmp.begin(); + vector>::iterator iter_end = VecTmp.end(); + for(;iter!=iter_end;iter++) + { + if(!bConnectObj) + { + PointVec.clear(); + } + vector::iterator iter1 = (*iter).begin(); + vector::iterator iter1_end = (*iter).end(); + for(;iter1!=iter1_end;iter1++) + { + Dbxy pt = (*iter1); + //ģҪתΪԪĵ(󶨵layer obj ݲҪת) + if(bUseTemplateData) + { + pt.x += m_BasePt.x; + pt.y += m_BasePt.y; + } + PointVec.push_back(pt); + } + if(!bConnectObj) + { + vec.push_back(PointVec); + } + } + } + if(bConnectObj) + { + vec.push_back(PointVec); + } + m_bCollected = true; +} + diff --git a/LaipuDrawing/ObjComponent.h b/LaipuDrawing/ObjComponent.h new file mode 100644 index 0000000..bc1430c --- /dev/null +++ b/LaipuDrawing/ObjComponent.h @@ -0,0 +1,94 @@ +#pragma once +#include "GlobalDefine.h" +#include "SmartPtr.h" +#include "ObjBase.h" + +//Ԫ +class CObjComponent +{ + friend class CDlgObjComponent; +public: + CObjComponent(); + CObjComponent(Dbxy pt,DbSize size); + ~CObjComponent(void); + void Draw(CDC* pDC); + DbRect GetRect(); + Dbxy GetBasePt(){return m_BasePt;}; + void SetBasePt(Dbxy pt){m_BasePt = pt;}; + void SetSize(DbSize s){m_Size = s;}; + DbSize GetSize(){return m_Size;}; + void SetBase(bool b){m_bBase = b;}; + bool IsBase(){return m_bBase;};//ǷΪ׼Ԫ + bool IsInRect(DbRect rect,bool bCenterIn =false); + void SetSelected(bool b); + bool IsSelected(){return m_bSel;}; + void SetbCollected(bool b){m_bCollected = b;};//ռ״̬ + bool IsCollected(){return m_bCollected;}; + void CollectWorkData(DbRect &rect,vector> &vec); + bool IsCircle(){return m_bCircle;}; + void SetIsCircle(bool b){m_bCircle = b;}; + void SetColorIdx(int idx){m_ColorIdx = idx;}; + void SetObjMarkIdx(bool b); + int GetObjMarkIdx(){return m_ObjMarkIdx;}; + void SetbMarkObj(bool b){m_bMarkObj = b;}; + bool IsMarkObj(){return m_bMarkObj;}; + void SetMarkSidewardObj(){m_bMarkSidewardObj = true;}; + void SetObjLineIdx(int idx){m_ObjLineIdx = idx;}; + int GetObjLineIdx(){return m_ObjLineIdx;}; + void SetbAutoCreatObj(){m_bAutoCreatObj = true;}; + bool IsbAutoCreat(){return m_bAutoCreatObj;}; + void SetIndex(IntXY idx){m_Index = idx;}; + IntXY GetIndex(){return m_Index;}; + void SetbView(bool b){m_bView = b;}; + void SetRealBasePt(Dbxy pt){m_RealBasePt = pt;}; + Dbxy GetRealBasePt(){return m_RealBasePt;}; + void SetbViewed(bool b){m_bViewed = b;}; + bool IsbViewed(){return m_bViewed;}; + void AddObjShape(Sptr p); + void SetbMarked(bool b){m_bMarked = b;}; + bool IsbMarked(){return m_bMarked;}; + void NotCollect(){m_bCollecteData = false;};//Ҫռ + bool IsbCollecteData(){return m_bCollecteData;}; + + void SetShapeLockState(bool b); + void SetColor(COLORREF c){m_Color = c;}; + void SetVal1(double val){m_Val1 = val;}; + void SetVal2(double val){m_Val2 = val;}; + double GetVal1(){return m_Val1;}; + double GetVal2(){return m_Val2;}; +private: + void Reset(); + COLORREF GetObjColorByIdx(int Idx); +private: + bool m_bBase;//ǷΪ׼Ԫ + bool m_bSel;//Ƿѡ + bool m_bCircle;//ǷΪԲ + bool m_bCollected;//ǷѾռ,ظռ + bool m_bMarked;//Ƿ񱻼ӹ + bool m_bCollecteData;//ǷҪռӹ(false ʱռobj ) + bool m_bMarkObj;//ǷΪǵobj (CCD λ) + + Dbxy m_BasePt;//ԪĻ׼(ĵ) + DbSize m_Size;//Ԫijߴ + int m_TempIdx;//ʹõģ + int m_ColorIdx;//ɫֵ + int m_ObjMarkIdx;//obj ,Ƿ񿪿 + + int m_ObjLineIdx;//obj line ϵֵ,ȷline obj Ĺϵ + bool m_bAutoCreatObj;//ǷΪԶobj + + bool m_bMarkSidewardObj;//ǷΪobj Աߵobj + + vector> m_ObjShapeVec;//ͼobj (ռ) + //LPS -ISP3000-------------------------------------------------------------------------------------- + IntXY m_Index;//obj + bool m_bView;//Ƿڹ۲ + bool m_bViewed;//Ƿ񱻹۲ + Dbxy m_RealBasePt;//ԪĻ׼(ĵ) ʵʵֵ(ܺʾֵһ) + DbSize m_RealSize;//Ԫijߴ ʵʵֵ(ܺʾֵһ) + + COLORREF m_Color;//ɫ + double m_Val1;//¼ֵ1(w) + double m_Val2;//¼ֵ2(¶) +}; + diff --git a/LaipuDrawing/ObjComponentMgr.cpp b/LaipuDrawing/ObjComponentMgr.cpp new file mode 100644 index 0000000..aa461bf --- /dev/null +++ b/LaipuDrawing/ObjComponentMgr.cpp @@ -0,0 +1,1151 @@ +#include "StdAfx.h" +#include "ObjComponentMgr.h" +#include "CStringFuc.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" +#include "DrawSimpleShape.h" +#include "ObjCircle.h" +#include "WorkFileMgr.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "MeasureMgr.h" +#include "MsgBox.h" +#include "WorkCmdInvoker.h" +#include "LogMgr.h" +#include "Layer.h" +#include "ObjContainer.h" +#include "CommonFlowMgr.h" + + +#define GENG_3 (1.7320508075689)//3 + +CObjComponentMgr *gObjComponentMgr = new CObjComponentMgr; +CObjComponentMgr::CObjComponentMgr(void) +{ + m_CurSelIdx = -1;//ǰѡ ֵ + m_bDrawBase = false;//Ƿֻƻ׼Ԫ + + m_ArrayXcntZ = 35;//X + m_ArrayXcntF = 0;//X + m_ArrayYcntZ = 3;//Y + m_ArrayYcntF = 0;//Y + m_OffsetX = 5;//X + m_OffsetY = 4.2;//Y + + m_RealOffsetX = m_OffsetX;//ʵʵX mm + m_RealOffsetY = m_OffsetY;//ʵʵY mm + + //޶ԪķΧ + m_bUseArea = false;//Ƿʹ޶Χ + + m_bRectArea = false;//true ΪηΧ,false ΪԲηΧ + m_AreaSize.w = 50;//ηΧijߴ + m_AreaSize.h = 50;//ηΧijߴ + m_AreaRadius = 150;//ԲηΧֱ + m_bDrawAllObj = true;//Ƿеԭ + m_bDrawFillColor = false;//Ƿ + m_NoSelColor = RGB_GREEN; + m_SelColor = RGB_RED; + m_ViewObjColor = RGB_YELLOW; + m_ViewedObjColor = RGB_GREEN;//۲obj ɫ + + m_bNeedAllIn = true;//ԪǷҪȫڷΧ + m_bAutoArray = false;//ǷԶ + m_AutoArrayGap = 0.5;//ԶŲ + m_DefaultAng = 0;//ĬϽǶ + + m_CurSelObjIdx.x = 1; + m_CurSelObjIdx.y = 1; + + m_bMoveTrackSDir = true;//Sι켣ƶķ־ + m_bShowRealObj = false;//ʾobj ʵλ + + m_bObjToCcdMode = false;//true ʱѡobj ƶCCD ۲ + + m_bDrawBindingObj = true;//Ƿư󶨵layer obj +} +CObjComponentMgr::~CObjComponentMgr(void) +{ +} +#if 1 +void CObjComponentMgr::WriteWorkFileExt(vector &LabVec) +{ + //ȡҲҪ˳ + LabVec.push_back(CLab(LAB_NULL,m_ArrayXcntZ)); + LabVec.push_back(CLab(LAB_NULL,m_ArrayXcntF)); + LabVec.push_back(CLab(LAB_NULL,m_ArrayYcntZ)); + LabVec.push_back(CLab(LAB_NULL,m_ArrayYcntF)); + LabVec.push_back(CLab(LAB_NULL,m_OffsetX)); + LabVec.push_back(CLab(LAB_NULL,m_OffsetY)); + LabVec.push_back(CLab(LAB_NULL,m_bUseArea)); + LabVec.push_back(CLab(LAB_NULL,m_bRectArea)); + LabVec.push_back(CLab(LAB_NULL,m_AreaBasePt.x)); + LabVec.push_back(CLab(LAB_NULL,m_AreaBasePt.y)); + LabVec.push_back(CLab(LAB_NULL,m_AreaSize.w)); + LabVec.push_back(CLab(LAB_NULL,m_AreaSize.h)); + LabVec.push_back(CLab(LAB_NULL,m_AreaRadius)); + LabVec.push_back(CLab(LAB_NULL,m_bAutoArray)); + LabVec.push_back(CLab(LAB_NULL,m_AutoArrayGap)); + LabVec.push_back(CLab(LAB_NULL,m_DefaultAng)); + //洢׼-------------------------------------------------------- + SaveBaseObj(LabVec); +} +void CObjComponentMgr::ReadWorkFile(CLabVecRang &LabVecRang) +{ + //ɾ + DelAll(); + + //ȡ˳Ҫдͬ + int idx = LabVecRang.GetStart()+1; + m_ArrayXcntZ = LabVecRang.GetInt(idx++); + m_ArrayXcntF = LabVecRang.GetInt(idx++); + m_ArrayYcntZ = LabVecRang.GetInt(idx++); + m_ArrayYcntF = LabVecRang.GetInt(idx++); + m_OffsetX = LabVecRang.GetDouble(idx++); + m_OffsetY = LabVecRang.GetDouble(idx++); + m_bUseArea = LabVecRang.GetBool(idx++); + m_bRectArea = LabVecRang.GetBool(idx++); + m_AreaBasePt.x = LabVecRang.GetDouble(idx++); + m_AreaBasePt.y = LabVecRang.GetDouble(idx++); + m_AreaSize.w = LabVecRang.GetDouble(idx++); + m_AreaSize.h = LabVecRang.GetDouble(idx++); + m_AreaRadius = LabVecRang.GetDouble(idx++); + m_bAutoArray = LabVecRang.GetBool(idx++); + m_AutoArrayGap = LabVecRang.GetDouble(idx++); + m_DefaultAng = LabVecRang.GetDouble(idx++); + //ȡ׼ + ReadBaseObj(LabVecRang); + + // + Array(); +} +//׼ +void CObjComponentMgr::SaveBaseObj(vector &LabVec) +{ + vector::iterator iter = m_BaseComponentVec.begin(); + vector::iterator iter_end = m_BaseComponentVec.end(); + for(;iter!=iter_end;iter++) + { + LabVec.push_back(CLab(LAB_OBJ_START));//ݵ㿪ʼ + + Dbxy BasePt = (*iter).GetBasePt(); + DbSize size = (*iter).GetSize(); + LabVec.push_back(CLab(LAB_POINT_X,BasePt.x)); + LabVec.push_back(CLab(LAB_POINT_Y,BasePt.y)); + LabVec.push_back(CLab(LAB_SIZE_W,size.w)); + LabVec.push_back(CLab(LAB_SIZE_H,size.h)); + LabVec.push_back(CLab(LAB_OBJ_IS_CIRCLE,(*iter).IsCircle())); + + LabVec.push_back(CLab(LAB_OBJ_END));//ݵ + } +} +void CObjComponentMgr::ReadBaseObj(CLabVecRang &LabVecRang) +{ + //obj --------------------------------------------------- + vector LabVecRangVec; + CWorkFileMgr WorkFileMgr; + WorkFileMgr.SeparateStrVec(LabVecRang,LabVecRangVec,LAB_OBJ_START,LAB_OBJ_END); + //ÿobj --------------------------------------------------- + if(!LabVecRangVec.empty()) + { + vector::iterator iter = LabVecRangVec.begin(); + vector::iterator iter_end = LabVecRangVec.end(); + for(;iter!=iter_end;iter++) + { + Dbxy BasePt; + DbSize size; + {//BasePt X + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_POINT_X); + if(Lab.m_ValType != _TYPE_NULL) + { + BasePt.x = Lab.m_Double; + } + } + {//BasePt Y + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_POINT_Y); + if(Lab.m_ValType != _TYPE_NULL) + { + BasePt.y = Lab.m_Double; + } + } + {//size w + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_SIZE_W); + if(Lab.m_ValType != _TYPE_NULL) + { + size.w = Lab.m_Double; + } + } + {//size h + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_SIZE_H); + if(Lab.m_ValType != _TYPE_NULL) + { + size.h = Lab.m_Double; + } + } + bool bIsCircle = true; + {//size h + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_OBJ_IS_CIRCLE); + if(Lab.m_ValType != _TYPE_NULL) + { + bIsCircle = Lab.m_Bool; + } + } + CObjComponent Obj(BasePt,size); + Obj.SetIsCircle(bIsCircle); + m_BaseComponentVec.push_back(Obj); + } + } +} +#endif +#if 1 +void CObjComponentMgr::Draw(CDC* pDC) +{ + if(!m_bDrawAllObj) + return; + { + //Ԫ + int size = m_ComponentVec.size(); + for(int i=0;iGetMarkPointPen(),Rect); +#endif +} +//ƫƻ޶Χ +void CObjComponentMgr::DrawArea(CDC* pDC,Dbxy Offset) +{ + if(m_bUseArea && !m_ComponentVec.empty()) + { + Dbxy BasePt; + BasePt.x += Offset.x; + BasePt.y += Offset.y; + if(m_bRectArea) + { + + DbRect rect(BasePt,m_AreaSize); + DrawRect(pDC,gDraw->GetObjComponentAreaPen(),rect,false); + } + else + { + CObjCircle Circle; + CCirclePar par; + par.CenterPt = m_AreaBasePt; + par.Radius = m_AreaRadius; + par.DEdgeCnt = 200; + Circle.Creat(par); + Circle.Draw(pDC,gDraw->GetObjComponentAreaPen()); + } + } +} +//ѡԪ +bool CObjComponentMgr::SelObjectInRect(DbRect rect) +{ + if(!m_bDrawAllObj) + return false; + + bool flg = false; + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsInRect(rect)) + { + //תѡ + bool b = !((*iter).IsSelected()); + (*iter).SetSelected(b); + flg = true; + + if(!gDraw->IsbMultipleSel())//ѡ + { + Dbxy pt = (*iter).GetBasePt(); + gLogMgr->WriteDebugLog("Sel Obj ViewCoord :","x","y",pt.x,pt.y); + //Թ۲ѡobj ʵֵ + Dbxy RealBasePt = (*iter).GetRealBasePt(); + gLogMgr->WriteDebugLog("Sel Obj RealCoord :","x","y",RealBasePt.x,RealBasePt.y); + break; + } + } + } + //Ӧobj ѡ״̬ĸı + OnObjSelStateChange(); + return flg; +} +//ȫѡ +void CObjComponentMgr::SelAllObj() +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetSelected(true); + } + //Ӧobj ѡ״̬ĸı + OnObjSelStateChange(); +} +void CObjComponentMgr::NotSelAllObj() +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetSelected(false); + } + //Ӧobj ѡ״̬ĸı + OnObjSelStateChange(); +} +//ѡ +void CObjComponentMgr::RevSelAllObj() +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetSelected(!((*iter).IsSelected())); + } + //Ӧobj ѡ״̬ĸı + OnObjSelStateChange(); +} +//Ӧobj ѡ״̬ĸı +void CObjComponentMgr::OnObjSelStateChange() +{ +} +//ȡѡobj ֵvec +void CObjComponentMgr::GetSelObjIdx(vector &SelObjIdxVec) +{ + SelObjIdxVec.clear(); + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + int idx = 0; + for(;iter!=iter_end;iter++,idx++) + { + SelObjIdxVec.push_back((*iter).IsSelected()); + } +} +//ֵͨobj ѡ״̬ +void CObjComponentMgr::SetSelectedByIdx(int idx,bool b) +{ + int size = m_ComponentVec.size(); + if(idx::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + int idx = 0; + for(;iter!=iter_end;iter++,idx++) + { + if((*iter).IsbCollecteData()) + { + AdjustRectByPoint(Rect,(*iter).GetBasePt()); + } + } + m_AllObjCenterPt = Rect.GetCenterPt(); +} +#endif +#if 1 +//ȡǰѡobj +int CObjComponentMgr::GetSelObjCnt() +{ + int cnt = 0; + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsSelected()) + cnt++; + } + return cnt; +} +//ȡǰ趨mark +int CObjComponentMgr::GetMarkObjCnt() +{ + int cnt = 0; + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsMarkObj()) + cnt++; + } + return cnt; +} +void CObjComponentMgr::ResetAllMarkObj() +{ + int cnt = 0; + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetbMarkObj(false); + } +} +//õǰѡobj Ϊmark +void CObjComponentMgr::SetSelObjMark(int CurMarkCnt) +{ + int idx = CurMarkCnt+1; + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsSelected()) + { + (*iter).SetbMarkObj(true); + CString LogStr; + LogStr.Format(("Set Mark Pt [%d]"),idx++); + gLogMgr->WriteDebugLog(LogStr); + Dbxy pt = (*iter).GetBasePt(); + LogStr.Format(("[pt.x] = [%f] ,[pt.y] = [%f]"),pt.x,pt.y); + gLogMgr->WriteDebugLog(LogStr); + } + } +} +//õǰѡobj Ϊmark obj +bool CObjComponentMgr::SetMarkObj() +{ + int SelObjCnt = GetSelObjCnt();//ѡĸ + if(SelObjCnt>2) + { + //gLogMgr->WriteDebugLog("ָobj Ϊmark"); + return false; + } + if(SelObjCnt==0) + { + return false; + } + int MarkObjCnt = GetMarkObjCnt();//mark obj ĸ + if(MarkObjCnt>=2) + { + ResetAllMarkObj(); + MarkObjCnt = 0; + } + //õǰѡobj Ϊmark + SetSelObjMark(MarkObjCnt); + return true; +} +#endif +#if 1 +//һ׼Ԫ +void CObjComponentMgr::AddBaseComponent() +{ + Dbxy pt; + DbSize size(2,2); + AddBaseComponent(pt,size); +} +void CObjComponentMgr::AddBaseComponent(Dbxy pt,DbSize size) +{ + CObjComponent Component(pt,size); + Component.SetBase(true); + m_BaseComponentVec.push_back(Component); +} + +//һͨԭ +void CObjComponentMgr::AddComponent(CObjComponent Component) +{ + m_ComponentVec.push_back(Component); +} +void CObjComponentMgr::InsertList(CListCtrl &List) +{ + int size = m_BaseComponentVec.size(); + for(int i=0;i= size) + return false; + return true; +} +void CObjComponentMgr::DelSel(int &idx) +{ + if(!IdxValid(idx)) + return; + vector::iterator iter = m_BaseComponentVec.begin(); + vector::iterator iter_end = m_BaseComponentVec.end(); + int i=0; + for(;iter!=iter_end;iter++) + { + if(i==idx) + { + m_BaseComponentVec.erase(iter); + idx = -1; + break; + } + i++; + } +} +//ɾ +void CObjComponentMgr::DelAll() +{ + m_BaseComponentVec.clear(); + m_ComponentVec.clear(); + m_CatchPtVec.clear(); +} +//idx +void CObjComponentMgr::OpArea(int idx,CObjComponent &Area,bool bRead) +{ + int size = m_BaseComponentVec.size(); + for(int i=0;i=endX;i--) + { + for(int j = startY;j>=endY;j--) + { + //obj ֵ + IntXY idx; + idx.x = (i-startX-1)*(-1); + idx.y = (j-startY-1)*(-1); + Arrayij(i,j,idx,Offset,RealOffset); + } + } +} +//i еj (Offset ʾƫ,RealOffset ʵƫ) +void CObjComponentMgr::Arrayij(int i,int j,IntXY idx,Dbxy Offset,Dbxy RealOffset) +{ + int size = m_BaseComponentVec.size(); + for(int k=0;k::iterator iter = m_BaseComponentVec.begin(); + vector::iterator iter_end = m_BaseComponentVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetBasePt(Offset); + } +} +//ڽҵpt ĵ +Dbxy CObjComponentMgr::FindNearestPt(Dbxy pt) +{ + Dbxy NearestPt = pt; + double MinDis = -1; + vector::iterator iter = m_CatchPtVec.begin(); + vector::iterator iter_end = m_CatchPtVec.end(); + for(;iter!=iter_end;iter++) + { + double dis = CalDistance(pt,(*iter)); + if(MinDis == -1 || dis < MinDis) + { + MinDis = dis; + NearestPt = (*iter); + } + } + return NearestPt; +} +#endif +#if 1 +//ͨlayer еͼζobj +void CObjComponentMgr::CreatObjByLayerObj() +{ + m_ComponentVec.clear(); + + CLayer &Layer = gLayer; + CObjContainer &ObjContainer = Layer.GetObjContainer(); + vector> &ObjVec = ObjContainer.GetObjVec(); + + vector>::iterator iter = ObjVec.begin(); + vector>::iterator iter_end = ObjVec.end(); + for(;iter!=iter_end;iter++) + { + DbRect rect = (*iter)->GetRect(); + if(!m_bDrawBindingObj)//Ƿưobj + { + (*iter)->SetbDraw(false); + } + (*iter)->SetSelected(false); + Dbxy pt = rect.GetCenterPt(); + DbSize size = rect.GetSize(); + double MinSize = 2; + if(size.w MarkVec; + //ҳ뾶СR Ķ + { + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + DbSize Size = (*iter).GetSize(); + if(Size.wIsCollected())//ظ + continue; + Dbxy pt1 = MarkVec[i]->GetBasePt(); + for(int k=i+1;kIsCollected())//ظ + continue; + Dbxy pt2 = MarkVec[k]->GetBasePt(); + double dis = CalDistance(pt1,pt2); + if(dis<0.5)//ƥ + { + MarkVec[k]->SetbMarkObj(true);//Ϊmark + MarkVec[k]->SetbCollected(true); + MarkCnt++;//¼ҵmark + break; + } + } + MarkVec[i]->SetbCollected(true);// + } + } + CString LogStr; + LogStr.Format(_T("func: AnalyseMarkPt---->[MarkCnt] = [%d]"),MarkCnt); + gLogMgr->WriteDebugLog(LogStr); +} +//û׼ +DbSize CObjComponentMgr::GetBaseSize(int idx) +{ + DbSize BaseSize; + int size = m_BaseComponentVec.size(); + if(idx>=0 && idx=0 && idx::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetbCollected(false); + if(NeedSel && (*iter).IsSelected()==false) + { + (*iter).SetbCollected(true);//δѡIJҪռ + } + } +} +//ռrect ΧԪĹ +void CObjComponentMgr::CollectWorkData(DbRect &rect,vector> &vec,bool bNeedSel) +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if(!bNeedSel || (bNeedSel && (*iter).IsSelected())) + { + (*iter).CollectWorkData(rect,vec); + } + } +} +//صһ׼obj ǷԲ +bool CObjComponentMgr::IsCircle() +{ + if(m_BaseComponentVec.empty()) + return true; + return m_BaseComponentVec[0].IsCircle(); +} +//õһ׼obj ǷΪԲ +void CObjComponentMgr::SetIsCircle(bool b) +{ + if(!m_BaseComponentVec.empty()) + { + m_BaseComponentVec[0].SetIsCircle(b); + } +} +//ͨobj 󴴽markarea +void CObjComponentMgr::CreatAreaByObj(CMarkAreaMgr &AreaMgr) +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + CMarkArea Area((*iter).GetBasePt(),(*iter).GetSize()); + AreaMgr.AddArea(Area); + } +} +#endif +#if 1 +//ȡһѡobj ֵ +IntXY CObjComponentMgr::GetFristSelectedObjIdx() +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsSelected()) + { + return (*iter).GetIndex(); + } + } + IntXY idx(-1,-1); + return idx; +} +//תΪvector ֵ(ûƥ䷵-1) +int CObjComponentMgr::ConvertIdx(IntXY Idx) +{ + int size = m_ComponentVec.size(); + for(int i=0;i=0) + { + CString LogStr; + LogStr.Format(_T("Fuc:MoveSelObjToPt : Idx[X] = [%d] ,Idx[Y] = [%d]"),IdxXY.x,IdxXY.y); + gLogMgr->WriteDebugLog(LogStr); + //¼ǰ۲obj ֵ + SetCurViewObjIdx(IdxXY); + //Ϊѹ۲ + m_ComponentVec[idx].SetbViewed(true); + return true; + } + return false; +} +//ͨƶobj ָ +void CObjComponentMgr::MoveObjToCameraByDir(DIRECTION dir,Dbxy TargetPt) +{ + IntXY IdxXY = GetCurViewObjIdx(); + if(dir == _DIR_R) + IdxXY.x--; + else if(dir == _DIR_L) + IdxXY.x++; + else if(dir == _DIR_U) + IdxXY.y--; + else if(dir == _DIR_D) + IdxXY.y++; + else if(dir == _DIR_M) + { + IdxXY.x = 1; + IdxXY.y = 1; + } + MoveObjToPtByIdx(IdxXY,TargetPt); +} +//S ι켣ƶobj (bDir ƶ) +void CObjComponentMgr::MoveTrackS(Dbxy TargetPt,IntXY Gap,bool bDir) +{ + IntXY IdxXY = GetCurViewObjIdx(); + IntXY NewIdxXY = IdxXY; + + if(m_bMoveTrackSDir)// + NewIdxXY.y += Gap.y; + else// + NewIdxXY.y -= Gap.y; + + if(MoveObjToPtByIdx(NewIdxXY,TargetPt)==false)//ͷˣƶ + { + NewIdxXY.y = IdxXY.y; + if(bDir)// + NewIdxXY.x += Gap.x; + else// + NewIdxXY.x -= Gap.x; + + if(MoveObjToPtByIdx(NewIdxXY,TargetPt))//ƶ + { + m_bMoveTrackSDir = !m_bMoveTrackSDir;//ƶY + } + } +} +#endif +#if 1 +//LPS ISP3000 ͨdie ľһobj ֳ(bDivideX Ƿ뷽) +void CObjComponentMgr::DivideBySpacingDis(double dis,bool bDivideX) +{ + if(dis<0.001) + return; + + vector ComponentVecTmp;//ʱ + + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + ComponentVecTmp.push_back(CopyObj((*iter),-1,dis,bDivideX)); + ComponentVecTmp.push_back(CopyObj((*iter),1,dis,bDivideX)); + } + m_ComponentVec = ComponentVecTmp; +} +CObjComponent CObjComponentMgr::CopyObj(CObjComponent &Obj,int sign,double dis,bool bDivideX) +{ + Dbxy BasePt = Obj.GetBasePt();//ʾ + Dbxy RealBasePt = Obj.GetRealBasePt();//ʵʵ + DbSize size = Obj.GetSize();//ʾߴ + IntXY Idx = Obj.GetIndex(); + CObjComponent NewObj = Obj; + BasePt.x += (size.w/4)*(sign); + NewObj.SetBasePt(BasePt); + RealBasePt.x += (dis/2)*(sign); + NewObj.SetRealBasePt(RealBasePt); + size.w /= 2; + NewObj.SetSize(size); + Idx.x *=2; + if(sign==1) + Idx.x -= 1; + NewObj.SetIndex(Idx); + return NewObj; +} +//ǰ۲obj +int CObjComponentMgr::GetCurViewedObj() +{ + int cnt = 0; + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsbViewed()) + cnt++; + } + return cnt; +} +#endif + +#if 1 +//лǷƶccd ģʽ +bool CObjComponentMgr::SwithObjToCcdMode() +{ + m_bObjToCcdMode = !m_bObjToCcdMode; + return m_bObjToCcdMode; +} +//ȡһѡobj ĵ +Dbxy CObjComponentMgr::GetFristSelObjCenter() +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsSelected()) + return (*iter).GetRealBasePt(); + } + Dbxy pt; + return pt; +} +#endif +#if 1 +//rect obj mark ״̬(bSel ʾǷҪѡʱ) +//obj ݷΧ(markarea) +DbRect CObjComponentMgr::SetMarkedStateRect(DbRect AreaRect,bool bSel) +{ + DbRect DataRect;//ݷΧ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + if(bSel && !(*iter).IsSelected()) + continue; + if(!(*iter).IsbMarked() && (*iter).IsInRect(AreaRect,true)) + { + (*iter).SetbMarked(true); + AdjustRectByRect(DataRect,(*iter).GetRect()); + } + } + return DataRect; +} +//obj ļӹ״̬ +void CObjComponentMgr::ResetAllMarkedState() +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetbMarked(false); + } +} +//ԭlayer obj ״̬(ɾ) +void CObjComponentMgr::SetShapeLockState(bool b) +{ + vector::iterator iter = m_ComponentVec.begin(); + vector::iterator iter_end = m_ComponentVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).SetShapeLockState(b); + } +} +#endif \ No newline at end of file diff --git a/LaipuDrawing/ObjComponentMgr.h b/LaipuDrawing/ObjComponentMgr.h new file mode 100644 index 0000000..d380ded --- /dev/null +++ b/LaipuDrawing/ObjComponentMgr.h @@ -0,0 +1,149 @@ +#pragma once +#include "ObjComponent.h" +#include "Module.h" +#include "LabVecRang.h" +#include "MarkAreaMgr.h" + + + +//Ԫ +class CObjComponentMgr :public CModule +{ + friend class CDlgObjComponent; + friend class CDlgObjComponentArr; +public: + CObjComponentMgr(void); + ~CObjComponentMgr(void); + virtual void Draw(CDC* pDC);//pDC һЩ + virtual MODULE GetModuleType(){return _OBJ_COMPONENT_PROP;}; + virtual void WriteWorkFileExt(vector &LabVec); + virtual void ReadWorkFile(CLabVecRang &LabVecRang); + + bool IsInArea(Dbxy pt,DbSize Size); + void SetDrawBase(bool b){m_bDrawBase = b;}; + void AddBaseComponent(); + void AddBaseComponent(Dbxy pt,DbSize size); + void AddComponent(CObjComponent Component); + void InsertList(CListCtrl &List); + void DelSel(int &idx); + void DelAll(); + void OpArea(int idx,CObjComponent &Area,bool bRead); + void SetCurSelIdx(int idx){m_CurSelIdx = idx;}; + void Array(); + bool SelObjectInRect(DbRect rect); + void SelAllObj(); + void NotSelAllObj(); + void RevSelAllObj(); + vector &GetCatchPtVec(){return m_CatchPtVec;}; + void SetDrawAllObj(bool b){m_bDrawAllObj = b;};//Ƿԭ + void DelAllBaseObj(){m_BaseComponentVec.clear();}; + bool HasBase(){return !m_BaseComponentVec.empty();};//Ƿл׼ + DbSize GetBaseSize(int idx); + bool IsBaseCircle(int idx); + void CollectWorkData(DbRect &rect,vector> &vec,bool bNeedSel); + void ResetObjCollectState(bool NeedSel); + void DrawArea(CDC* pDC,Dbxy Offset); + void SetAreaRadius(double r){m_AreaRadius = r;}; + double GetAreaRadius(){return m_AreaRadius;}; + COLORREF GetNoSelColor(){return m_NoSelColor;}; + COLORREF GetSelColor(){return m_SelColor;}; + COLORREF GetViewColor(){return m_ViewObjColor;}; + COLORREF GetViewedObjColor(){return m_ViewedObjColor;}; + bool IsDrawFillColor(){return m_bDrawFillColor;}; + void SetDefaultAng(double ang){m_DefaultAng = ang;}; + double GetDefaultAng(){return m_DefaultAng;}; + Dbxy FindNearestPt(Dbxy pt); + bool IsAutoArray(){return m_bAutoArray;}; + bool HasObj(){return !m_ComponentVec.empty();}; + void CreatAreaByObj(CMarkAreaMgr &AreaMgr); + int GetObjCnt(){return m_ComponentVec.size();} + void GetSelObjIdx(vector &SelObjIdxVec); + void SetSelectedByIdx(int idx,bool b); + vector&GetComponentVec(){return m_ComponentVec;}; + void CreatObjByLayerObj(); + void AnalyseMarkPt(double R); + void SetAreaBasePt(Dbxy pt){m_AreaBasePt = pt;}; + IntXY GetFristSelectedObjIdx(); + void MoveFristSelObjToPt(Dbxy TargetPt); + void MoveObjToCameraByDir(DIRECTION dir,Dbxy TargetPt); + IntXY GetCurViewObjIdx(){return m_CurSelObjIdx;}; + void MoveTrackS(Dbxy TargetPt,IntXY Gap,bool bDir); + void ResetMoveTrackSDir(){m_bMoveTrackSDir = true;};//÷ + bool IsbShowRealObj(){return m_bShowRealObj;}; + void SetCurSelObjIdx(IntXY Idx); + bool MoveObjToPtByIdx(IntXY IdxXY,Dbxy TargetPt); + int GetCurViewedObj(); + bool SetMarkObj(); + bool SwithObjToCcdMode(); + DbRect SetMarkedStateRect(DbRect rect,bool bSel); + void ResetAllMarkedState(); + void SetShapeLockState(bool b); + Dbxy GetAllObjCenterPt(){return m_AllObjCenterPt;}; + void CalAllObjCenterPt(); + void ResetAllMarkObj(); +private: + bool IdxValid(int idx); + void ArrayExt(); + void Arrayij(int i,int j,IntXY idx,Dbxy Offset,Dbxy RealOffset); + void AutoArray(); + void SetBaseObjOffset(Dbxy Offset); + bool AutoArrayExt(Dbxy BasePt,DbSize Size,double OffsetX,double OffsetY,bool bIsCircle); + void SaveBaseObj(vector &LabVec); + void ReadBaseObj(CLabVecRang &LabVecRang); + bool IsCircle(); + void SetIsCircle(bool b); + void OnObjSelStateChange(); + int ConvertIdx(IntXY Idx); + void SetCurViewObjIdx(IntXY Idx); + void DivideBySpacingDis(double dis,bool bDivideX); + CObjComponent CopyObj(CObjComponent &Obj,int sign,double dis,bool bDivideX); + int GetMarkObjCnt(); + void SetSelObjMark(int CurMarkCnt); + int GetSelObjCnt(); + Dbxy GetFristSelObjCenter(); +private: + vector m_BaseComponentVec;//׼Ԫ + vector m_ComponentVec;//Ԫ + bool m_bDrawAllObj;//Ƿеԭ + bool m_bDrawBase;//Ƿֻƻ׼Ԫ + int m_CurSelIdx;//ǰѡĻ׼Ԫ ֵ + vector m_CatchPtVec;//иĽ㣬ָץȡ + + bool m_bObjToCcdMode;//true ʱѡobj ƶCCD ۲ +//ҪIJ----------------------------------------------- + COLORREF m_NoSelColor;//ûѡеɫ + COLORREF m_SelColor;//ѡеɫ + COLORREF m_ViewObjColor;//ڹ۲obj ɫ + COLORREF m_ViewedObjColor;//۲obj ɫ + + bool m_bDrawBindingObj;//Ƿư󶨵layer obj + bool m_bDrawFillColor;//Ƿ + bool m_bAutoArray;//ǷԶ + double m_AutoArrayGap;//ԶŲ(mm) + double m_DefaultAng;//ĬϽǶ + //ԪϢ--------------------------------------------------------------- + int m_ArrayXcntZ;//X + int m_ArrayXcntF;//X + int m_ArrayYcntZ;//Y + int m_ArrayYcntF;//Y + double m_OffsetX;//X + double m_OffsetY;//Y + //޶ԪķΧ------------------------------------------------------------- + bool m_bUseArea;//Ƿʹ޶Χ + bool m_bRectArea;//true ΪηΧ,false ΪԲηΧ + Dbxy m_AreaBasePt;//ΧĻ׼ + DbSize m_AreaSize;//ηΧijߴ + double m_AreaRadius;//ԲηΧֱ + bool m_bNeedAllIn;//ԪǷҪȫڷΧ + + + Dbxy m_AllObjCenterPt;//ԭ,㲻ӹobj + //LPS - ISP3000------------------------------------------------------------------ + IntXY m_CurSelObjIdx;//ǰѡobj ֵ + double m_RealOffsetX;//ʵʵX mm + double m_RealOffsetY;//ʵʵY mm + bool m_bMoveTrackSDir;//Sι켣ƶķ־ + bool m_bShowRealObj;//ʾobj ʵλ +}; + +extern CObjComponentMgr *gObjComponentMgr; \ No newline at end of file diff --git a/LaipuDrawing/ObjComposite.cpp b/LaipuDrawing/ObjComposite.cpp new file mode 100644 index 0000000..cc17109 --- /dev/null +++ b/LaipuDrawing/ObjComposite.cpp @@ -0,0 +1,120 @@ +#include "StdAfx.h" +#include "ObjComposite.h" +#include "ObjPline.h" +#include "GlobalFunction.h" + + +CObjComposite::CObjComposite(void) +{ + m_Distance = 10;//׼ľ +} +CObjComposite::~CObjComposite(void) +{ +} +CObjComposite::CObjComposite(CObjComposite &rhs) +:CObjBase(rhs) +{ + m_BasePt1 = rhs.m_BasePt1;//object ǰλ + m_BasePt2 = rhs.m_BasePt2;//object ǰλ(ڼ¼ת) + m_Distance = rhs.m_Distance;//ľ + + rhs.m_ObjContainer.CloneObj(m_ObjContainer,false); +} +#if 1 +void CObjComposite::WriteWorkFileExt(vector &LabVec) +{ + //дobj Ϣ + m_ObjContainer.WriteWorkFile(LabVec); +} +void CObjComposite::ReadWorkFileExt(CLabVecRang &LabVecRang) +{ + //ȡobj Ϣ + m_ObjContainer.ReadWorkFile(LabVecRang); +} +#endif +//bNewLine ʾǷҪ½һ߶ +void CObjComposite::AddPt(CDataPoint pt,bool bNewLine) +{ + if(bNewLine) + { + CObjPline *p = new CObjPline; + p->AddDataPoint(pt); + m_ObjContainer.AddObject(p); + } + else + { + m_ObjContainer.AddPtToLastObj(pt); + } +} +void CObjComposite::Creat() +{ + CreatExt(); + UpdateSelState(); +} +//obj ѡ״̬ +void CObjComposite::UpdateSelState() +{ + if(m_bSelected) + { + m_ObjContainer.SelAllObj(); + } + else + { + m_ObjContainer.NotSelAllObj(); + } +} +void CObjComposite::Draw(CDC* pDC,CPen &Pen) +{ + m_ObjContainer.DrawAllObj(pDC); +} +bool CObjComposite::IsInRect(DbRect rect,bool bNeedAllIn) +{ + return m_ObjContainer.IsInRect(rect,bNeedAllIn); +} +void CObjComposite::SetSelected(bool bSelected) +{ + CObjBase::SetSelected(bSelected);//ȫѡ״̬ + + m_ObjContainer.SetSelected(bSelected);//ÿԱѡ״̬ +} +void CObjComposite::Operate(SObjOperatePar &par) +{ + //¼ + SavePar(par); + m_ObjContainer.Operate(par); +} +//¼, ɵǷλ +void CObjComposite::SavePar(SObjOperatePar &par) +{ + if(par.OpType == _OP_MOVE) + { + m_BasePt1.x += par.MoveX; + m_BasePt1.y += par.MoveY; + m_BasePt2.x += par.MoveX; + m_BasePt2.y += par.MoveY; + } + if(par.OpType == _OP_ROTATO) + { + m_BasePt1 = RotatoPt(m_BasePt1,_360ToAngle(par.Angle),par.BasePt); + m_BasePt2 = RotatoPt(m_BasePt2,_360ToAngle(par.Angle),par.BasePt); + } +} +DbRect CObjComposite::GetRect() +{ + return m_ObjContainer.GetObjRect(false); +} +void CObjComposite::SetPosition(Dbxy pt) +{ + m_BasePt1 = m_BasePt2= pt; + m_BasePt2.x += m_Distance; +}; +//ίиԱȥѼ +void CObjComposite::GetPtData(vector> &vec) +{ + m_ObjContainer.GetObjPtData(vec,false); +} +//ȡrect Χе߶ +void CObjComposite::GetLineInRect(DbRect &rect,vector &DataPtLineVec,bool bGetCatchNode) +{ + m_ObjContainer.GetLineInRect(rect,DataPtLineVec,true); +} \ No newline at end of file diff --git a/LaipuDrawing/ObjComposite.h b/LaipuDrawing/ObjComposite.h new file mode 100644 index 0000000..908996c --- /dev/null +++ b/LaipuDrawing/ObjComposite.h @@ -0,0 +1,41 @@ +#pragma once +#include "ObjBase.h" +#include "ObjContainer.h" + +//϶ +class CObjComposite :public CObjBase +{ +public: + CObjComposite(void); + CObjComposite(CObjComposite &rhs); + virtual ~CObjComposite(void); + virtual CObjComposite * Clone(){return new CObjComposite(*this);}; + virtual CString GetStr(){return "϶";}; + virtual OBJ_TYPE GetType(){return _TYPE_COMPOSITE;}; + virtual void WriteWorkFileExt(vector &LabVec); + virtual void ReadWorkFileExt(CLabVecRang &LabVecRang); + + virtual void CreatExt(){}; + virtual void Draw(CDC* pDC,CPen &Pen); + virtual bool IsInRect(DbRect rect,bool bNeedAllIn); + virtual void SetSelected(bool bSelected); + virtual void Operate(SObjOperatePar &par); + virtual DbRect GetRect(); + virtual void GetPtData(vector> &vec); + virtual void GetLineInRect(DbRect &rect,vector &DataPtLineVec,bool bGetCatchNode = true); +public: + void AddPt(CDataPoint pt,bool bNewLine); + void Creat(); + void SetPosition(Dbxy pt);//û׼ +protected: + void UpdateSelState(); +private: + void SavePar(SObjOperatePar &par); +protected: + CObjContainer m_ObjContainer;//ģʽ + + Dbxy m_BasePt1;//object ǰλ + Dbxy m_BasePt2;//object ǰλ(ڼ¼ת) + double m_Distance;//ľ +}; + diff --git a/LaipuDrawing/ObjContainer.cpp b/LaipuDrawing/ObjContainer.cpp new file mode 100644 index 0000000..98102c3 --- /dev/null +++ b/LaipuDrawing/ObjContainer.cpp @@ -0,0 +1,1414 @@ +#include "StdAfx.h" +#include "ObjContainer.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" +#include "ObjPLine.h" +#include "ObjFactory.h" +#include "CommandBase.h" +#include "CStringFuc.h" +#include "WorkFileLable.h" +#include "WorkFileMgr.h" +#include "LogMgr.h" +#include "MsgBox.h" +#include "TemplateMgr.h" +#include "PenParMgr.h" +#include "Laser.h" +#include "ObjFillMgr.h" +#include "ProgramLaserTuiHuo.h" +#include "Layer.h" +#include "WaferRecipeDataMgr.h" +#include "RecipeMgr.h" +#include "FileMgr.h" + + + +#define OBJ_TXT_START "START" +#define OBJ_TXT_END "END" + +CObjContainer::CObjContainer(void) +{ +} +CObjContainer::~CObjContainer(void) +{ +} +#if 1 +void CObjContainer::WriteWorkFile(vector &LabVec) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsbFillObj()) + continue; + LabVec.push_back(CLab(LAB_OBJ_START)); + (*iter)->WriteWorkFile(LabVec); + LabVec.push_back(CLab(LAB_OBJ_END)); + } +} +void CObjContainer::ReadWorkFile(CLabVecRang &LabVecRang) +{ + //obj --------------------------------------------------- + vector LabVecRangVec; + CWorkFileMgr WorkFileMgr; + WorkFileMgr.SeparateStrVec(LabVecRang,LabVecRangVec,LAB_OBJ_START,LAB_OBJ_END); + //ÿobj --------------------------------------------------- + if(gTemplateMgr->IsbClearOldObj()) + { + Clear();//ԭobj + } + if(!LabVecRangVec.empty()) + { + vector::iterator iter = LabVecRangVec.begin(); + vector::iterator iter_end = LabVecRangVec.end(); + for(;iter!=iter_end;iter++) + { + //ȡobj + CLab ObjType= WorkFileMgr.FindLab((*iter),LAB_OBJ_TYPE); + if(ObjType.m_ValType != _TYPE_NULL) + { + OBJ_TYPE type = (OBJ_TYPE)(ObjType.m_Int); + if(type != _TYPE_BASE) + { + CObjFactory ObjFactory; + CObjBase *p = ObjFactory.CreatObj(type);//ָobj ʵ + if(p) + { + p->ReadWorkFile(*iter);//ָ + AddObject(p); + } + } + } + } + } +} +#endif +#if 1 +//obj Txt ļ +void CObjContainer::SaveObjToTxt(CString FilePath) +{ + ofstream FileStream; + FileStream.open(FilePath); + + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + OBJ_TYPE Type = (*iter)->GetType(); + if(!(Type==_TYPE_PLINE||Type==_TYPE_CIRCLE))//ֻ߶κԲ + continue; + vector&PtVec = (*iter)->GetPtContainer(); + int size = PtVec.size(); + if(size<4)//4 + continue; + FileStream<<"OBJ"<<","<> StrVec; + int EmptyLine = FileMgr.ReadFileToStrVec(FilePath,StrVec); + if(EmptyLine>0) + { + s.Format("ݸʽline = %d",EmptyLine); + MsgBox.Show(s); + return; + } + int size = StrVec.size(); + vector ObjPtVec; + + for(int k=0;kCreat(ObjPtVec[0],ObjPtVec[1]); + PtCnt = ObjPtVec.size(); + for(int i=2;iAddDataPoint(DataPoint); + } + AddObject(pLine); + } + else + { + Dbxy pt; + pt.x = CStringToDouble(StrVec[k][0]); + pt.y = CStringToDouble(StrVec[k][1]); + ObjPtVec.push_back(pt); + } + } + } +} +#endif +#if 1 +void CObjContainer::AddObject(CObjBase *pMarkObject) +{ + //浽ָ + Sptr sPtr(pMarkObject); + AddObject(sPtr); +} +void CObjContainer::AddObject(Sptr p) +{ + m_ObjVec.push_back(p); +} +//ӵ㵽ĩβobj +void CObjContainer::AddPtToLastObj(CDataPoint pt) +{ + if(!m_ObjVec.empty()) + { + m_ObjVec[m_ObjVec.size()-1]->AddDataPoint(pt); + } +} +//(Բ) +CMFCPropertyGridProperty *CObjContainer::CreatSpecialGridProperty(CModule *pModule) +{ + if(GetSelObjCnt() == 1)//ֻһʱ + { + return GetFirstSelObj()->CreatSpecialGridProperty(pModule); + } + else + return NULL; +} +//ӦԵı仯 +void CObjContainer::OnSpecialPropertyChanged() +{ + if(GetSelObjCnt() == 1)//ֻһʱ + { + GetFirstSelObj()->OnSpecialPropertyChanged(); + } +} +//б +void CObjContainer::InsertList(CListCtrl &List) +{ + int size = m_ObjVec.size(); + for(int i=0;iGetStr());// + } +} +#endif +#if 1// +void CObjContainer::DrawAllObj(CDC* pDC) +{ + //obj + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + int k = 1; + for(;iter!=iter_end;iter++,k++) + { + //˻вҪ + if(!gLayer.IsbDrawObj() && (*iter)->IsbFillObj()) + { + continue; + } + if((*iter)->IsbScaned())//ɨ + { + (*iter)->Draw(pDC,gDraw->GetScanLine()); + continue; + } + if((*iter)->IsSelected()) + { + (*iter)->Draw(pDC,gDraw->GetSelObjectPen()); + } + else + { + (*iter)->Draw(pDC); + } + } +} +//obj idx +void CObjContainer::DrawObjIdx(CDC* pDC) +{ + if(GetScanAreaCnt()<=1) + return; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + int k = 1; + int MarkIdx = 1; + for(;iter!=iter_end;iter++,k++) + { + if(!(*iter)->IsbFillObj()) + { + CString str; + str.Format(_T("%d"),k); + if(gDraw->IsbDrawObjIdxCenter()) + gDraw->DrawTxt(pDC,str,(*iter)->GetCenterPt()); + else + gDraw->DrawTxt(pDC,str,(*iter)->GetFirstPt()); + } + } +} +//ͼεĽڵ +void CObjContainer::DrawObjPtCoord(CDC* pDC) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected())//ֻѡͼ + { + (*iter)->DrawPtCoord(pDC); + } + } +} + +//mark ַ +void CObjContainer::DrawMarkIdx(CDC* pDC) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + int k = 1; + int MarkIdx = 1; + for(;iter!=iter_end;iter++,k++) + { + if((*iter)->IsbMarkPt()) + { + CString str; + str.Format(_T("Mark%d"),MarkIdx++); + gDraw->DrawTxt(pDC,str,(*iter)->GetFirstPt()); + } + if(MarkIdx>2) + break; + } +} + +void CObjContainer::DrawAllObj(CDC* pDC,CPen &Pen) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->Draw(pDC,Pen); + } +} + +void CObjContainer::XorRedrawObj(CDC* pDC,bool bNeedSel) +{ + int old_rop = pDC->SetROP2(R2_XORPEN); + //obj + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(bNeedSel) + { + if((*iter)->IsSelected()) + { + (*iter)->Draw(pDC,gDraw->GetSelObjectPen()); + } + } + else + { + (*iter)->Draw(pDC,gDraw->GetObjectPen()); + } + } + pDC->SetROP2(old_rop); +} +void CObjContainer::XorDrawLastObj(CDC* pDC) +{ + if(m_ObjVec.empty()==false) + { + int old_rop = pDC->SetROP2(R2_XORPEN); + m_ObjVec[m_ObjVec.size()-1]->Draw(pDC,gDraw->GetObjectPen()); + pDC->SetROP2(old_rop); + } +} +#endif +#if 1 +//Ƿѡobj +bool CObjContainer::HasObjSel() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()) + return true; + } + return false; +} +//ȡѡobj ĸ +int CObjContainer::GetSelObjCnt() +{ + int cnt = 0; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()) + cnt++; + } + return cnt; +} +//ȡobj () +int CObjContainer::GetScanAreaCnt() +{ + int cnt = 0; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(!(*iter)->IsbFillObj()) + { + cnt++; + } + } + return cnt; +} +//ȡɨ߶ε +int CObjContainer::GetScanLineCnt() +{ + int cnt = 0; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsbFillObj()) + { + cnt++; + } + } + return cnt; +} +bool CObjContainer::HasSelObjectInRect(DbRect rect) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected() && (*iter)->IsInRect(rect,false)) + return true; + } + return false; +} +//rect ǷѡĽڵ +bool CObjContainer::HasSelNodeInRect(DbRect rect) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()&&(*iter)->HasNodeInRect(rect)) + { + return true; + } + } + return false; +} +bool CObjContainer::HasObjectInRect(DbRect rect) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsInRect(rect,false)) + return true; + } + return false; +} +//ȡһѡobj +Sptr CObjContainer::GetFirstSelObj() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()) + { + return (*iter); + } + } + // + Sptr sp(NULL); + return sp; +} +Sptr CObjContainer::GetFirstObjInRect(DbRect &rect) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsInRect(rect,false)) + { + Sptr sp(*iter); + return sp; + } + } + // + Sptr sp(NULL); + return sp; +} +Sptr CObjContainer::GetFirstNodeObjInRect(DbRect &rect) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->HasNodeInRect(rect)) + { + Sptr sp(*iter); + return sp; + } + } + // + Sptr sp(NULL); + return sp; +} +DbRect CObjContainer::GetSelObjRect() +{ + DbRect SelObjRect; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()==false) + continue; + DbRect rect = (*iter)->GetRect(); + if(SelObjRect.IsZero()) + { + SelObjRect = rect; + } + else + { + AdjustRectByRect(SelObjRect,rect); + } + } + return SelObjRect; +} +//ȡObj ķΧ +DbRect CObjContainer::GetObjRect(bool bNeedSel) +{ + DbRect ObjRect; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(bNeedSel && (*iter)->IsSelected()==false) + continue; + DbRect rect = (*iter)->GetRect(); + if(ObjRect.IsZero()) + { + ObjRect = rect; + } + else + { + AdjustRectByRect(ObjRect,rect); + } + } + return ObjRect; +} +//ȡobj ľηΧ +DbRect CObjContainer::GetObjRect(int idx) +{ + DbRect ObjRect; + int size = m_ObjVec.size(); + if(CorrectIdx(idx)) + { + ObjRect = m_ObjVec[idx]->GetRect(); + } + return ObjRect; +} +//ѡrect ڵobj +bool CObjContainer::SelObjectInRect(DbRect rect,bool bNeedAllIn) +{ + bool ret = false; + int cnt = 0; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + Sptr p = (*iter); + if(p->IsInRect(rect,bNeedAllIn)) + { + p->SetSelected(true); + ret = true; + cnt++; + } + } + if(cnt>0) + { + CString LogStr; + LogStr.Format(_T("[Sel Obj Count] = [%d]"),cnt); + gLogMgr->WriteDebugLog(LogStr); + } + return ret; +} +//ȫѡ +void CObjContainer::SelAllObj() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->SetSelected(true); + } +} +void CObjContainer::NotSelAllObj() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->SetSelected(false); + } +} +//ѡ +void CObjContainer::RevSelAllObj() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()) + { + (*iter)->SetSelected(false); + } + else + { + (*iter)->SetSelected(true); + } + } +} +//ɾѡ +void CObjContainer::DelSelObj() +{ + vector> vec; + //ȱݷѡ + { + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected() == false) + { + vec.push_back(*iter); + } + } + } + //ɾobj + m_ObjVec.clear(); + //ѡobj + { + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + m_ObjVec.push_back(*iter); + } + } +} +//ɾָobj +void CObjContainer::DelObj(Sptr p) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).GetPtr() == p.GetPtr()) + { + m_ObjVec.erase(iter); + break; + } + } +} +//ɾһobj +void CObjContainer::DeleteLastObj() +{ + if(Empty()==false) + { + m_ObjVec.pop_back(); + } +} +//ɾ߶ +void CObjContainer::DelNullLine() +{ + vector> vec; + //ȱݷѡ + { + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->Empty() == false) + { + vec.push_back(*iter); + } + } + } + //ɾobj + m_ObjVec.clear(); + //ѡobj + { + vector>::iterator iter = vec.begin(); + vector>::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + m_ObjVec.push_back(*iter); + } + } +} +//ϲѡͼ +CObjBase* CObjContainer::JoinSelObj() +{ + //ʺϷڵһλobj --------------------------------------------------- + int size = m_ObjVec.size(); + int cnt = 0; + bool flg1; + bool flg2; + double eps =0.01;//ȽϾ + int idx=0; + int firstSelIdx = -1;//һѡobj + for(;idxIsSelected()) + { + if(firstSelIdx==-1) + { + firstSelIdx = idx; + } + flg1 = true; + flg2 = true; + for(int j=0;jIsSelected()&&j!=idx) + { + Dbxy FirstPt1 = m_ObjVec[idx]->GetFirstPt(); + Dbxy FirstPt2 = m_ObjVec[j]->GetFirstPt(); + Dbxy LastPt1 = m_ObjVec[idx]->GetLastPt(); + Dbxy LastPt2 = m_ObjVec[j]->GetLastPt(); + // + if(IsTwoPtEqual(FirstPt1,FirstPt2,eps) || IsTwoPtEqual(FirstPt1,LastPt2,eps)) + { + flg1 = false; + } + if(IsTwoPtEqual(LastPt1,FirstPt2,eps) || IsTwoPtEqual(LastPt1,LastPt2,eps)) + { + flg2 = false; + } + } + } + if(flg1 || flg2)//ҵ + { + break; + } + } + } + if(flg1 && flg2)//˶ûкobjӣܺϲ + return NULL; + if(firstSelIdx==-1) + return NULL; + if(!flg1 && !flg2)//ѡobj Ϊպ״̬Եһѡobj ʼ + { + idx= flg1; + } + //ϲobj ------------------------------------------ + bool bReverse = false; + if(flg2) + { + bReverse = true; + } + CObjPline *p = new CObjPline; + p->AddObj(m_ObjVec[idx],bReverse);//һobj + set Set;//жЩѾ + Set.insert(idx); + + Dbxy ConectPt = p->GetLastPt();//ǰӵ + for(int i=0;iIsSelected()&&Set.count(j)==false)//ûѡobj + { + if(IsTwoPtEqual(ConectPt,m_ObjVec[j]->GetFirstPt(),eps))// + { + p->AddObj(m_ObjVec[j],false); + Set.insert(j);// + ConectPt = m_ObjVec[j]->GetLastPt(); + } + else if(IsTwoPtEqual(ConectPt,m_ObjVec[j]->GetLastPt(),eps))// + { + p->AddObj(m_ObjVec[j],true); + Set.insert(j);// + ConectPt = m_ObjVec[j]->GetFirstPt(); + } + } + } + } + //Ƿѡobj ûбϲ + bool flg = false; + for(int i=0;iIsSelected()&&Set.count(i)==false) + { + flg = true; + break; + } + } + + //Уʾܺϲ + if(flg) + { + delete p; + p = NULL; + } + return p; +} +//õǰidx ڵֵΪpt +void CObjContainer::SetNodePtByIdx(int idx,Dbxy pt) +{ + if(Empty()) + return; + m_ObjVec[0]->SetNodePtByIdx(idx,pt); +} + +#endif +#if 1 +//ѡobj +//bNeedSel ʾҪΪѡ״̬Ų +//bTmpOp ʾǷΪʱ +void CObjContainer::OperateObj(SObjOperatePar &par,bool bNeedSel) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(bNeedSel==false || (bNeedSel && (*iter)->IsSelected())) + { + (*iter)->Operate(par); + } + } +} +//һobj +void CObjContainer::OperateLastObj(SObjOperatePar &par) +{ + if(m_ObjVec.empty()==false) + { + m_ObjVec[m_ObjVec.size()-1]->Operate(par); + } +} +#endif +#if 1// +void CObjContainer::GetLineInRect(DbRect &rect,vector &DataPtLineVec,bool bCatchTemp) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + //Ҫ׽ʱĹΪѡĶҲʱ + if(bCatchTemp==false&&(*iter)->IsSelected()) + continue; + (*iter)->GetLineInRect(rect,DataPtLineVec); + } +} +//m_ObjVec obj rhs +void CObjContainer::CloneObj(CObjContainer &rhs,bool bNeedSel) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(!bNeedSel ||(bNeedSel && (*iter)->IsSelected())) + { + CObjBase *p = (*iter)->Clone(); + rhs.AddObject(p); + } + } +} +//ȡline ཻн㵽PointVec +void CObjContainer::GetIntersectPoint(DbLine &line,vector &PointVec) +{ + +} +//Ƿobj line ཻ +bool CObjContainer::HasObjIntersectWithLine(DbLine &line) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IntersectWithLine(line)) + { + return true; + } + } + return false; +} +#endif +#if 1 +//obj ָ +void CObjContainer::AddObjToCmd(CCommandBase *p,bool bNeedSel) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(bNeedSel) + { + if((*iter)->IsSelected()) + p->AddOpObj((*iter)); + } + else + { + p->AddOpObj((*iter)); + } + } +} +//obj 뵱ǰlayer +void CObjContainer::AllObjAddToLayer() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + gLayer.AddObject(*iter); + } +} +//Լеobj rhs +void CObjContainer::AllObjAddToContainer(CObjContainer &rhs,bool bNeedSel) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(bNeedSel) + { + if((*iter)->IsSelected()) + rhs.AddObject(*iter); + } + else + { + rhs.AddObject(*iter); + } + } +} +void CObjContainer::AllObjAddToLayerTmp() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + gLayer.AddTmpObject(*iter); + } +} + +//ȡǰһobj ָ(ɴtool ʹ) +CObjBase *CObjContainer::GetCurOpObj() +{ + if(m_ObjVec.empty()) + return NULL; + else + return m_ObjVec[m_ObjVec.size()-1].GetPtr(); +} +#endif +#if 1//group غ +bool CObjContainer::IsInRect(DbRect rect,bool bNeedAllIn) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsInRect(rect,bNeedAllIn)) + return true; + } + return false; +} +void CObjContainer::SetSelected(bool bSelected) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->SetSelected(bSelected); + } +} +//idx Ϊ-1 ʱȫ +void CObjContainer::Operate(SObjOperatePar &par,int idx) +{ + if(idx==-1) + { + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->Operate(par); + } + } + else + { + if(CorrectIdx(idx)) + { + m_ObjVec[idx]->Operate(par); + } + } +} +bool CObjContainer::CorrectIdx(int idx) +{ + int size = m_ObjVec.size(); + if(0<=idx && idx>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()) + { + (*iter)->BindingDlg(); + break; + } + } + } +} +#endif +#if 1 +//ȡobj ()vec (ϲ߶) +void CObjContainer::GetObjPtData(vector> &vec,bool bNeedSel) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsbScaned())//˵ɨline + continue; + if(!bNeedSel || (bNeedSel && (*iter)->IsSelected())) + { + (*iter)->GetPtData(vec); + } + } +} +//ȡobj ݵvec +void CObjContainer::GetObjFillData(vector> &vec,bool bNeedSel) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if(!bNeedSel || (bNeedSel && (*iter)->IsSelected())) + { + (*iter)->GetFillData(vec); + } + } +} + +//ҵе󣬲굽vec +void CObjContainer::GetOnePoint(vector &vec) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->GetType()==_TYPE_POINT) + { + Dbxy pt = (*iter)->GetFirstPt(); + vec.push_back(pt); + } + } +} +#endif +// +void CObjContainer::FillObj(SFillPar &FillPar,bool bNeedSel) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + int idx = 0; + for(;iter!=iter_end;iter++,idx++) + { + if(bNeedSel && (*iter)->IsSelected()==false) + continue; + CRecipeParameter RecipePar; + if(gLaser->IsbScanByDirX()) + RecipePar = gRecipeMgr->GetCurRecipePar(RECIPE_PAR_NAME_OVERLAP_RATIO_Y); + else + RecipePar = gRecipeMgr->GetCurRecipePar(RECIPE_PAR_NAME_OVERLAP_RATIO_X); + + double ScanOverlapRatio = RecipePar.m_ParDoubleVal;//Y ص + SCAN_TRACK_E ScanTrack = gObjFillMgr.GetCurScanType(); + bool bhorizontal = false; + if(ScanTrack == _SCAN_TRACK_S_U_D || ScanTrack == _SCAN_TRACK_S_D_U|| ScanTrack == _SCAN_TRACK_L_R|| ScanTrack == _SCAN_TRACK_R_L) + { + bhorizontal = true; + FillPar.m_FillAngle = 0; + } + else if(ScanTrack == _SCAN_TRACK_S_L_R || ScanTrack == _SCAN_TRACK_S_R_L|| ScanTrack == _SCAN_TRACK_U_D|| ScanTrack == _SCAN_TRACK_D_U) + { + FillPar.m_FillAngle = 90; + } + //ͨصʺ͹ֱɨmm (bhorizontal Ƿ) + FillPar.m_FillGap = gLaser->GetScanIntervals(ScanOverlapRatio,bhorizontal); + (*iter)->CreatFillData(FillPar); + } +} +//ȡеĵ +void CObjContainer::GetAllPointObjPt(vector &PtVec) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->GetType()==_TYPE_POINT) + { + PtVec.push_back(((*iter)->GetRect()).GetCenterPt()); + } + } +} +//ѡobj ıʺ +void CObjContainer::SetSelObjPenNum(int num) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()) + { + int CurPenNum = (*iter)->GetPenNum(); + if(!gPenParMgr->IsSpecialPen(CurPenNum))//ܸıʺŵĶ + (*iter)->SetPenNum(num); + } + } +} +//ͨʺѡobj +void CObjContainer::SelObjByPenNum(int num) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + int CurPenNum = (*iter)->GetPenNum(); + if(CurPenNum == num) + { + (*iter)->SetSelected(true); + } + else + { + (*iter)->SetSelected(false); + } + } +} +#if 1 +//ѡڵobj (bNext == true һ) +void CObjContainer::SelborderObj(bool bNext) +{ + if(GetSelObjCnt()!=1) + { + CMsgBox MsgBox; + MsgBox.Show("ֻѡһobj !"); + return; + } + int size = m_ObjVec.size(); + for(int i=0;iIsSelected()) + { + if(bNext && i+1SetSelected(false); + m_ObjVec[i+1]->SetSelected(true); + } + if(!bNext && i-1>=0) + { + m_ObjVec[i]->SetSelected(false); + m_ObjVec[i-1]->SetSelected(true); + } + break; + } + } +} +//ѡobj 뵽idx ָλ +void CObjContainer::SelectedObjInsertToIdx(int idx) +{ + int size = m_ObjVec.size(); + if(idx<1 || idx>size) + { + return; + } + vector> ObjVecTmp;//ʱ + int k = 1; + //ҵidx-1 ûѡobj ʱ + for(int i=0;iIsSelected()) + { + if(k>=idx) + { + k = i;//סλ + break; + } + k++; + ObjVecTmp.push_back(m_ObjVec[i]); + } + } + //ѡobj μ + for(int i=0;iIsSelected()) + { + ObjVecTmp.push_back(m_ObjVec[i]); + } + } + //ʣûѡobj ηں + for(int i=k;iIsSelected()) + { + ObjVecTmp.push_back(m_ObjVec[i]); + } + } + //ԭ + m_ObjVec = ObjVecTmp; +} +//ѡobj +void CObjContainer::ReverseSelObj() +{ + int size = m_ObjVec.size(); + int L = 0; + int R = size-1; + while(LIsSelected()) + break; + L++; + } + while(LIsSelected()) + break; + R--; + } + if(LSetSelected(true); + } + else + { + m_ObjVec[i]->SetSelected(false); + } + } +} +int CObjContainer::GetMarkObjCnt() +{ + int cnt = 0; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsbMarkPt()) + cnt++; + } + return cnt; +} +void CObjContainer::ResetAllMarkObj() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->SetbMarkPt(false); + } +} +void CObjContainer::ResetAllCollectedState() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->SetbCollected(false); + } +} +//ȡѡıʺ +int CObjContainer::GetSelObjPenNum() +{ + if(GetSelObjCnt()!=1) + { + return -1; + } + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()) + { + return (*iter)->GetPenNum(); + } + } + return -1; +} +#endif +//˳ѡһobj +void CObjContainer::SelObjByIdx(int idx) +{ + int k=0; + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++,k++) + { + (*iter)->SetSelected(false); + if(k==idx) + (*iter)->SetSelected(true); + } +} +//ѡ +void CObjContainer::SelAllFillObj() +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsbFillObj()) + (*iter)->SetSelected(true); + } +} +//ɾĶ +void CObjContainer::DelAllFillObj() +{ + //ȫѡ + NotSelAllObj(); + //ѡ + SelAllFillObj(); + //ɾѡ + DelSelObj(); +} +//ͨһӦCheck Vec obj ѡ״̬ +void CObjContainer::SelObjByIdxVec(vector &vec) +{ + int size1 = m_ObjVec.size(); + int size2 = vec.size(); + for(int k=0;kSetSelected(vec[k]); + } + else + { + m_ObjVec[k]->SetSelected(false); + } + } +} +//ӹʼǰobj ɨ״̬ +void CObjContainer::SetObjScanState(int ScanedLineCnt) +{ + int FillObjCnt = 0; + int size1 = m_ObjVec.size(); + for(int k=0;kSetbScaned(false); + if(ScanedLineCnt>0) + { + if(m_ObjVec[k]->IsbFillObj() && FillObjCntSetbScaned(true); + FillObjCnt++; + } + } + } +} +//Ƿбɨline +bool CObjContainer::HasScanedLine() +{ + int size1 = m_ObjVec.size(); + for(int k=0;kIsbScaned()) + return true; + } + return false; +} +//Ƿɨ +bool CObjContainer::HasScanLine() +{ + int size1 = m_ObjVec.size(); + for(int k=0;kIsbFillObj()) + return true; + } + return false; +} +//ݵʱڰ뾶R ķΧ +bool CObjContainer::CheckPtRadius(double R) +{ + vector>::iterator iter = m_ObjVec.begin(); + vector>::iterator iter_end = m_ObjVec.end(); + for(;iter!=iter_end;iter++) + { + OBJ_TYPE Type = (*iter)->GetType(); + if(!(Type==_TYPE_PLINE||Type==_TYPE_CIRCLE))//ֻ߶κԲ + return false; + vector&PtVec = (*iter)->GetPtContainer(); + int size = PtVec.size(); + for(int k=0;kR) + return false; + } + } + return true; +} + diff --git a/LaipuDrawing/ObjContainer.h b/LaipuDrawing/ObjContainer.h new file mode 100644 index 0000000..3ec377d --- /dev/null +++ b/LaipuDrawing/ObjContainer.h @@ -0,0 +1,106 @@ +#pragma once +#include "SmartPtr.h" +#include "GlobalDefine.h" +#include "ObjBase.h" +#include "Subject.h" +#include "LabVecRang.h" + +class CCommandBase; + +//obj +class CObjContainer +{ +public: + CObjContainer(void); + ~CObjContainer(void); + void AddObject(CObjBase *pMarkObject); + void AddObject(Sptr p); + void AddPtToLastObj(CDataPoint pt); + void DrawAllObj(CDC* pDC); + void DrawAllObj(CDC* pDC,CPen &Pen); + void XorRedrawObj(CDC* pDC,bool bNeedSel); + void XorDrawLastObj(CDC* pDC); + bool HasSelObjectInRect(DbRect rect); + bool HasSelNodeInRect(DbRect rect); + bool SelObjectInRect(DbRect rect,bool bNeedAllIn); + void SelAllObj(); + bool HasObjSel(); + void NotSelAllObj(); + void RevSelAllObj(); + void DelSelObj(); + void DelObj(Sptr p); + DbRect GetSelObjRect(); + void OperateObj(SObjOperatePar &par,bool bAll); + void GetLineInRect(DbRect &rect,vector &DataPtLineVec,bool bCatchTemp); + void CloneObj(CObjContainer &rhs,bool bNeedSel); + void AllObjAddToContainer(CObjContainer &rhs,bool bNeedSel); + void AddObjToCmd(CCommandBase *p,bool bNeedSel); + void SetNodePtByIdx(int idx,Dbxy pt); + bool Empty(){return m_ObjVec.empty();}; + void Clear(){m_ObjVec.clear();}; + vector> &GetObjVec(){return m_ObjVec;}; + void AllObjAddToLayer(); + CObjBase *GetCurOpObj(); + void DeleteLastObj(); + void OperateLastObj(SObjOperatePar &par); + Sptr GetFirstObjInRect(DbRect &rect); + Sptr GetFirstNodeObjInRect(DbRect &rect); + bool HasObjectInRect(DbRect rect); + void GetIntersectPoint(DbLine &line,vector &PointVec); + bool HasObjIntersectWithLine(DbLine &line); + void AllObjAddToLayerTmp(); + void AllObjCombToPline(); + CObjBase* JoinSelObj(); + void DelNullLine(); + DbRect GetObjRect(bool bNeedSel); + DbRect GetObjRect(int idx); + bool IsInRect(DbRect rect,bool bNeedAllIn); + void SetSelected(bool bSelected); + void Operate(SObjOperatePar &par,int idx= -1); + int GetSize(){return m_ObjVec.size();}; + void BindingDlg(); + int GetSelObjCnt(); + int GetObjCnt(){return m_ObjVec.size();}; + void FillObj(SFillPar &FillPar,bool bNeedSel); + void GetOnePoint(vector &vec); + CMFCPropertyGridProperty *CreatSpecialGridProperty(CModule *pModule); + void OnSpecialPropertyChanged(); + Sptr GetFirstSelObj(); + void InsertList(CListCtrl &List); + void WriteWorkFile(vector &LabVec); + void ReadWorkFile(CLabVecRang &LabVecRang); + void GetAllPointObjPt(vector &PtVec); + void SetSelObjPenNum(int num); + void SelborderObj(bool bNext); + void DrawObjIdx(CDC* pDC); + void DrawObjPtCoord(CDC* pDC); + void SelectedObjInsertToIdx(int idx); + void ReverseSelObj(); + void SelFirstObj(); + void DrawMarkIdx(CDC* pDC); + void ResetAllMarkObj(); + void ResetAllCollectedState(); + int GetSelObjPenNum(); + int GetScanAreaCnt(); + void SelObjByIdx(int idx); + void DelAllFillObj(); + void SelAllFillObj(); + void SelObjByIdxVec(vector &vec); + void SetObjScanState(int ScanedLineCnt); + bool HasScanedLine(); + bool HasScanLine(); + void SelObjByPenNum(int num); + int GetScanLineCnt(); + void GetObjPtData(vector> &vec,bool bNeedSel); + void GetObjFillData(vector> &vec,bool bNeedSel); + void SaveObjToTxt(CString FilePath); + void ReadObjFromTxt(CString FilePath); + bool CheckPtRadius(double R); +private: + bool CorrectIdx(int idx); + int GetMarkObjCnt(); +private: + vector> m_ObjVec;//obj + +}; + diff --git a/LaipuDrawing/ObjFactory.cpp b/LaipuDrawing/ObjFactory.cpp new file mode 100644 index 0000000..1982c75 --- /dev/null +++ b/LaipuDrawing/ObjFactory.cpp @@ -0,0 +1,66 @@ +#include "StdAfx.h" +#include "ObjFactory.h" +#include "ObjCircle.h" +#include "ObjPline.h" +#include "ObjComposite.h" +#include "ObjPoint.h" +#include "ObjArc.h" + + + +CObjFactory::CObjFactory(void) +{ +} +CObjFactory::~CObjFactory(void) +{ +} +CObjBase *CObjFactory::CreatObj(OBJ_TYPE type) +{ + CObjBase *p = NULL; + switch(type) + { + case _TYPE_PLINE: + p = new CObjPline; + break; + case _TYPE_CIRCLE: + p = new CObjCircle; + break; + case _TYPE_COMPOSITE: + p = new CObjComposite; + break; + case _TYPE_POINT: + p = new CObjPoint; + break; + case _TYPE_ARC: + p = new CObjArc; + break; + default: + break; + } + return p; +} + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/LaipuDrawing/ObjFactory.h b/LaipuDrawing/ObjFactory.h new file mode 100644 index 0000000..d1bbb59 --- /dev/null +++ b/LaipuDrawing/ObjFactory.h @@ -0,0 +1,11 @@ +#pragma once +#include "ObjBase.h" + +class CObjFactory +{ +public: + CObjFactory(void); + ~CObjFactory(void); + CObjBase *CreatObj(OBJ_TYPE type); +}; + diff --git a/LaipuDrawing/ObjFill.cpp b/LaipuDrawing/ObjFill.cpp new file mode 100644 index 0000000..7f67925 --- /dev/null +++ b/LaipuDrawing/ObjFill.cpp @@ -0,0 +1,180 @@ +#include "StdAfx.h" +#include "ObjFill.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +#include "LogMgr.h" + +#define MAX_FILL_LINE_LEN 500 //䷶Χ + +CObjFill::CObjFill(vector &Vec) +:m_SequentialPointVec(Vec) +{ +} +CObjFill::~CObjFill(void) +{ +} +//obj ݵ +void CObjFill::CreatFill(vector> &LinesVec,DbRect rect) +{ + if(m_FillPar.bFill ==false) + return; + + Dbxy Pt1,Pt2,Offset; + int ScanTimes = 0; + //ȡɨ(Pt1,Pt2ǵһ),ɨߵĴ + GetScanLine(rect,Pt1,Pt2,Offset,ScanTimes); + //һ㣬չ˵һ + Pt1.x -= Offset.x/2; + Pt2.x -= Offset.x/2; + Pt1.y -= Offset.y/2; + Pt2.y -= Offset.y/2; + + //һߣ֤֮ļһ + + + for(int i=0;i IntersectionVec; + if(GetIntersection(LinesVec,Pt1,Pt2,IntersectionVec,rect)) + { + //ԼĽ + SortIntersection(IntersectionVec); + //ɨ + SaveScanResult(IntersectionVec); + } + //ɨƫ + Pt1.x += Offset.x; + Pt1.y += Offset.y; + Pt2.x += Offset.x; + Pt2.y += Offset.y; + } +} +#if 1// +//ȡɨ(ScanTimes ɨƫƵĴ) +void CObjFill::GetScanLine(DbRect rect,Dbxy &Pt1,Dbxy &Pt2,Dbxy &Offset,int &ScanTimes) +{ + //һ㹻߶ + double R = MAX_FILL_LINE_LEN;//ķΧ + Dbxy CenterPt(rect.L,rect.T); + Pt1.y = Pt2.y = rect.T; + Pt1.x = rect.L-R; + Pt2.x = rect.R+R; + double FillGap = m_FillPar.m_FillGap;// + + Dbxy Pt(Pt1.x,Pt1.y-FillGap);//ɨÿεƫ + //תɨ + double Angle = _360ToAngle(m_FillPar.m_FillAngle); + Pt1 = RotatoPt(Pt1,Angle,CenterPt); + Pt2 = RotatoPt(Pt2,Angle,CenterPt); + Pt = RotatoPt(Pt,Angle,CenterPt); + + double len = CalDistance(Dbxy(rect.L,rect.T),Dbxy(rect.R,rect.B)); + ScanTimes = len/FillGap; + //ÿɨߵƫ + Offset.x = Pt.x - Pt1.x; + Offset.y = Pt.y - Pt1.y; +} +//߶κpt1,pt2 ߶εĽ(浽IntersectionVec) +//Ҫrect Χ +bool CObjFill::GetIntersection(vector> &LinesVec,Dbxy pt1,Dbxy pt2,vector &IntersectionVec,DbRect rect) +{ + IntersectionVec.clear(); + if(pt1.x>3.66 && pt1.x<4.44) + { + int a = 0; + } + vector>::iterator iter = LinesVec.begin(); + vector>::iterator iter_end = LinesVec.end(); + for(;iter!=iter_end;iter++) + { + int size = (*iter).size(); + for(int i=0;i7.974 && u1.x<7.976)&&(u2.x>4.04 && u2.x<4.06)) + { + int a=0; + } + //Ƕ˵ + if(dot_online_in(u1,pt1,pt2) && dot_online_in(u2,pt1,pt2))//㶼pt1,pt2 + { + //ɨ΢سһһ,˵ + double offset = 0.0001; + pt1.x -= offset; + pt2.x -= offset; + pt1.y -= offset; + pt2.y -= offset; + //ݹ麯(ע) + return GetIntersection(LinesVec,pt1,pt2,IntersectionVec,rect); + } + else if(dot_online_in(u1,pt1,pt2))//һpt1,pt2 + { + continue; + } + else if(dot_online_in(u2,pt1,pt2))//ڶpt1,pt2 + { + //һ߶εĵڶһʱ㽻 + if((i+2) &IntersectionVec) +{ + if(m_FillPar.m_FillAngle<=45) + { + sort(IntersectionVec.begin(),IntersectionVec.end(),CompareDbxyByX); + } + else + { + sort(IntersectionVec.begin(),IntersectionVec.end(),CompareDbxyByY); + } +} +//ɨ +void CObjFill::SaveScanResult(vector &IntersectionVec) +{ + int size = IntersectionVec.size(); + int idx = 1; + for(int i=1;i &Vec); + virtual ~CObjFill(void); + void CreatFill(vector> &PtVec,DbRect rect); + void SetPar(SFillPar Par){m_FillPar = Par;}; +private: + void FillCloseArea(vector &PtVec,Dbxy pt1,Dbxy pt2,Dbxy Offset,int ScanTimes,DbRect rect); + void GetScanLine(DbRect rect,Dbxy &Pt1,Dbxy &Pt2,Dbxy &Offset,int &ScanTimes); + void SortIntersection(vector &IntersectionVec); + void SaveScanResult(vector &IntersectionVec); + bool GetIntersection(vector> &LinesVec,Dbxy pt1,Dbxy pt2,vector &IntersectionVec,DbRect rect); +private: + vector &m_SequentialPointVec;//һ߶ε + SFillPar m_FillPar;// +}; + diff --git a/LaipuDrawing/ObjFillMgr.cpp b/LaipuDrawing/ObjFillMgr.cpp new file mode 100644 index 0000000..c646548 --- /dev/null +++ b/LaipuDrawing/ObjFillMgr.cpp @@ -0,0 +1,362 @@ +#include "StdAfx.h" +#include "ObjFillMgr.h" +#include "CommandArray.h" +#include "CommandMgr.h" +#include "Layer.h" +#include "MsgBox.h" +#include "ObjPline.h" +#include "FileMgr.h" +#include "PenParMgr.h" +#include "Laser.h" +#include "ProgramLaserTuiHuo.h" +#include "WaferRecipeDataMgr.h" +#include "RecipeMgr.h" +#include "WorkRecord.h" +#include "LogMgr.h" + +#if 1 +CObjFillMgr gObjFillMgr; +CObjFillMgr::CObjFillMgr(void) +{ + m_FillOffset = 1;//mm + m_FillAngle = 90;//Ƕ(360 ) + m_bDelEdgeObj = false;//Ƿɾobj + m_bCreatConnectLine = true;//Ƿ񴴽 + m_CurScanType = _SCAN_TRACK_S_L_R;//ǰɨ跽ʽ + m_StartFillIdx = 0;//ӵڼ߿ʼ +} +CObjFillMgr::~CObjFillMgr(void) +{ +} +//ɨ跽ʽ +void CObjFillMgr::UpdateCurScanType() +{ + int WaferScanType = gProgramLaserTuiHuo->GetWaferScanType(); + if(WaferScanType>=0&&WaferScanType<8) + { + m_CurScanType = (SCAN_TRACK_E)WaferScanType; + CString log; + log.Format("Func--->UpdateCurScanType = %ld",WaferScanType); + gLogMgr->WriteDebugLog(log); + } +} +//ѡ +void CObjFillMgr::FillAllSelObj() +{ + //obj ת90 (Ϊɺɨ) + if(gLaser->IsbScanByDirX()) + gLayer.Rotato(90); + //ɨ跽ʽ + UpdateCurScanType(); + //ʼ + m_ObjContainer.Clear(); + m_ScanLineVec.clear(); + //ͨobj ɨ(m_ScanLineVec) + if(!CreatScanLineByObjFill()) + return; + //ͨɨobj + CreatObjByScanLine(); + //ӵlayer + FillObjAddToLayer(); + + //obj ת90 + if(gLaser->IsbScanByDirX()) + gLayer.Rotato(-90); +} +void CObjFillMgr::FillObjAddToLayer() +{ + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + m_ObjContainer.AllObjAddToContainer(ObjContainer,false); +} +//Ϊidx obj +void CObjFillMgr::FillAllSelObjByIdx(int idx) +{ + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + ObjContainer.NotSelAllObj(); + +} +//ָ +void CObjFillMgr::CreatCmd() +{ + if(!m_ObjContainer.Empty()) + { + //ָ-------start + CCommandArray *pCmd = new CCommandArray; + gCommandMgr.AddUndoCommand(pCmd,m_ObjContainer.GetObjVec()); + //ɾobj + if(m_bDelEdgeObj) + { + pCmd->SaveBaseObj(gLayer.GetObjContainer()); + } + //ָ-------end + pCmd->Excute(); + } +} +// +void CObjFillMgr::CreatObjFillData(CObjContainer &ObjContainer) +{ + SFillPar FillPar; + FillPar.m_FillAngle = m_FillAngle; + FillPar.bFill = true; + FillPar.m_FillGap = m_FillOffset; + ObjContainer.FillObj(FillPar,false); +} +//ͨobj ɨ +bool CObjFillMgr::CreatScanLineByObjFill() +{ + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + // + CreatObjFillData(ObjContainer); + //obj 㷨----------------------------- + vector> &ObjVec = ObjContainer.GetObjVec(); + vector>::iterator iter = ObjVec.begin(); + vector>::iterator iter_end = ObjVec.end(); + int idx = 0; + + bool bNeedCloseLaser = true;//ɨ費ͬǷҪرռ + + vector ScanLineVecTmp; + for(;iter!=iter_end;iter++,idx++) + { + ScanLineVecTmp.clear(); + int CurPenNum = idx;//ʺΪobj к + if(!(*iter)->IsbFillObj() && (*iter)->IsSelected())//˵obj + { + vector> FillDataVec; + (*iter)->GetFillData(FillDataVec); + bool DirFlg = false;//ʾ + vector>::iterator iter1 = FillDataVec.begin(); + vector>::iterator iter1_end = FillDataVec.end(); + for(;iter1!=iter1_end;iter1++) + { + int size = (*iter1).size(); + int idx1 = (DirFlg)?1:0; + int idx2 = (DirFlg)?0:1; + DirFlg = !DirFlg;// + + Dbxy pt1 = (*iter1)[idx1]; + Dbxy pt2 = (*iter1)[idx2]; + if(size==2) + { + CScanLine ScanLine(pt1,pt2);//һ + ScanLine.SetPenNum(CurPenNum); + ScanLineVecTmp.push_back(ScanLine); + } + } + + //S -µϣҵҪ + SCAN_TRACK_E ScanTrack = m_CurScanType; + if(ScanTrack == _SCAN_TRACK_S_D_U ||ScanTrack == _SCAN_TRACK_S_R_L) + { + reverse(ScanLineVecTmp.begin(),ScanLineVecTmp.end()); + } + + vector::iterator iter2 = ScanLineVecTmp.begin(); + vector::iterator iter2_end = ScanLineVecTmp.end(); + bool bFirst = true;//ǵһline + for(;iter2!=iter2_end;iter2++) + { + if(bFirst && bNeedCloseLaser) + { + (*iter2).SetbFirstLine(); + bFirst = false; + } + m_ScanLineVec.push_back(*iter2); + } + } + } + if(!m_ScanLineVec.empty()) + { + m_ScanLineVec[0].SetbFirstLine();//һǿ + } + //ɨߣʹɨ·ԸǵԲ + AdjustScanLine1(); + + // + SFillPar FillPar; + FillPar.bFill = false; + ObjContainer.FillObj(FillPar,false); + + return true; +} +//ɨߣʹɨ·ԸǵԲ +void CObjFillMgr::AdjustScanLine1() +{ + vector::iterator iter = m_ScanLineVec.begin(); + vector::iterator iter_end = m_ScanLineVec.end(); + for(;iter!=iter_end;iter++) + { + Dbxy StartPt = (*iter).GetStartPt(); + Dbxy EndPt = (*iter).GetEndPt(); + + Dbxy pt1 = StartPt; + Dbxy pt2 = StartPt; + Dbxy pt3 = EndPt; + Dbxy pt4 = EndPt; + + int PenNum = (*iter).GetPenNum(); + double FillAngle; + GetAngle(FillAngle,PenNum); + if(FillAngle>0) + { + if(pt1.y>pt3.y) + { + ScanLineCoverWafer(pt1,pt2,true,PenNum); + ScanLineCoverWafer(pt3,pt4,false,PenNum); + } + else + { + ScanLineCoverWafer(pt3,pt4,true,PenNum); + ScanLineCoverWafer(pt1,pt2,false,PenNum); + } + + StartPt.y = pt1.y; + EndPt.y = pt3.y; + } + else + { + if(pt1.x>pt3.x) + { + ScanLineCoverWafer(pt1,pt2,true,PenNum); + ScanLineCoverWafer(pt3,pt4,false,PenNum); + } + else + { + ScanLineCoverWafer(pt3,pt4,true,PenNum); + ScanLineCoverWafer(pt1,pt2,false,PenNum); + } + StartPt.x = pt1.x; + EndPt.x = pt3.x; + } + + (*iter).SetStartPt(StartPt); + (*iter).SetEndPt(EndPt); + } +} +//ɨ߸סԲbDir ǵ +void CObjFillMgr::ScanLineCoverWafer(Dbxy &pt1,Dbxy &pt2,bool bDir,int PenNum) +{ + //Ե + + double Offset = 0; + if(Offset<=0)//0 ѭ + Offset = 0.05; + + if(!bDir) + Offset*=-1; + + double FillAngle; + GetAngle(FillAngle,PenNum); + + while(gLayer.HasObjIntersectWithLine(DbLine(CDataPoint(pt1),CDataPoint(pt2)))) + { + //ֻԾԲԵĵе + if(FillAngle>0) + { + pt1.y += Offset; + pt2.y += Offset; + } + else + { + pt1.x += Offset; + pt2.x += Offset; + } + + } +} + +//ÿһеend ,һеstart Ƚ,ȡX Ϊ뾧ԲԶĵ +void CObjFillMgr::AdjustScanLine2() +{ + int size = m_ScanLineVec.size(); + for(int i=0;i0)?(&(EndPt.y)):(&(EndPt.x)); + double *pVal2 = (FillAngle>0)?(&(NextStartPt.y)):(&(NextStartPt.x)); + + if(abs(*pVal1)GetCurScanState(); + //int EndScanLineIdx = ScanState.m_EndScanLineIdx; + + int size = m_ScanLineVec.size(); + Dbxy PerPt; + int ScanLineIdx = 0; + for(int i=0;i EndPt.y) + swap(StartPt,EndPt); + } + if(ScanTrack == _SCAN_TRACK_R_L)//ɨ- + { + if(StartPt.x < EndPt.x) + swap(StartPt,EndPt); + } + if(ScanTrack == _SCAN_TRACK_L_R)//ɨ-ҵ + { + if(StartPt.x > EndPt.x) + swap(StartPt,EndPt); + } + //bool bScaned = (EndScanLineIdx>0 && ScanLineIdx<=EndScanLineIdx); + bool bScaned = false; + PerPt = EndPt; + CObjPline *pObjPline = new CObjPline; + pObjPline->SetbFillObj(true);//Ϊ + pObjPline->SetPenNum(m_ScanLineVec[i].GetPenNum()); + pObjPline->Creat(StartPt,EndPt); + //DZɨ߶ + pObjPline->SetbScaned(bScaned); + if(ScanLineIdx>=m_StartFillIdx) + m_ObjContainer.AddObject(pObjPline); + + //ɨ߶ + ScanLineIdx++; + } +} +//ɨģʽȡǶȣǷɨ +bool CObjFillMgr::GetAngle(double &Angle,int PenNum) +{ + SCAN_TRACK_E ScanTrack = m_CurScanType; + bool bhorizontal = false; + if(ScanTrack == _SCAN_TRACK_S_U_D || ScanTrack == _SCAN_TRACK_S_D_U|| ScanTrack == _SCAN_TRACK_L_R|| ScanTrack == _SCAN_TRACK_R_L) + { + bhorizontal = true; + Angle = 0; + } + else if(ScanTrack == _SCAN_TRACK_S_L_R || ScanTrack == _SCAN_TRACK_S_R_L|| ScanTrack == _SCAN_TRACK_U_D|| ScanTrack == _SCAN_TRACK_D_U) + { + Angle = 90; + } + return bhorizontal; +} +#endif diff --git a/LaipuDrawing/ObjFillMgr.h b/LaipuDrawing/ObjFillMgr.h new file mode 100644 index 0000000..42f2ac8 --- /dev/null +++ b/LaipuDrawing/ObjFillMgr.h @@ -0,0 +1,89 @@ +#pragma once +#include "GlobalDefine.h" +#include "ObjContainer.h" +#include "GlobalFunction.h" + + +enum SCAN_TRACK_E +{ + _SCAN_TRACK_S_L_R=0,//S ɨ-- + _SCAN_TRACK_S_R_L,//S ɨ--ҵ + + _SCAN_TRACK_U_D,//ɨ-ϵ + _SCAN_TRACK_D_U,//ɨ-µ + + _SCAN_TRACK_S_U_D,//S ɨ--ϵ + _SCAN_TRACK_S_D_U,//S ɨ--µ + + _SCAN_TRACK_L_R,//ɨ- + _SCAN_TRACK_R_L,//ɨ-ҵ +}; + + +//ɨ +class CScanLine +{ +public: + CScanLine(Dbxy StartPt,Dbxy EndPt) + { + m_StartPt = StartPt; + m_EndPt = EndPt; + m_bFirstLine = false;//һ + }; + CScanLine(void) + { + }; + ~CScanLine(void){}; + Dbxy GetStartPt(){return m_StartPt;}; + Dbxy GetEndPt(){return m_EndPt;}; + void SetStartPt(Dbxy pt){m_StartPt = pt;}; + void SetEndPt(Dbxy pt){m_EndPt = pt;}; + double GetLength(){return CalDistance(m_StartPt,m_EndPt);}; + void SetbFirstLine(){m_bFirstLine = true;}; + bool IsbFirstLine(){return m_bFirstLine;}; + void SetPenNum(int n){m_PenNum = n;}; + int GetPenNum(){return m_PenNum;}; +private: + Dbxy m_StartPt;// + Dbxy m_EndPt;//յ + bool m_bFirstLine;//һ + int m_PenNum;//ʺ +}; + +//ͼ +class CObjFillMgr +{ +public: + CObjFillMgr(void); + ~CObjFillMgr(void); + void FillAllSelObj(); + void FillAllSelObjByIdx(int idx); + void SetFillOffset(double val){m_FillOffset = val;}; + void SetFillAngle(double val){m_FillAngle = val;}; + void SetbDelEdgeObj(bool b){m_bDelEdgeObj = b;}; + bool GetAngle(double &Angle,int PenNum); + SCAN_TRACK_E GetCurScanType(){return m_CurScanType;}; + void SetStartFillIdx(int idx){m_StartFillIdx = idx;}; +private: + void CreatCmd(); + void FillObjAddToLayer(); + void CreatFillLineByObj(); + void CreatObjFillData(CObjContainer &ObjContainer); + void AdjustScanLine1(); + void AdjustScanLine2(); + bool CreatScanLineByObjFill(); + void CreatObjByScanLine(); + void ScanLineCoverWafer(Dbxy &pt1,Dbxy &pt2,bool bDir,int PenNum); + void UpdateCurScanType(); +public: + double m_FillOffset;//mm + double m_FillAngle;//Ƕ(360 ) + bool m_bDelEdgeObj;//Ƿɾobj + bool m_bCreatConnectLine;//Ƿ񴴽 + int m_StartFillIdx;//ӵڼ߿ʼ + SCAN_TRACK_E m_CurScanType;//ǰɨ跽ʽ + vector m_ScanLineVec;//ɨ + CObjContainer m_ObjContainer; +}; + +extern CObjFillMgr gObjFillMgr; diff --git a/LaipuDrawing/ObjGeometryPorp.cpp b/LaipuDrawing/ObjGeometryPorp.cpp new file mode 100644 index 0000000..526f5de --- /dev/null +++ b/LaipuDrawing/ObjGeometryPorp.cpp @@ -0,0 +1,32 @@ +#include "StdAfx.h" +#include "ObjGeometryPorp.h" + +#define RADIUS 5//ڼľΰ뾶(Сν) +CObjGeometryPorp::CObjGeometryPorp(void) +{ +} +CObjGeometryPorp::~CObjGeometryPorp(void) +{ +} +//ʼε˳ +// 4---------3 +// | | +// | | +// 1---------2 +void CObjGeometryPorp::OnAppInitialize() +{ + m_bMiirorH = false;//Ƿˮƽ + m_bMiirorV = false;//Ƿֱ + //ֻжֵ,ûбҪʵʵobj λöӦ + m_IniRect.Creat(Dbxy(0,0),RADIUS); + + m_PtContainer.DelAllPt(); + m_PtContainer.AddDataPoint(Dbxy(m_IniRect.L,m_IniRect.B)); + m_PtContainer.AddDataPoint(Dbxy(m_IniRect.R,m_IniRect.B)); + m_PtContainer.AddDataPoint(Dbxy(m_IniRect.R,m_IniRect.T)); + m_PtContainer.AddDataPoint(Dbxy(m_IniRect.L,m_IniRect.T)); +} +void CObjGeometryPorp::Operate(SObjOperatePar &par) +{ + +} \ No newline at end of file diff --git a/LaipuDrawing/ObjGeometryPorp.h b/LaipuDrawing/ObjGeometryPorp.h new file mode 100644 index 0000000..1b3290d --- /dev/null +++ b/LaipuDrawing/ObjGeometryPorp.h @@ -0,0 +1,21 @@ +#pragma once +#include "GlobalDefine.h" +#include "DataPoint.h" +#include "SequentialPoint.h" +//ͨһobj ļ +//λ,,ת,б, +class CObjGeometryPorp +{ +public: + CObjGeometryPorp(void); + ~CObjGeometryPorp(void); + void Operate(SObjOperatePar &par); +private: + void OnAppInitialize(); +private: + CSequentialPoint m_PtContainer;//εĸ + DbRect m_IniRect;//ʼľ + bool m_bMiirorH;//Ƿˮƽ + bool m_bMiirorV;//Ƿֱ +}; + diff --git a/LaipuDrawing/ObjPline.cpp b/LaipuDrawing/ObjPline.cpp new file mode 100644 index 0000000..ab5992b --- /dev/null +++ b/LaipuDrawing/ObjPline.cpp @@ -0,0 +1,148 @@ +#include "StdAfx.h" +#include "ObjPline.h" +#include "GlobalDrawMgr.h" +#include "DataPoint.h" +#include "GlobalFunction.h" + +CObjPline::CObjPline(void) +{ +} +CObjPline::~CObjPline(void) +{ +} +CString CObjPline::GetStr() +{ + CString str = "߶"; + return str; +} +#if 1 +//ͨεʽ߶point1 ½ǵĵ +void CObjPline::Creat(Dbxy point1,double w,double h) +{ + //ɾݵ + DelAllPt(); + + Dbxy point2(point1.x+w,point1.y+h); + CreatRect(point1,point2); +} +//ֱ +void CObjPline::Creat(Dbxy point1,Dbxy point2) +{ + //ɾݵ + DelAllPt(); + + if(point1 == point2)//ͬ + { + { + CDataPoint DataPoint(point1); + DataPoint.SetIsNode(true); + AddDataPoint(DataPoint); + } + } + else + { + { + CDataPoint DataPoint(point1); + DataPoint.SetIsNode(true); + AddDataPoint(DataPoint); + } + { + CDataPoint DataPoint(point2); + DataPoint.SetIsNode(true); + AddDataPoint(DataPoint); + } + AddMidNodePoint(point1,point2); + } +} +//һobj ߶εĺ(bReverse Ϊtrue ʱ) +void CObjPline::AddObj(Sptr &pObj,bool bReverse) +{ + if(bReverse) + { + vector&vec = pObj->GetPtContainer(); + int size = vec.size(); + for(int i=size-1;i>=0;i--) + { + AddDataPoint(vec[i]); + } + } + else + { + vector&vec = pObj->GetPtContainer(); + int size = vec.size(); + for(int i=0;i&vec = GetPtContainer(); + int size = vec.size(); + for(int i=0;i0) + { + AddMidNodePoint(vec[i-1].GetPt(),vec[i].GetPt()); + } + } +} +//һмڵ׽ +void CObjPline::AddMidNodePoint(Dbxy point1,Dbxy point2) +{ + Dbxy pt = CenterPtOfTwoPoint(point1,point2); + CDataPoint DataPoint(pt); + DataPoint.SetIsNode(true); + AddNodePt(DataPoint); +} +void CObjPline::CreatRect(DbRect rect) +{ + Dbxy point1(rect.L,rect.B); + Dbxy point2(rect.R,rect.T); + CreatRect(point1,point2); +} +void CObjPline::CreatRect(Dbxy point1,Dbxy point2) +{ + Dbxy pt = point1; + { + CDataPoint DataPoint(pt); + DataPoint.SetIsNode(true); + AddDataPoint(DataPoint); + } + pt.y = point2.y; + { + CDataPoint DataPoint(pt); + DataPoint.SetIsNode(true); + AddDataPoint(DataPoint); + } + AddMidNodePoint(point1,pt); + AddMidNodePoint(point2,pt); + pt = point2; + { + CDataPoint DataPoint(pt); + DataPoint.SetIsNode(true); + AddDataPoint(DataPoint); + } + pt.y = point1.y; + { + CDataPoint DataPoint(pt); + DataPoint.SetIsNode(true); + AddDataPoint(DataPoint); + } + AddMidNodePoint(point1,pt); + AddMidNodePoint(point2,pt); + pt = point1; + { + CDataPoint DataPoint(pt); + DataPoint.SetIsNode(true); + AddDataPoint(DataPoint); + } +} +#endif +#if 1//ͨεʽ + +#endif \ No newline at end of file diff --git a/LaipuDrawing/ObjPline.h b/LaipuDrawing/ObjPline.h new file mode 100644 index 0000000..d779668 --- /dev/null +++ b/LaipuDrawing/ObjPline.h @@ -0,0 +1,25 @@ +#pragma once +#include "ObjBase.h" +#include "SmartPtr.h" + +//߶ +class CObjPline :public CObjBase +{ +public: + CObjPline(void); + ~CObjPline(void); + virtual CObjPline * Clone(){return new CObjPline(*this);}; + virtual CString GetStr(); + virtual OBJ_TYPE GetType(){return _TYPE_PLINE;}; +public: + void Creat(Dbxy point1,double w,double h); + void Creat(Dbxy point1,Dbxy point2); + void Clone(CObjPline *p); + void CreatMidNode(); + void AddObj(Sptr &pObj,bool bReverse); + void CreatRect(DbRect rect); +private: + void CreatRect(Dbxy point1,Dbxy point2); + void AddMidNodePoint(Dbxy point1,Dbxy point2); +}; + diff --git a/LaipuDrawing/ObjPoint.cpp b/LaipuDrawing/ObjPoint.cpp new file mode 100644 index 0000000..1014ba7 --- /dev/null +++ b/LaipuDrawing/ObjPoint.cpp @@ -0,0 +1,71 @@ +#include "StdAfx.h" +#include "ObjPoint.h" +#include "GlobalDrawMgr.h" +#include "DrawSimpleShape.h" +#include "WorkFileLable.h" +#include "WorkFileMgr.h" + +CObjPoint::CObjPoint(void) +{ +} +CObjPoint::~CObjPoint(void) +{ +} +CString CObjPoint::GetStr() +{ + CString str = ""; + return str; +} +#if 1 +void CObjPoint::WriteWorkFileExt(vector &LabVec) +{ + //ݵ + Dbxy pt = GetRect().GetCenterPt(); + LabVec.push_back(CLab(LAB_POINT_X,pt.x)); + LabVec.push_back(CLab(LAB_POINT_Y,pt.y)); +} +void CObjPoint::ReadWorkFileExt(CLabVecRang &LabVecRang) +{ + CWorkFileMgr WorkFileMgr; + Dbxy pt; + {//X + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_POINT_X); + if(Lab.m_ValType != _TYPE_NULL) + { + pt.x = Lab.m_Double; + } + } + {//Y + CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_POINT_Y); + if(Lab.m_ValType != _TYPE_NULL) + { + pt.y = Lab.m_Double; + } + } + SetPt(pt); +} +#endif +void CObjPoint::Draw(CDC* pDC,CPen &Pen) +{ + DbRect Rect(GetRect().GetCenterPt(),gDraw->GetCatchNodeSize()*0.8); + DrawCrossX(pDC,Pen,Rect); +} +void CObjPoint::SetPt(Dbxy pt) +{ + //ڲĵ + double gap = 0.0001; + CDataPoint DataPoint1(Dbxy(pt.x-gap,pt.y+gap)); + DataPoint1.SetIsNode(true); + CDataPoint DataPoint2(Dbxy(pt.x+gap,pt.y-gap)); + AddDataPoint(DataPoint1); + AddDataPoint(DataPoint2); +} +//ݾһ +void CObjPoint::GetPtData(vector> &vec) +{ + Dbxy pt = GetRect().GetCenterPt(); + pt.PenNum = m_PenNum;//ñʺ + vector VecTmp; + VecTmp.push_back(pt); + vec.push_back(VecTmp); +} \ No newline at end of file diff --git a/LaipuDrawing/ObjPoint.h b/LaipuDrawing/ObjPoint.h new file mode 100644 index 0000000..0e1df6d --- /dev/null +++ b/LaipuDrawing/ObjPoint.h @@ -0,0 +1,17 @@ +#pragma once +#include "ObjBase.h" +class CObjPoint :public CObjBase +{ +public: + CObjPoint(void); + ~CObjPoint(void); + virtual void WriteWorkFileExt(vector &LabVec); + virtual void ReadWorkFileExt(CLabVecRang &LabVecRang); + virtual CObjPoint * Clone(){return new CObjPoint(*this);}; + virtual CString GetStr(); + virtual OBJ_TYPE GetType(){return _TYPE_POINT;}; + virtual void Draw(CDC* pDC,CPen &Pen); + virtual void GetPtData(vector> &vec); + void SetPt(Dbxy pt); +}; + diff --git a/LaipuDrawing/ObjSortMgr.cpp b/LaipuDrawing/ObjSortMgr.cpp new file mode 100644 index 0000000..8485240 --- /dev/null +++ b/LaipuDrawing/ObjSortMgr.cpp @@ -0,0 +1,304 @@ +#include "StdAfx.h" +#include "ObjSortMgr.h" +#include "ObjContainer.h" +#include "Layer.h" +#include "GlobalFunction.h" +#include "ObjPoint.h" + + +#if 1//ú +bool CompareDouble1(double val1,double val2) +{ + return val1>val2; +} +bool CompareDouble2(double val1,double val2) +{ + return val1 &Obj1,Sptr &Obj2) +{ + Dbxy pt1 = Obj1->GetCenterPt(); + Dbxy pt2 = Obj2->GetCenterPt(); + return pt1.x>pt2.x; +} +bool CompareObjX2(Sptr &Obj1,Sptr &Obj2) +{ + Dbxy pt1 = Obj1->GetCenterPt(); + Dbxy pt2 = Obj2->GetCenterPt(); + return pt1.x &Obj1,Sptr &Obj2) +{ + Dbxy pt1 = Obj1->GetCenterPt(); + Dbxy pt2 = Obj2->GetCenterPt(); + return pt1.y>pt2.y; +} +bool CompareObjY2(Sptr &Obj1,Sptr &Obj2) +{ + Dbxy pt1 = Obj1->GetCenterPt(); + Dbxy pt2 = Obj2->GetCenterPt(); + return pt1.y> &LayerObjVec = LayerObjContainer.GetObjVec(); + //ѡͷѡobj ͬ + vector> SelObjVec; + vector> NotSelObjVec; + SeparateSelObj(LayerObjVec,SelObjVec,NotSelObjVec); + + if(SelObjVec.empty()) + return; + + //ѡobj + SortObjVec(SelObjVec); + + //Żԭ + LayerObjVec.clear(); + PushToObjVec(LayerObjVec,SelObjVec); + PushToObjVec(LayerObjVec,NotSelObjVec); +} +//ѡͷѡobj ͬ +void CObjSortMgr::SeparateSelObj(vector> &ObjVec,vector> &SelObjVec,vector> &NotSelObjVec) +{ + vector>::iterator iter = ObjVec.begin(); + vector>::iterator iter_end = ObjVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter)->IsSelected()) + SelObjVec.push_back(*iter); + else + NotSelObjVec.push_back(*iter); + } +} +//ŻԭObjVec2---->ObjVec1 +void CObjSortMgr::PushToObjVec(vector> &ObjVec1,vector> &ObjVec2) +{ + vector>::iterator iter = ObjVec2.begin(); + vector>::iterator iter_end = ObjVec2.end(); + for(;iter!=iter_end;iter++) + { + ObjVec1.push_back(*iter); + } + +} +//Ƿɨ +bool CObjSortMgr::IsHorizontalScan() +{ + if(m_ScanDir == _DIR_L || m_ScanDir == _DIR_R) + return true; + return false; +} +//ǷΪɨ +bool CObjSortMgr::IsForwardDirection() +{ + if(m_ScanDir == _DIR_R || m_ScanDir == _DIR_D) + return true; + return false; +} +#endif +#if 1 +//еobj (Ͱ˼·) +void CObjSortMgr::SortObjVec(vector> &ObjVec) +{ + vector>> BucketVec;//Ͱ(ÿͰĵһobj ʾͰ) + //Ͱ + CreatBucketVec(BucketVec,ObjVec); + //ѼͰobj + CollectBucketObj(BucketVec,ObjVec); + //ÿͰ + BucketSort(BucketVec); + //Ͱobj ObjVec + BucketToObjVec(BucketVec,ObjVec); +} +//Ͱ +void CObjSortMgr::CreatBucketVec(vector>> &BucketVec,vector> &ObjVec) +{ + //Ͱ׼ + vector BucketBaseCoordVec; + CreatBucketBaseCoordVec(BucketBaseCoordVec,ObjVec); + + //Ͱ׼ + if(IsForwardDirection()) + sort(BucketBaseCoordVec.begin(),BucketBaseCoordVec.end(),CompareDouble1); + else + sort(BucketBaseCoordVec.begin(),BucketBaseCoordVec.end(),CompareDouble2); + + //ݻ׼㴴Ͱ + vector::iterator iter = BucketBaseCoordVec.begin(); + vector::iterator iter_end = BucketBaseCoordVec.end(); + for(;iter!=iter_end;iter++) + { + //ÿͰĵһobj Ϊ׼ + CObjPoint *p = new CObjPoint; + p->SetPt(Dbxy((*iter),(*iter)));//x yΪһ,Ͳַ + //浽ָ + Sptr sPtr(p); + vector> Bucket;//һͰ + Bucket.push_back(sPtr); + BucketVec.push_back(Bucket); + } +} +//Ͱ׼(ֺ) +void CObjSortMgr::CreatBucketBaseCoordVec(vector &BucketBaseCoordVec,vector> &ObjVec) +{ + vector>::iterator iter = ObjVec.begin(); + vector>::iterator iter_end = ObjVec.end(); + for(;iter!=iter_end;iter++) + { + Dbxy pt = (*iter)->GetCenterPt();//obj ĵ + double Val = IsHorizontalScan()?pt.x:pt.y; + + bool bFlg = true;//ǷҪ + int size = BucketBaseCoordVec.size(); + for(int k=0;k>> &BucketVec,vector> &ObjVec) +{ + vector>>::iterator iter = BucketVec.begin(); + vector>>::iterator iter_end = BucketVec.end(); + for(;iter!=iter_end;iter++) + { + vector> &Bucket = (*iter); + Dbxy BasePt = Bucket[0]->GetCenterPt(); + double BaseVal = IsHorizontalScan()?BasePt.x:BasePt.y;//׼ֵ + Bucket.clear();//׼obj + + vector>::iterator ObjIter = ObjVec.begin(); + vector>::iterator ObjIter_end = ObjVec.end(); + for(;ObjIter!=ObjIter_end;ObjIter++) + { + Sptr &Obj = (*ObjIter); + if(!Obj->IsbCollected())//ظռ + { + Dbxy ObjPt = Obj->GetCenterPt(); + double ObjVal = IsHorizontalScan()?ObjPt.x:ObjPt.y;//Ƚֵ + if(IsTwoDbEqual(BaseVal,ObjVal,BUCKET_EPS))//Ͱobj + { + Bucket.push_back(Obj); + Obj->SetbCollected(true);//ռ״̬ + } + } + } + } +} +//ÿͰ +void CObjSortMgr::BucketSort(vector>> &BucketVec) +{ + bool bDir = true;//S + vector>>::iterator iter = BucketVec.begin(); + vector>>::iterator iter_end = BucketVec.end(); + for(;iter!=iter_end;iter++) + { + vector> &Bucket = (*iter); + if(IsHorizontalScan())//ɨ谴Y + { + if(bDir) + sort(Bucket.begin(),Bucket.end(),CompareObjY1); + else + sort(Bucket.begin(),Bucket.end(),CompareObjY2); + } + else//ɨ谴X + { + if(bDir) + sort(Bucket.begin(),Bucket.end(),CompareObjX1); + else + sort(Bucket.begin(),Bucket.end(),CompareObjX2); + } + bDir =!bDir;// + } +} +//Ͱobj ObjVec +void CObjSortMgr::BucketToObjVec(vector>> &BucketVec,vector> &ObjVec) +{ + ObjVec.clear(); + vector>>::iterator iter = BucketVec.begin(); + vector>>::iterator iter_end = BucketVec.end(); + for(;iter!=iter_end;iter++) + { + vector> &Bucket = (*iter); + vector>::iterator BucketIter = Bucket.begin(); + vector>::iterator BuckeIter_end = Bucket.end(); + for(;BucketIter!=BuckeIter_end;BucketIter++) + { + ObjVec.push_back(*BucketIter); + } + } +} +#endif + +#if 0//ܽܵ㷨 +void CObjSortMgr::PlineSort(vector> &LineVec) +{ + + double gl; + double Min_gl=0; + double sum1,sum2; + int n=0; + for (vector>::size_type i=0;i!=(LineVec.size()-1);++i) + { + Dbxy ed1=LineVec[i].back(); + + for (vector>::size_type j=i+1;j!=LineVec.size();++j) + { + Dbxy ed2=LineVec[j].back(); + Dbxy beg=LineVec[j].front(); + sum1=sqrt((ed1.x-beg.x)*(ed1.x-beg.x)+(ed1.y-beg.y)*(ed1.y-beg.y)); + sum2=sqrt((ed1.x-ed2.x)*(ed1.x-ed2.x)+(ed1.y-ed2.y)*(ed1.y-ed2.y)); + if (sum2> &ObjVec,vector> &SelObjVec,vector> &NotSelObjVec); + void SortObjVec(vector> &SelObjVec); + void PushToObjVec(vector> &ObjVec1,vector> &ObjVec2); + void CreatBucketVec(vector>> &BucketVec,vector> &ObjVec); + void CreatBucketBaseCoordVec(vector &BucketBaseCoordVec,vector> &ObjVec); + bool IsHorizontalScan(); + bool IsForwardDirection(); + void CollectBucketObj(vector>> &BucketVec,vector> &ObjVec); + void BucketToObjVec(vector>> &BucketVec,vector> &ObjVec); + void BucketSort(vector>> &BucketVec); +private: + DIRECTION m_ScanDir;//ɨķ + +}; + diff --git a/LaipuDrawing/ObjString.cpp b/LaipuDrawing/ObjString.cpp new file mode 100644 index 0000000..e9f0159 --- /dev/null +++ b/LaipuDrawing/ObjString.cpp @@ -0,0 +1,34 @@ +#include "StdAfx.h" +#include "ObjString.h" +#include "FontTypeMgr.h" + +CObjString::CObjString(void) +{ +} + +CObjString::~CObjString(void) +{ +} +CObjString::CObjString(CObjString &rhs) +:CObjComposite(rhs) +{ + m_ValStr.Copy(rhs.m_ValStr); + m_FontTypeName = rhs.m_FontTypeName; + m_FontName = rhs.m_FontName; +} +//ÿɱıĿ +void CObjString::GetValStrCopy(CValString &ValStr) +{ + ValStr.Copy(m_ValStr); +} +void CObjString::SetValStr(CValString &ValStr) +{ + m_ValStr.Copy(ValStr); +} +//浱ǰϵͳ +void CObjString::SetUseCurFontName() +{ + CFontTypeMgr &pFontTypeMgr = CFontTypeMgr::Instance(); + SetFontTypeName(pFontTypeMgr.GetCurFontTypeName()); + SetFontName(pFontTypeMgr.GetCurFontName()); +} \ No newline at end of file diff --git a/LaipuDrawing/ObjString.h b/LaipuDrawing/ObjString.h new file mode 100644 index 0000000..beff18f --- /dev/null +++ b/LaipuDrawing/ObjString.h @@ -0,0 +1,26 @@ +#pragma once +#include "ObjComposite.h" +#include "ValString.h" + +class CObjString :public CObjComposite +{ +public: + CObjString(void); + virtual ~CObjString(void); + virtual OBJ_TYPE GetType(){return _TYPE_STR;}; + CObjString(CObjString &rhs); + void GetValStrCopy(CValString &ValStr); + void SetValStr(CValString &ValStr); + void SetUseCurFontName(); + void SetFontTypeName(CString str){m_FontTypeName = str;}; + void SetFontName(CString str){m_FontName = str;}; + CString GetFontTypeName(){return m_FontTypeName;}; + CString GetFontName(){return m_FontName;}; +protected: + //滻ı + CValString m_ValStr; + //ֻ֣ǰûٸΪǰĬ + CString m_FontTypeName;//͵ + CString m_FontName;// +}; + diff --git a/LaipuDrawing/ObjTxt.cpp b/LaipuDrawing/ObjTxt.cpp new file mode 100644 index 0000000..2ff4683 --- /dev/null +++ b/LaipuDrawing/ObjTxt.cpp @@ -0,0 +1,262 @@ +#include "StdAfx.h" +#include "ObjTxt.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "FontTypeMgr.h" + +CObjTxt::CObjTxt(void) +{ +} + +CObjTxt::~CObjTxt(void) +{ +} +CObjTxt::CObjTxt(CObjTxt &rhs) +:CObjString(rhs) +{ + m_FontPar = rhs.m_FontPar; + CreatExt(); +} +CString CObjTxt::GetStr() +{ + CString str = "ַ"; + return str; +} +//󶨵Ի +void CObjTxt::BindingDlg() +{ +#ifdef __DLG_PANE_VAR_STRING__ + GetFrame()->m_DlgVariableString.BindingObjString(this); +#endif +} +void CObjTxt::CreatExt() +{ + // + m_ObjContainer.Clear(); + //ȡַ + CString Str = GetCurString(); + // + MakeReverse(Str); + //ȡַݵm_ObjContainer + GetEachCharData(Str); + //ַȣ߶ + AdjustWidthHeight(); + //ַ + AdjustGap(); + // + MakeOutDir(); + //бĽǶ + AdjustItalic(); + //Բı + AdjustArcTxt(); + //ָ֮ǰ״̬ + RecoverPerState(); +} +#if 1 +//ȡǰı +CString CObjTxt::GetCurString() +{ + //ɱı + m_ValStr.UpdateValStr(); + return m_ValStr.GetString(); +} +//ȡַ +void CObjTxt::GetEachCharData(CString Str) +{ + //ȱɵ + CFontTypeMgr &pFontTypeMgr = CFontTypeMgr::Instance(); + CString OldFontTypeName = pFontTypeMgr.GetCurFontTypeName(); + CString OldFontName = pFontTypeMgr.GetCurFontName(); + //õǰѡõ + pFontTypeMgr.SetCurFontByName(m_FontTypeName,m_FontName); + + const char* pStr=(const char*)(Str); + int StrLen = strlen(pStr); + while(StrLen>0) + { + unsigned char char1,char2; + char Char[3]; + char1 = *pStr; + char2 = *(pStr+1); + if(char1>160 && char2>160)//λһ + { + strncpy(Char,pStr,2); + Char[2]='\0'; + pStr += 2; + StrLen -= 2; + } + else//һλһĸ + { + strncpy(Char,pStr,1); + Char[1]='\0'; + pStr += 1; + StrLen -= 1; + } + CObjChar *p = new CObjChar(Char); + p->Creat(); + m_ObjContainer.AddObject(p); + } + + //ԭɵ + pFontTypeMgr.SetCurFontByName(OldFontTypeName,OldFontName); +} +// +void CObjTxt::MakeReverse(CString &Str) +{ + if(m_FontPar.m_bReverse) + { + Str.MakeReverse(); + } +} +// +void CObjTxt::MakeOutDir() +{ + if(m_FontPar.m_bOutDir) + { + DbRect rect = m_ObjContainer.GetObjRect(false); + SObjOperatePar par; + par.OpType = _OP_MIRROR; + par.BasePt = rect.GetCenterPt(); + par.xy = _Y; + m_ObjContainer.OperateObj(par,false); + } +} +#endif +#if 1// +//ַȣ߶ +void CObjTxt::AdjustWidthHeight() +{ + DbRect rect = m_ObjContainer.GetObjRect(false); + double Scale = m_FontPar.m_CharHeight/rect.GetSize().h; + + //ȷű + SObjOperatePar par; + par.OpType = _OP_SCALE; + par.Scale = Scale; + + int size = m_ObjContainer.GetSize(); + for(int i=0;i> StrVec; + FileMgr.ReadFileToStrVec(FilePath,StrVec); + size = StrVec.size(); + for(int k=0;k m_OffsetTableParVec;//recipe +}; \ No newline at end of file diff --git a/LaipuDrawing/OutputWnd.cpp b/LaipuDrawing/OutputWnd.cpp new file mode 100644 index 0000000..9c8fb4c --- /dev/null +++ b/LaipuDrawing/OutputWnd.cpp @@ -0,0 +1,174 @@ + +#include "stdafx.h" + +#include "OutputWnd.h" +#include "Resource.h" +#include "MainFrm.h" +#include "LogMgr.h" + + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// COutputBar + +COutputWnd::COutputWnd() +{ + m_CurLineCnt = 0;//ǰ +} +COutputWnd::~COutputWnd() +{ +} + +BEGIN_MESSAGE_MAP(COutputWnd, CDockablePane) + ON_WM_CREATE() + ON_WM_SIZE() +END_MESSAGE_MAP() + +int COutputWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) +{ + if (CDockablePane::OnCreate(lpCreateStruct) == -1) + return -1; + + CRect rectDummy; + rectDummy.SetRectEmpty(); + + // ѡ: + if (!m_wndTabs.Create(CMFCTabCtrl::STYLE_FLAT, rectDummy, this, 1)) + { + TRACE0("δܴѡ\n"); + return -1; // δܴ + } + + // : + const DWORD dwStyle = LBS_NOINTEGRALHEIGHT | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL; + + if (!m_List.Create(dwStyle, rectDummy, &m_wndTabs, 2)) + { + TRACE0("δܴ\n"); + return -1; // δܴ + } + + UpdateFonts(); + + CString strTabName; + + // бڸӵѡ: + strTabName = _T("List"); + m_wndTabs.AddTab(&m_List, strTabName, (UINT)0); + return 0; +} + +void COutputWnd::OnSize(UINT nType, int cx, int cy) +{ + CDockablePane::OnSize(nType, cx, cy); + // ѡؼӦ: + m_wndTabs.SetWindowPos (NULL, -1, -1, cx, cy, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER); +} + +void COutputWnd::AdjustHorzScroll(CListBox& wndListBox) +{ + CClientDC dc(this); + CFont* pOldFont = dc.SelectObject(&afxGlobalData.fontRegular); + + int cxExtentMax = 0; + + for (int i = 0; i < wndListBox.GetCount(); i ++) + { + CString strItem; + wndListBox.GetText(i, strItem); + + cxExtentMax = max(cxExtentMax, dc.GetTextExtent(strItem).cx); + } + + wndListBox.SetHorizontalExtent(cxExtentMax); + dc.SelectObject(pOldFont); +} + +void COutputWnd::UpdateFonts() +{ + m_List.SetFont(&afxGlobalData.fontRegular); +} +void COutputWnd::AddToList(CString str,int MaxLine) +{ + if(m_CurLineCnt>MaxLine) + { + m_List.ResetContent(); + m_CurLineCnt = 0; + } + m_List.AddString(str); + //ʾһ + m_List.SetTopIndex(m_List.GetCount()-1); + m_CurLineCnt++; + //ѡһ + m_List.SetCurSel(m_CurLineCnt-1); +} + +///////////////////////////////////////////////////////////////////////////// +// COutputList1 + +COutputList::COutputList() +{ +} + +COutputList::~COutputList() +{ +} + +BEGIN_MESSAGE_MAP(COutputList, CListBox) + ON_WM_CONTEXTMENU() + ON_COMMAND(ID_EDIT_COPY, OnEditCopy) + ON_COMMAND(ID_EDIT_CLEAR, OnEditClear) + ON_COMMAND(ID_OUTPUT_CMD, OnViewOutput) + ON_COMMAND(ID_OUTPUT_LOG, OnViewOutput) + ON_WM_WINDOWPOSCHANGING() +END_MESSAGE_MAP() +///////////////////////////////////////////////////////////////////////////// +// COutputList Ϣ + +void COutputList::OnContextMenu(CWnd* /*pWnd*/, CPoint point) +{ + CMenu menu; + menu.LoadMenu(IDR_OUTPUT_POPUP); + + CMenu* pSumMenu = menu.GetSubMenu(0); + + if (AfxGetMainWnd()->IsKindOf(RUNTIME_CLASS(CMDIFrameWndEx))) + { + CMFCPopupMenu* pPopupMenu = new CMFCPopupMenu; + + if (!pPopupMenu->Create(this, point.x, point.y, (HMENU)pSumMenu->m_hMenu, FALSE, TRUE)) + return; + + ((CMDIFrameWndEx*)AfxGetMainWnd())->OnShowPopupMenu(pPopupMenu); + UpdateDialogControls(this, FALSE); + } + + SetFocus(); +} + +void COutputList::OnEditCopy() +{ + //־Ŀ¼ + gLogMgr->OpenLogFileDir(); +} +void COutputList::OnEditClear() +{ + ResetContent(); +} +void COutputList::OnViewOutput() +{ + CDockablePane* pParentBar = DYNAMIC_DOWNCAST(CDockablePane, GetOwner()); + CMDIFrameWndEx* pMainFrame = DYNAMIC_DOWNCAST(CMDIFrameWndEx, GetTopLevelFrame()); + + if (pMainFrame != NULL && pParentBar != NULL) + { + pMainFrame->SetFocus(); + pMainFrame->ShowPane(pParentBar, FALSE, FALSE, FALSE); + pMainFrame->RecalcLayout(); + } +} diff --git a/LaipuDrawing/OutputWnd.h b/LaipuDrawing/OutputWnd.h new file mode 100644 index 0000000..00e9725 --- /dev/null +++ b/LaipuDrawing/OutputWnd.h @@ -0,0 +1,50 @@ + +#pragma once + +///////////////////////////////////////////////////////////////////////////// +// COutputList + +class COutputList : public CListBox +{ +// +public: + COutputList(); + +// ʵ +public: + virtual ~COutputList(); + +protected: + afx_msg void OnContextMenu(CWnd* pWnd, CPoint point); + afx_msg void OnEditCopy(); + afx_msg void OnEditClear(); + afx_msg void OnViewOutput(); + + DECLARE_MESSAGE_MAP() +}; + +class COutputWnd : public CDockablePane +{ +// +public: + COutputWnd(); + void UpdateFonts(); + void AddToList(CString str,int MaxLine); +// +protected: + CMFCTabCtrl m_wndTabs; + COutputList m_List; + int m_CurLineCnt;//ǰ +protected: + void AdjustHorzScroll(CListBox& wndListBox); + +// ʵ +public: + virtual ~COutputWnd(); + +protected: + afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); + afx_msg void OnSize(UINT nType, int cx, int cy); + DECLARE_MESSAGE_MAP() +}; + diff --git a/LaipuDrawing/PaneDialogTmp.cpp b/LaipuDrawing/PaneDialogTmp.cpp new file mode 100644 index 0000000..e616f2d --- /dev/null +++ b/LaipuDrawing/PaneDialogTmp.cpp @@ -0,0 +1,45 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "PaneDialogTmp.h" + +IMPLEMENT_DYNAMIC(CPaneDialogTmp, CDockablePane) +BEGIN_MESSAGE_MAP(CPaneDialogTmp, CDockablePane) + ON_WM_CREATE() + ON_WM_SIZE() +END_MESSAGE_MAP() + +CPaneDialogTmp::CPaneDialogTmp() +{ + +} + +CPaneDialogTmp::~CPaneDialogTmp() +{ +} +// CPaneStdMarkCtrl Ϣ +int CPaneDialogTmp::OnCreate(LPCREATESTRUCT lpCreateStruct) +{ + if (CDockablePane::OnCreate(lpCreateStruct) == -1) + return -1; + + CRect rectDummy; + rectDummy.SetRectEmpty(); + // ѡ: + if(!m_Dlg->Create(m_Dlg->GetIDD(),this)) + { + return -1; // δܴ + } + m_Dlg->ShowWindow(SW_SHOW); + return 0; +} + +void CPaneDialogTmp::OnSize(UINT nType, int cx, int cy) +{ + CDockablePane::OnSize(nType, cx, cy); + + // ѡؼӦ + m_Dlg->SetWindowPos (this, -1, -1, cx, cy, SWP_NOACTIVATE | SWP_NOZORDER); + m_Dlg->ShowWindow(SW_SHOW); +} + diff --git a/LaipuDrawing/PaneDialogTmp.h b/LaipuDrawing/PaneDialogTmp.h new file mode 100644 index 0000000..fd3d6e1 --- /dev/null +++ b/LaipuDrawing/PaneDialogTmp.h @@ -0,0 +1,27 @@ +#pragma once +#include "MyDlgView.h" + + +//ͣԻģ +class CPaneDialogTmp : public CDockablePane +{ + DECLARE_DYNAMIC(CPaneDialogTmp) +public: + CPaneDialogTmp(); + virtual ~CPaneDialogTmp(); + void SetDlg(CMyDlgView *p){m_Dlg = p;}; + + //virtual BOOL CanBeClosed() const { return FALSE; } + //virtual BOOL CanAutoHide() const { return FALSE; } + //virtual BOOL FloatPane(CRect rectFloat, AFX_DOCK_METHOD dockMethod = DM_UNKNOWN, bool bShow = true) { return FALSE; } + //virtual BOOL CanFloat() const { return FALSE; } + +private: + CMyDlgView *m_Dlg; +protected: + afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); + afx_msg void OnSize(UINT nType, int cx, int cy); + DECLARE_MESSAGE_MAP() +}; + + diff --git a/LaipuDrawing/ParMappingTab.cpp b/LaipuDrawing/ParMappingTab.cpp new file mode 100644 index 0000000..85d0194 --- /dev/null +++ b/LaipuDrawing/ParMappingTab.cpp @@ -0,0 +1,116 @@ +#include "StdAfx.h" +#include "ParMappingTab.h" +#include "Propertie.h" +#include "PropertieMgr.h" + + +CParMappingTab::CParMappingTab(void) +{ + //ʼ + for(int i=0;iSetpVal((void*)&(m_CurCtrlParVec[i])); + pPropertie->SetType(_PROP_TYPE_STRING); + pPropertie->SetpModule(pModule); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + str.Format("%ld",i+1); + CString PropertyName = str; + str += "Ӧĺ(޸ҪЧ)"; + CString Description = str; + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_CurCtrlParVec[i], Description); + // + InsertPenParName(p1); + + p1->AllowEdit(FALSE);//޸ + pGroup1->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + pGroup->AddSubItem(pGroup1); + } +} +//˳(ʹõIJǰ),ȥڵIJ +void CParMappingTab::AdjustParOrder() +{ + vector Vec; + for(int i=0;i::iterator iter = m_AllCtrlParList.begin(); + vector::iterator iter_end = m_AllCtrlParList.end(); + for(int i=0;iter!=iter_end;iter++,i++) + { + p->AddOption(*iter); + } +} + +//ͨ(ģԶpar öֵ)ѯӳеֵidx +//ģõidx ,ٵԼȥҶӦ +bool CParMappingTab::GetMappingTabParIdx(int EnumParType,int &ParIdx) +{ + int size = m_AllCtrlParList.size(); + if(EnumParType &vec){m_AllCtrlParList = vec;}; + bool GetMappingTabParIdx(int EnumParType,int &ParIdx); + vector &GetCtrlParVec(){return m_CurCtrlParVec;}; + void AdjustParOrder(); +private: + void InsertPenParName(CMFCPropertyGridProperty* p); +private: + vector m_AllCtrlParList;//пɿƲб + vector m_CurCtrlParVec;//ǰƲӳ +}; + diff --git a/LaipuDrawing/PenPar.cpp b/LaipuDrawing/PenPar.cpp new file mode 100644 index 0000000..bfc8a40 --- /dev/null +++ b/LaipuDrawing/PenPar.cpp @@ -0,0 +1,85 @@ +#include "StdAfx.h" +#include "PenPar.h" +#include "GlobalDefine.h" +#include "WorkFileMgr.h" + +CPenPar::CPenPar(void) +{ + m_color = RGB_GRAY;//ʵɫ + m_bSelected = false;//Ƿѡ + CreatParVec(); +} +CPenPar::~CPenPar(void) +{ +} +CPenPar CPenPar::operator =(CPenPar rls) +{ + //Ҫѡɫ + m_ParVec = rls.m_ParVec; + m_bSelected = rls.m_bSelected;//Ƿѡ + return *this; +} +void CPenPar::Serialize(CArchive &ar) +{ + if(ar.IsStoring()) + { + for(int i=0;i>m_ParVec[i]; + } + } +} +void CPenPar::WriteWorkFile(vector &LabVec) +{ + for(int i=0;i=0 && idx=0 && idx &LabVec); + void ReadWorkFile(CLabVecRang &LabVecRang); + COLORREF GetColor(){return m_color;}; + void SetColor(COLORREF c){m_color = c;}; + void Serialize(CArchive &ar); + double GetParByIdx(int idx); + void SetParByIdx(int idx,double val); + double &GetParReference(int idx){return m_ParVec[idx];}; +private: + void CreatParVec(); +public: + COLORREF m_color;//ʵɫ + bool m_bSelected;//Ƿѡ + vector m_ParVec;// +}; + diff --git a/LaipuDrawing/PenParMgr.cpp b/LaipuDrawing/PenParMgr.cpp new file mode 100644 index 0000000..8394269 --- /dev/null +++ b/LaipuDrawing/PenParMgr.cpp @@ -0,0 +1,343 @@ +#include "StdAfx.h" +#include "PenParMgr.h" +#include "CStringFuc.h" +#include "GlobalDefine.h" +#include "FileMgr.h" +#include "WorkFileLable.h" +#include "WorkFileMgr.h" +#include "GlobalFunction.h" +#include "PropertieMgr.h" +#include "LogMgr.h" +#include "PenParMgr.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" + +#define FILE_PATH _T("\\Parameter\\CPenParMgr\\PenPar.par") + +CPenParMgr *gPenParMgr = new CPenParMgr; +CPenParMgr::CPenParMgr(void) +{ + m_CurPen = 0;//ǰıʺ + m_PenPlatMoveSpeed = 99;//ƽ̨ٶ(˶ƿ) + m_PenOffsetObj = 98;//S ƶʱƽobj ıʺ + m_PenFindOrignXY = 97;//XY ƽ̨Զٶ + m_PenManualMoveX = 95;//ֶƶƽ̨X ٶ + m_PenManualMoveY = 96;//ֶƶƽ̨Y ٶ + m_CurWorkPen = 0;//ǰıʺ + //ʼ + IniParVec(); + InitRecipeParVec(); +} +CPenParMgr::~CPenParMgr(void) +{ +} +//ƺ +void CPenParMgr::Copy(CPenParMgr &rls) +{ + //Ҫ + for(int k=0;k &LabVec) +{ + +} +void CPenParMgr::ReadWorkFile(CLabVecRang &LabVecRang) +{ + +} +#endif +//ʼ +void CPenParMgr::IniParVec() +{ + for(int i=0;iMAX_RECIPE_PAR_CNT) + { + m_PenParVec.pop_back(); + size = m_PenParVec.size(); + } +} +void CPenParMgr::InsertToList(CListCtrl &List) +{ + int size = m_ParVec.size(); + for(int i=0;i::iterator iter = m_ParVec.begin(); + vector::iterator iter_end = m_ParVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).Serialize(ar); + } +} +CPenPar CPenParMgr::GetPen(int pen) +{ + if(pen>=0 && pen=0 && num=0 && PenNum=0 && PenNum=SPECIAL_PEN_START)&&(n &vec) +{ + int size = vec.size(); + for(int k=0;(k &LabVec); + virtual void ReadWorkFile(CLabVecRang &LabVecRang); + virtual CString GetParDirName(){return "CPenParMgr";}; + virtual void OnAppInitialize(); + void Copy(CPenParMgr &rls); + void InsertToList(CListCtrl &List); + COLORREF GetPenColor(int pen); + void SaveCurPen(int Pen,CPenPar CurPar); + CPenPar GetPen(int pen); + CPenPar& GetCurPen(){return m_ParVec[m_CurPen];};//õǰѡı + void SetCurPenNum(int num); + int GetCurPenNum(){return m_CurPen;}; + int GetCurWorkPenNum(){return m_CurWorkPen;}; + void SetCurWorkPen(int n){m_CurWorkPen = n;}; + void SaveOrLoad(bool bSave); + void SaveCurPen(CPenPar CurPar); + double GetPar(int PenNum,PEN_CTRL_PAR PenCtrlPar); + double GetPar(CPenPar &PenPar,PEN_CTRL_PAR PenCtrlPar); + bool IsSpecialPen(int n); + void SetPar(int PenNum,PEN_CTRL_PAR PenCtrlPar,double val); + vector &GetParVec(){return m_ParVec;}; + void SetParVec(vector &vec){m_ParVec = vec;}; + void SetParSelectState(vector &vec); + void SetFirstSelPenAsWorkPen(); + void ResetAllSelState(); + vector &GetRecipeParVec(){return m_PenParVec;}; +private: + void IniParVec(); + void InitRecipeParVec(); + void SaveOrLoadExt(CArchive &ar); + void InsertPenParName(CMFCPropertyGridProperty* p); + void AdjustPenParOrder(); +private: + vector m_ParVec;// + vector m_PenParVec;//recipe ӹʹõIJ + int m_CurPen;//ǰıʺ + int m_CurWorkPen;//ǰıʺ + //;ʺ --------------------------------------- + int m_PenPlatMoveSpeed;//ƽ̨ٶȵıʺ(˶ƿ) + int m_PenOffsetObj;//S ƶʱƽobj ıʺ + int m_PenFindOrignXY;//XY ƽ̨Զٶ + int m_PenManualMoveX;//ֶƶƽ̨X ٶ + int m_PenManualMoveY;//ֶƶƽ̨Y ٶ +}; + +extern CPenParMgr *gPenParMgr; diff --git a/LaipuDrawing/PltReader.cpp b/LaipuDrawing/PltReader.cpp new file mode 100644 index 0000000..778a213 --- /dev/null +++ b/LaipuDrawing/PltReader.cpp @@ -0,0 +1,240 @@ +#include "StdAfx.h" +#include "PltReader.h" +#include "ObjComposite.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "MarkObjPropertieMgr.h" +#include "Layer.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +CPltReader* gPltReader = new CPltReader;//plt ȡ + +CPltReader::CPltReader(void) +{ + m_ScaleX = 0.024888; + m_ScaleY = 0.024875; +} +CPltReader::~CPltReader(void) +{ +} +#if 1//ú +CMFCPropertyGridProperty *CPltReader::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = _T("PltSet");;//洢· + CString Name; +//-------------------------------------------------------------------------------// + PropertyName = _T("plt ȡ"); + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_ScaleX");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_ScaleX); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("plt ȡX"); + Description = _T("ڽȡplt ļŵcad ӦСı"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_ScaleX, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + //Աӳ + Name = _T("m_ScaleY");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_ScaleY); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("plt ȡY"); + Description = _T("ڽȡplt ļŵcad ӦСı"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_ScaleY, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } +//-------------------------------------------------------------------------------// + return pGroup; +} +#endif +#if 1 +//ļ +void CPltReader::OpenFile() +{ + CLayer &layer = gLayer; + CFileDialog FileOpen(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "plt ļ (*.plt)|*.plt;"); + if(IDOK == FileOpen.DoModal()) + { + CString FilePath=FileOpen.GetPathName(); + //plt ļ + if(AnalysePltFlie(FilePath)) + { + //vec һϳɶ + TranslatorToComposite(m_PtVec,layer.GetObjContainer()); + GetCurViewPtr()->RefreshView(); + //ͼ + gMarkObjPropertieMgr->UpdateSelMarkObjPropertie(); + gLogMgr->WriteDebugLog("func :Open Plt File---->"+FilePath); + } + gLogMgr->WriteDebugLog("func :AnalysePltFlie---->Error"); + } +} +//vec һϳɶ +void CPltReader::TranslatorToComposite(vector &vec,CObjContainer &ObjContainer) +{ + if(vec.empty()) + { + return; + } + //ϳɶ + CObjComposite *pObj = new CObjComposite; + + vector::iterator iter = vec.begin(); + vector::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + Dbxy DbPt((*iter).first.x,(*iter).first.y); + CDataPoint pt(DbPt); + pObj->AddPt(pt,(*iter).second); + } + //ƶм + { + DbRect rect = pObj->GetRect(); + Dbxy pt = rect.GetCenterPt(); + + SObjOperatePar par; + par.OpType = _OP_MOVE; + par.MoveX = -pt.x; + par.MoveY = -pt.y; + pObj->Operate(par); + } + //ŵcad óߴX + { + SObjOperatePar par; + par.Scale = m_ScaleX; + + par.OpType = _OP_STRETCH; + DbRect rect = pObj->GetRect(); + Dbxy pt = rect.GetCenterPt(); + + par.OldSize = rect.R - rect.L; + par.NewSize = par.OldSize*par.Scale; + par.Diff = par.NewSize-par.OldSize; + par.xy = _X; + pObj->Operate(par); + } + //ŵcad óߴY + { + SObjOperatePar par; + par.Scale = m_ScaleY; + + par.OpType = _OP_STRETCH; + DbRect rect = pObj->GetRect(); + Dbxy pt = rect.GetCenterPt(); + + par.OldSize = rect.T - rect.B; + par.NewSize = par.OldSize*par.Scale; + par.Diff = par.NewSize-par.OldSize; + par.xy = _Y; + pObj->Operate(par); + } + + ObjContainer.AddObject(pObj); +} +#endif +#if 1 +//plt ļ +bool CPltReader::AnalysePltFlie(CString FilePath) +{ + m_PtVec.clear(); + + CStdioFile file; + if(file.Open(FilePath,CFile::modeRead,NULL)==0) + { + return false; + } + + CString str; + bool flg = true; + int pos = 0; + while(file.ReadString(str))//ȡһ + { + int len = str.GetLength(); + while(pos &vec,CObjContainer &ObjContainer); +private: + vector m_PtVec;//洢ȡݵ + //ڽȡplt ļŵcad ӦСı + double m_ScaleX; + double m_ScaleY; +}; + +extern CPltReader* gPltReader; \ No newline at end of file diff --git a/LaipuDrawing/PrintView.cpp b/LaipuDrawing/PrintView.cpp new file mode 100644 index 0000000..651011c --- /dev/null +++ b/LaipuDrawing/PrintView.cpp @@ -0,0 +1,58 @@ +#include "StdAfx.h" +#include "PrintView.h" +#include "GlobalFunction.h" +#include "FileMgr.h" + + +CPrintViewMgr::CPrintViewMgr(void) +{ +} +CPrintViewMgr::~CPrintViewMgr(void) +{ +} +CString CPrintViewMgr::GetPrintViewFullFilePath() +{ + CString FullFilePath; + CString FileName = "\\View.bmp"; + //ȡ· + CFileMgr FileMgr; + FileMgr.GetFullFilePath(FullFilePath,FileName); + return FullFilePath; +} +//ӡview ݵһbmp ͼƬ +void CPrintViewMgr::PrintViewToBmp(HDC hDC,RECT rect) +{ + CString FullFilePath = GetPrintViewFullFilePath(); + PrintViewToBmpExt(FullFilePath,hDC,rect); +} +void CPrintViewMgr::PrintViewToBmpExt(CString Path,HDC hDC,RECT rect) +{ + HDC hDCMem = ::CreateCompatibleDC(hDC);//DC + + HBITMAP hBitMap = ::CreateCompatibleBitmap(hDC, rect.right, rect.bottom);//λͼ + HBITMAP hOldMap = (HBITMAP)::SelectObject(hDCMem, hBitMap);//λͼѡDC淵ֵ + + ::BitBlt(hDCMem, 0, 0, rect.right, rect.bottom, hDC, 0, 0, SRCCOPY);//ĻDCͼƵڴDC + + CImage image; + image.Attach(hBitMap); + image.Save(Path);//ļ׺Ϊ.bmp򱣴ΪΪbmpʽ + image.Detach(); + + ::SelectObject(hDCMem, hOldMap);//ѡϴεķֵ + + //ͷ + ::DeleteObject(hBitMap); + ::DeleteDC(hDCMem); + //::DeleteDC(hDC); +} +//Ϊbmp ļ +void CPrintViewMgr::SaveToBmpFile(HDC hDC,RECT rect) +{ + TCHAR szFilters[]=("BMP ļ(*.bmp)|*.bmp"); + CFileDialog dlg(FALSE,("bmp"),("BmpFile"),OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilters); + if(dlg.DoModal()==IDOK) + { + PrintViewToBmpExt(dlg.GetPathName(),hDC,rect); + } +} \ No newline at end of file diff --git a/LaipuDrawing/PrintView.h b/LaipuDrawing/PrintView.h new file mode 100644 index 0000000..eee7a3a --- /dev/null +++ b/LaipuDrawing/PrintView.h @@ -0,0 +1,15 @@ +#pragma once + + +//ӡǰview +class CPrintViewMgr +{ +public: + CPrintViewMgr(void); + ~CPrintViewMgr(void); + CString GetPrintViewFullFilePath(); + void SaveToBmpFile(HDC hDC,RECT rect); + void PrintViewToBmp(HDC hDC,RECT rect); + void PrintViewToBmpExt(CString Path,HDC hDC,RECT rect); +}; + diff --git a/LaipuDrawing/ProgramLaserTuiHuo.cpp b/LaipuDrawing/ProgramLaserTuiHuo.cpp new file mode 100644 index 0000000..639331b --- /dev/null +++ b/LaipuDrawing/ProgramLaserTuiHuo.cpp @@ -0,0 +1,713 @@ +#include "StdAfx.h" +#include "ProgramLaserTuiHuo.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "WorkTime.h" +#include "FileMgr.h" +#include "WorkFileMgr.h" +#include "Layer.h" +#include "ObjFillMgr.h" +#include "Laser.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "MsgBox.h" +#include "CStringFuc.h" +#include "Layer.h" +#include "PenParMgr.h" +#include "ObjBase.h" +#include "ObjContainer.h" +#include "ExceptionMsg.h" +#include "WorkRecord.h" +#include "WorkAreaMgr.h" +#include "PenParMgr.h" +#include "CommonFlowMgr.h" +#include "LaserPowCheckMgr.h" +#include "EncryptionMgr.h" +#include "TimingProgressMgr.h" +#include "AllThreadMgr.h" +#include "ObjPline.h" +#include "CommomText.h" +#include "WaferRecipeDataMgr.h" +#include "WarningMgr.h" +#include "AllThreadMgr.h" +#include "ModuleDeviceMgr.h" + + + +#define CYCLIC_RUN_TIMES_FILE _T("\\CommPar\\CyclicRun.bin") + + +#define SCAN_AREA_FILE_PATH _T("\\ScanArea\\") + +#define CUR_SOFT_VISION "v 2.1.5" //ǰ汾 + + +//̿߳(ѭ) +UINT AutoWorkFlowCtrlThread(LPVOID pParam) +{ + CProgramLaserTuiHuo *p = (CProgramLaserTuiHuo *)pParam; + p->AutoWorkFlowCtrl(); + return 0; +} + +//ִһ߳(ִһ) +UINT ExecuteStepThread(LPVOID pParam) +{ + CProgramLaserTuiHuo *p = (CProgramLaserTuiHuo *)pParam; + p->ExecuteCurStep(); + return 0; +} + +CProgramLaserTuiHuo *gProgramLaserTuiHuo = new CProgramLaserTuiHuo; +CProgramLaserTuiHuo::CProgramLaserTuiHuo(void) +{ + m_pMeasureThread = NULL;//߳ + m_bCheckLaserPar = true;//ӹǰʵʼǷƥ + + m_BackTime2Mins = 300;//߼ʱ(رյԴ)() + m_CurAutoWorkStep = _AutoWork_Step_Stop; + m_OldAutoWorkStep = _AutoWork_Step_Stop; + m_bAutoWorking = false;//ǷԶ + m_bStopAfterThisCycle = false;//ѭֹͣ + m_bAutoPowerMode = false;//Զƥģʽ + m_bStopWork = false;//Ƿֹͣ + m_bLockAllDlgPane = true;// + m_bAutoTransferMode = false;//ԶƬģʽ + m_bLastWaferEnd = false;//ǷΪһƬ + + m_bLockCurRecipe = false;//ǰrecipe ʾ(ֵ) + + m_bCyclicRunMode = false;//ǷCyclicRun ģʽ + m_bCyclicRunExcuting = false;//CyclicRun Ƿִ + + m_AllCyclicWaferCnt = 0;//CyclicRun Wafer + m_CurCyclicWaferCnt = 0;//CyclicRun Wafer + m_WaferScanType = 0;//wafer ɨ跽ʽ + m_RecoverScanIdxAdjust = 1;//ָɨ·ǰĵڼ߿ʼ(ֵ) + + m_CurLaserPathBmpId = IDB_BTN_IMG21;//ǰ·ͼID + m_CurAnnealPercent = 0;//ǰ˻ɶ + m_bSoftInitComplete = false;//ʼǷ + + m_DeviceID = "LA2540G";//ǰ豸ı(ʾ) + + m_CurSoftVision = CUR_SOFT_VISION;//ǰ汾 + + m_LaipuLaserDataDir = "E:\\LaipuLaserData";//Ŀ¼,E:\LaipuLaserData +} +CProgramLaserTuiHuo::~CProgramLaserTuiHuo(void) +{ +} +CMFCPropertyGridProperty *CProgramLaserTuiHuo::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = GetParDirName();//洢· + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T("˻豸"); + GroupName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + + { + //Աӳ + Name = _T("m_bLockAllDlgPane");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bLockAllDlgPane); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T(""); + Description = _T(""); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bLockAllDlgPane, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bLockCurRecipe");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bLockCurRecipe); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Recipeʾ"); + Description = _T("ǰRecipeʾ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bLockCurRecipe, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_LaipuLaserDataDir");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_LaipuLaserDataDir); + pPropertie->SetType(_PROP_TYPE_STRING); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Ŀ¼"); + Description = _T("ݴ洢Ŀ¼(Ч)"); + + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + pPropertie->SetModuleName(ModuleName); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LaipuLaserDataDir, Description); + pGroup->AddSubItem(p); + gDevicePropertieMgr.Insert(p, pPropertie); + } + { + //Աӳ + Name = _T("m_ObjTxtFilePath");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_ObjTxtFilePath); + pPropertie->SetType(_PROP_TYPE_STRING); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Obj Txt ·"); + Description = _T("Obj Txt ·"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_ObjTxtFilePath, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_DeviceID");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_DeviceID); + pPropertie->SetType(_PROP_TYPE_STRING); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("豸ID"); + Description = _T("ǰ豸ID"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_DeviceID, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_WorkRecordFilePath");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WorkRecordFilePath); + pPropertie->SetType(_PROP_TYPE_STRING); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ӹ¼·"); + Description = _T("ӹ¼ ļ·"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_WorkRecordFilePath, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_BackTime2Mins");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_BackTime2Mins); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("߼ʱ"); + Description = _T("߼ʱ()"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_BackTime2Mins, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_WaferScanType");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WaferScanType); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ɨ跽ʽ"); + Description = _T("0:S 1:S ҵ2:ϵ3:µ4:S ϵ5:S µ6:7:ҵ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_WaferScanType, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_RecoverScanIdxAdjust");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_RecoverScanIdxAdjust); + pPropertie->SetType(_PROP_TYPE_INT); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ָɨߵ"); + Description = _T("ָɨ·ǰĵڼ߿ʼ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_RecoverScanIdxAdjust, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + } +//-------------------------------------------------------------------------------// + return pGroup; +} +//ӦԵı仯 +void CProgramLaserTuiHuo::OnPropertyChanged() +{ + //沼 + GetFrame()->LockPane(m_bLockAllDlgPane); + m_pView->RefreshView(); + +} +#if 1 +void CProgramLaserTuiHuo::OnAppInitialize() +{ + CWorkTime WorkTime; + m_AppOpenTime = WorkTime.GetDateTime("/",":");//¼򿪵ʱ + + //浱ǰļĿ¼ + //m_LaipuLaserDataDirҪЧ + m_CurLaipuLaserDataDir= m_LaipuLaserDataDir; +} +void CProgramLaserTuiHuo::OnExitApp() +{ +} +//Ͻ˳ť(ǷԹرճ) +bool CProgramLaserTuiHuo::CloseAppCheck() +{ + if(gAuthorityMgr->IsbLoginDlgOpen()) + { + gLogMgr->WriteDebugLog("CloseAppCheck-->LoginDlgOpen"); + return false; + } + CMsgBox MsgBox; + if(MsgBox.ConfirmOkCancel("رճ?")==false) + return false; + return true;//Թر +} + +//ǷΪɨ +bool CProgramLaserTuiHuo::IsOneDirScanType() +{ + if((m_WaferScanType==2) ||(m_WaferScanType==3)||(m_WaferScanType==6)||(m_WaferScanType==7)) + return true; + return false; +} +//ͨϵͳϢر +void CProgramLaserTuiHuo::CloseAppBySysMsg() +{ + gLogMgr->WriteDebugLog("Func--->CloseAppBySysMsg"); + + HWND hWnd; + CString WndName = "LaiPuDrawing - [ޱ]"; + hWnd = (HWND)::FindWindow(NULL,WndName); + if(hWnd != NULL) + { + ::SendMessage(hWnd,WM_SYSCOMMAND, SC_CLOSE,0); + } +} +// +void CProgramLaserTuiHuo::ReStartApp() +{ + gLogMgr->WriteDebugLog("Func--->ReStartApp"); + //õǰ· + char strPath[100]; + GetModuleFileName(NULL,strPath,100); + //ػ̣½̳ɹWM_QUITϢԭḶ̌ + STARTUPINFO startInfo; + PROCESS_INFORMATION processInfo; + ZeroMemory(&startInfo, sizeof(STARTUPINFO)); + startInfo.cb = sizeof(STARTUPINFO); + if(CreateProcess(NULL,(LPTSTR)(LPCTSTR)strPath, NULL, NULL,FALSE, 0, NULL, NULL, &startInfo, &processInfo)) + { + CloseHandle( processInfo.hProcess ); + CloseHandle( processInfo.hThread ); + PostQuitMessage(WM_CLOSE); + } +} + +#endif +#if 1 +//ӹ(bAutoMode = true ԶƬģʽ=false ֶ˻) +//Job start һ +bool CProgramLaserTuiHuo::StartWork(bool bAutoMode) +{ + + return true; +} +//ӹǰ׼(ҪִеIJ) +bool CProgramLaserTuiHuo::StartWorkPrepare() +{ + + return true; +} +#endif + +#if 1//Զ̹ +//õǰĹ +void CProgramLaserTuiHuo::SetCurAutoWorkStep(EAutoWorkStep Step) +{ + //޷ֹͣ + if(Step==_AutoWork_Step_Stop) + { + m_OldAutoWorkStep = _AutoWork_Step_NULL; + m_CurAutoWorkStep = _AutoWork_Step_NULL; + } + CString Log; + switch(Step) + { + case _AutoWork_Step_Transfer_Load:// + Log = "_AutoWork_Step_Transfer_Load"; + break; + case _AutoWork_Step_Tuihuo_Progress://˻ + Log = "_AutoWork_Step_Tuihuo_Progress"; + break; + case _AutoWork_Step_Transfer_UnLoad:// + Log = "_AutoWork_Step_Transfer_UnLoad"; + break; + case _AutoWork_Step_Stop://ֹͣ + Log = "_AutoWork_Step_Stop"; + break; + case _AutoWork_Step_NULL://ֹͣ + Log = "_AutoWork_Step_NULL"; + break; + default: + break; + } + Log = "Flow---->SetCurAutoWorkStep : " + Log; + gLogMgr->WriteDebugLog(Log); + + m_CurAutoWorkStep = Step; +} +//̿ +void CProgramLaserTuiHuo::AutoWorkFlowCtrl() +{ + while(1) + { + //ʱֹͣ߳ + if(gAllThreadMgr.IsbStopAllThread()) + break; + //߳̿ʼ + gAllThreadMgr.SetThreadInfoState(_EThreadType_AutoWorkFlowCtrlThread,true); + Sleep(500); + + if(m_CurAutoWorkStep == m_OldAutoWorkStep)//ޱ仯 + continue; + if(m_bAutoWorking) + { + //¼ǰ + m_OldAutoWorkStep = m_CurAutoWorkStep; + if(m_CurAutoWorkStep != _AutoWork_Step_NULL) + { + //ִ߳ÿ + AfxBeginThread(ExecuteStepThread,this); + } + } + } + //߳̽ + gAllThreadMgr.SetThreadInfoState(_EThreadType_AutoWorkFlowCtrlThread,false); +} +//ִеǰ +void CProgramLaserTuiHuo::ExecuteCurStep() +{ + if(gExitApp) + return; + gAllThreadMgr.SetThreadInfoState(_EThreadType_ExecuteStepThread,true); + + switch(m_CurAutoWorkStep) + { + case _AutoWork_Step_Transfer_Load:// + OnLoadWaferToPlat(); + break; + case _AutoWork_Step_Tuihuo_Progress://˻ + OnTuiHuoProgress(); + break; + case _AutoWork_Step_Transfer_UnLoad:// + OnUnLoadPlatWaferToPod(); + break; + case _AutoWork_Step_Stop://ֹͣ + OnWorkStop(); + break; + default: + break; + } + //ǰִֹԶ + if(!m_bAutoWorking && m_CurAutoWorkStep!= _AutoWork_Step_Stop && m_CurAutoWorkStep!= _AutoWork_Step_NULL) + { + OnWorkStop(); + } + gAllThreadMgr.SetThreadInfoState(_EThreadType_ExecuteStepThread,false); +} +//ѭֹͣ +void CProgramLaserTuiHuo::StopAftrThisCycle() +{ + m_bStopAfterThisCycle = true; + gLogMgr->WriteDebugLog("Func---->Stop After This Cycle"); +} +#endif +#if 1//Ƭصĸ +//Ƿ׼Load +bool CProgramLaserTuiHuo::IsReadyToLoad() +{ + + return false; +} +//Ƿload +bool CProgramLaserTuiHuo::IsLoadEnd() +{ + + return false; +} +//Ƿ׼Unload +bool CProgramLaserTuiHuo::IsReadyToUnload() +{ + + return false; +} +//Ƿunload +bool CProgramLaserTuiHuo::IsUnloadEnd() +{ + + return false; +} +//Ƿδwafer +bool CProgramLaserTuiHuo::HasUntreatedWafer() +{ + + return false; +} +#endif +#if 1 +//load wafer +bool CProgramLaserTuiHuo::OnLoadWaferToPlat() +{ + + return true; +} +//ӹ(Զģʽֱӽһ) +void CProgramLaserTuiHuo::OnTuiHuoProgress() +{ + +} +void CProgramLaserTuiHuo::OnTuiHuoProgressExt() +{ + + +} +//wafer ϴ䵽pod +bool CProgramLaserTuiHuo::OnUnLoadPlatWaferToPod() +{ + + return true; +} +//(Job ֹ߽ͣ) +void CProgramLaserTuiHuo::OnWorkStop() +{ + +} +#endif +#if 1 +//ֶ +void CProgramLaserTuiHuo::ManualTransferLoad() +{ + + +} +//ֶ +void CProgramLaserTuiHuo::ManualTransferUnLoad() +{ + + +} +//ֶarm/׼ֱϵwafer ˻Ϻ +void CProgramLaserTuiHuo::ManualArmAlignerUnLoad() +{ + +} +//һ(/Arm2 ֱ۵wafer) +void CProgramLaserTuiHuo::ManualRecoverAllWafer() +{ + +} +#endif +#if 1 +UINT CyclicRunThread(LPVOID pParam) +{ + CProgramLaserTuiHuo *p = (CProgramLaserTuiHuo *)pParam; + p->CyclicRun(); + return 0; +} +//ӦCyclicRun +void CProgramLaserTuiHuo::OnClickeCyclicRun() +{ + +} +//ǷܽCyclicRun +bool CProgramLaserTuiHuo::CheckCyclicRunCondition() +{ + + return true; +} +//CyclicRun +void CProgramLaserTuiHuo::StartCyclicRunThread() +{ + gLogMgr->WriteDebugLog("Func---->StartCyclicRunThread"); + m_bCyclicRunExcuting = true; + m_bCyclicRunMode = true; + //ִ߳ + AfxBeginThread(CyclicRunThread,this); +} +//ֹͣCyclicRun ģʽ +void CProgramLaserTuiHuo::StopCyclicRunThread() +{ + gLogMgr->WriteDebugLog("Func---->StopCyclicRunThread"); + m_bCyclicRunMode = false; +} + +void CProgramLaserTuiHuo::CyclicRun() +{ + gLogMgr->WriteDebugLog("Func---->CyclicRun"); + while(1) + { + Sleep(CTRL_CYCLIC_RUN_DELAY); + if(gAllThreadMgr.IsbStopAllThread()) + break; + if(!m_bCyclicRunMode) + break; + gAllThreadMgr.SetThreadInfoState(_EThreadType_CyclicRunThread,true); + + CyclicRunExt(); + } + + gAllThreadMgr.SetThreadInfoState(_EThreadType_CyclicRunThread,false); + + m_bCyclicRunExcuting = false; + gLogMgr->WriteDebugLog("Func---->CyclicRun End"); +} +void CProgramLaserTuiHuo::CyclicRunExt() +{ + +} +void CProgramLaserTuiHuo::ClearCyclicWaferCnt() +{ + CMsgBox MsgBox; + if(MsgBox.ConfirmOkCancel("Cur Run Times ?")) + { + m_CurCyclicWaferCnt = 0; + gLogMgr->WriteDebugLog("Func---->ClearCyclicWaferCnt"); + } +} +//ȡǰCyclic +CString CProgramLaserTuiHuo::GetCyclicWaferCnt() +{ + return Int2CString(m_AllCyclicWaferCnt); +} +CString CProgramLaserTuiHuo::GetCurCyclicWaferCnt() +{ + return Int2CString(m_CurCyclicWaferCnt); +} + +//ۼӵǰCyclic +void CProgramLaserTuiHuo::CyclicWaferInc() +{ + if(!m_bCyclicRunMode) + return; + m_AllCyclicWaferCnt++; + m_CurCyclicWaferCnt++; + WriteCyclicWaferCntToFile(m_AllCyclicWaferCnt); +} +//Cyclic дļ +void CProgramLaserTuiHuo::WriteCyclicWaferCntToFile(int CyclicWaferCnt) +{ + CString s; + s.Format("Func---->WriteCyclicWaferCntToFile : %ld",CyclicWaferCnt); + gLogMgr->WriteDebugLog(s); + + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,CYCLIC_RUN_TIMES_FILE); + + ofstream FileStream; + FileStream.open(FilePath); + FileStream< StrVec; + FileMgr.ReadFileToStringVec(FilePath,StrVec); + if(StrVec.size()>0) + { + m_AllCyclicWaferCnt = CStringToInt(StrVec[0]); + CString s; + s.Format("Func---->ReadCyclicWaferCntFromFile : %ld",m_AllCyclicWaferCnt); + gLogMgr->WriteDebugLog(s); + } +} +#endif +#if 1 +//"E:\\LaipuLaserData" +CString CProgramLaserTuiHuo::GetLaipuLaserDataDir(CString Path) +{ + CString DataDir = m_CurLaipuLaserDataDir; + DataDir += Path; + return DataDir; +} +CString CProgramLaserTuiHuo::GetScanAreaFilePath() +{ + CString ScanAreaFilePath = GetLaipuLaserDataDir(SCAN_AREA_FILE_PATH); + return ScanAreaFilePath; +} + +#endif diff --git a/LaipuDrawing/ProgramLaserTuiHuo.h b/LaipuDrawing/ProgramLaserTuiHuo.h new file mode 100644 index 0000000..5434bce --- /dev/null +++ b/LaipuDrawing/ProgramLaserTuiHuo.h @@ -0,0 +1,157 @@ +#pragma once +#include "module.h" +#include "GlobalDefine.h" +#include "RecipeMgr.h" + + +enum EAutoWorkStep +{ + _AutoWork_Step_NULL = 0, + _AutoWork_Step_Stop,//ֹͣ״̬ + _AutoWork_Step_Transfer_Load,//Load Բ + _AutoWork_Step_Tuihuo_Progress,//ӹ + _AutoWork_Step_Transfer_UnLoad,//UnLoad Բ + +}; + +//˻豸 +class CProgramLaserTuiHuo :public CModule +{ +public: + CProgramLaserTuiHuo(void); + ~CProgramLaserTuiHuo(void); + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual void OnPropertyChanged(); + virtual MODULE GetModuleType(){return _PROGRAM_LASER_ANEAL_PROP;}; + virtual CString GetParDirName(){return "CProgramLaserTuiHuo";}; + virtual void OnAppInitialize(); + + virtual void OnExitApp(); + void ReadMachiningModeFile(int Idx); + void FastReadInfo(); + void SlowReadInfo(); + void SetListCheckVec(vector vec){m_ListCheckVec = vec;}; + vector GetListCheckVec(){return m_ListCheckVec;}; + bool StartWork(bool bAutoMode); + CString GetAppOpenTime(){return m_AppOpenTime;}; + void AutoWorkFlowCtrl(); + void ExecuteCurStep(); + void SetCurAutoWorkStep(EAutoWorkStep Step); + EAutoWorkStep GetCurAutoWorkStep(){return m_CurAutoWorkStep;}; + bool StartWorkPrepare(); + bool IsbAutoWorking(){return m_bAutoWorking;}; + bool IsbStopAfterThisCycle(){return m_bStopAfterThisCycle;}; + void StopAftrThisCycle(); + bool IsbAutoPowerMode(){return m_bAutoPowerMode;}; + void SetbAutoPowerMode(bool b){m_bAutoPowerMode = b;}; + bool IsbStopWork(){return m_bStopWork;}; + bool CloseAppCheck(); + + bool ReadDlgItemSizeFile(CString FilePath); + void AdjustItemSize(CWnd *pWnd,int Idx); + bool IsbArmAutoMode(){return m_bAutoTransferMode;}; + CString GetScanAreaFilePath(); + CString GetObjTxtFilePath(){return m_ObjTxtFilePath;}; + void ManualTransferLoad(); + void ManualTransferUnLoad(); + bool IsbLockAllDlgPane(){return m_bLockAllDlgPane;}; + int GetBackTime2Mins(){return m_BackTime2Mins;}; + bool OnLoadWaferToPlat(); + bool OnUnLoadPlatWaferToPod(); + void ManualArmAlignerUnLoad(); + bool IsbFirstWafer(){return m_bFirstWafer;}; + void SetbFirstWafer(bool b){m_bFirstWafer = b;}; + bool IsbLockCurRecipe(){return m_bLockCurRecipe;}; + void OnClickeCyclicRun(); + void SetbCyclicRunMode(bool b){m_bCyclicRunMode = b;}; + bool IsbCyclicRunMode(){return m_bCyclicRunMode;}; + bool IsbCyclicRunExcuting(){return m_bCyclicRunExcuting;}; + void CyclicRun(); + void StopCyclicRunThread(); + void SetCyclicRunRecipe(CRecipe Recipe){m_CyclicRecipe = Recipe;}; + CString GetCyclicWaferCnt(); + CString GetCurCyclicWaferCnt(); + void CyclicWaferInc(); + void ClearCyclicWaferCnt(); + int GetWaferScanType(){return m_WaferScanType;}; + bool IsOneDirScanType(); + int GetRecoverScanIdxAdjust(){return m_RecoverScanIdxAdjust;}; + CString GetWorkRecordFilePath(){return m_WorkRecordFilePath;}; + void ManualRecoverAllWafer(); + int GetLaserPathBmpId(){return m_CurLaserPathBmpId;}; + void SetbSoftInitComplete(bool b){m_bSoftInitComplete = b;}; + bool IsbSoftInitComplete(){return m_bSoftInitComplete;}; + double GetCurAnnealPercent(){return m_CurAnnealPercent;}; + void SetCurAnnealPercent(double val){m_CurAnnealPercent = val;}; + CString GetDeviceID(){return m_DeviceID;}; + CString GetCurSoftVision(){return m_CurSoftVision;}; + void CloseAppBySysMsg(); + CString GetLaipuLaserDataDir(CString Path); + void ReStartApp(); +private: + void OnTuiHuoProgress(); + void OnWorkStop(); + bool IsReadyToLoad(); + bool IsLoadEnd(); + bool IsReadyToUnload(); + bool IsUnloadEnd(); + bool HasUntreatedWafer(); + void StartCyclicRunThread(); + bool CheckCyclicRunCondition(); + void CyclicRunExt(); + void WriteCyclicWaferCntToFile(int CyclicWaferCnt); + void ReadCyclicWaferCntFromFile(); + void OnTuiHuoProgressExt(); +private: + CWinThread* m_pMeasureThread;//߳ + + bool m_bCheckLaserPar;//ӹǰʵʼǷƥ + bool m_bExitApp;//Ƿ˳ + bool m_bFirstWafer;//ǷΪһƬwafer 㿪ʼ֮ĵһƬ + + int m_BackTime2Mins;//߼ʱ(رյԴ)()(ֵ) + + vector m_ListCheckVec;//ѡ״̬ + CString m_AppOpenTime;//򿪵ʱ + + EAutoWorkStep m_CurAutoWorkStep;//ǰĹ + EAutoWorkStep m_OldAutoWorkStep;//֮ǰĹ(жǷ仯) + bool m_bAutoWorking;//ǷԶ + bool m_bStopAfterThisCycle;//ѭֹͣ + EAutoWorkStep m_ExcuteStartWorkStep;//㿪ʼӹʱִеIJ + + bool m_bAutoPowerMode;//Զƥģʽ + bool m_bAutoTransferMode;//ԶƬģʽ + bool m_bStopWork;//Ƿֹͣ + COffsetRotatoPar m_WaferOffsetRotatoPar;//ǰڼӹľԪλò + + CString m_ObjTxtFilePath;//obj Txt·(ֵ) + CString m_WorkRecordFilePath;//ӹ¼ ļ·(ֵ) + + bool m_bLockAllDlgPane;//(ֵ) + bool m_bLockCurRecipe;//ǰrecipe ʾ(ֵ) + + bool m_bLastWaferEnd;//ǷΪһƬ + + bool m_bCyclicRunMode;//ǷCyclicRun ģʽ + bool m_bCyclicRunExcuting;//CyclicRun Ƿִ + CRecipe m_CyclicRecipe;//CyclicRun ʹõRecipe + int m_AllCyclicWaferCnt;//CyclicRun Wafer (ȫ) + int m_CurCyclicWaferCnt;//CyclicRun Wafer (ǰ) + + int m_WaferScanType;//wafer ɨ跽ʽ + int m_RecoverScanIdxAdjust;//ָɨ·ǰĵڼ߿ʼ(ֵ) + + + int m_CurLaserPathBmpId;//ǰ·ͼID + + bool m_bSoftInitComplete;//ʼǷ + double m_CurAnnealPercent;//ǰ˻ɶ + CString m_DeviceID;//ǰ豸ı(ʾ) + CString m_CurSoftVision;//ǰ汾 + + CString m_LaipuLaserDataDir;//洢Ŀ¼,E:\LaipuLaserData (ֵ) + CString m_CurLaipuLaserDataDir;//ǰ洢Ŀ¼ +}; + +extern CProgramLaserTuiHuo *gProgramLaserTuiHuo; diff --git a/LaipuDrawing/ProgressMgr.cpp b/LaipuDrawing/ProgressMgr.cpp new file mode 100644 index 0000000..9dacac8 --- /dev/null +++ b/LaipuDrawing/ProgressMgr.cpp @@ -0,0 +1,29 @@ +#include "StdAfx.h" +#include "ProgressMgr.h" +#include "GlobalFunction.h" + + + +CProgressMgr gProgressMgr; +CProgressMgr::CProgressMgr(void) +{ + m_WorkProgress = NULL; +} +CProgressMgr::~CProgressMgr(void) +{ +} +//õǰ +void CProgressMgr::SetCurProgress(int cur,int total) +{ + if(gExitApp) + return; + + if(cur<=total && total != 0) + { + double progress = (static_cast(cur)/static_cast(total))*100; + if(m_WorkProgress) + { + m_WorkProgress->SetPos(static_cast(progress)); + } + } +} \ No newline at end of file diff --git a/LaipuDrawing/ProgressMgr.h b/LaipuDrawing/ProgressMgr.h new file mode 100644 index 0000000..197bba3 --- /dev/null +++ b/LaipuDrawing/ProgressMgr.h @@ -0,0 +1,19 @@ +#pragma once +#include "Observer.h" + +//ӹȹ +class CProgressMgr +{ +public: + CProgressMgr(void); + ~CProgressMgr(void); + void SetWorkProgress(CProgressCtrl *p){m_WorkProgress = p;}; + void SetCurProgress(int cur,int total); + void SetCurProgress(double val); + void ResetStopState(); + bool GetStopState(); +private: + CProgressCtrl *m_WorkProgress; +}; + +extern CProgressMgr gProgressMgr; \ No newline at end of file diff --git a/LaipuDrawing/Propertie.cpp b/LaipuDrawing/Propertie.cpp new file mode 100644 index 0000000..fce5fda --- /dev/null +++ b/LaipuDrawing/Propertie.cpp @@ -0,0 +1,154 @@ +#include "StdAfx.h" +#include "Propertie.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "CStringFuc.h" + + +CPropertie::CPropertie() +{ + m_pVal = NULL; + m_pModule = NULL; +} +CPropertie::~CPropertie() +{ +} +//ıԵֵ֪ͨԶӦģ +void CPropertie::PropertyChangeVal(const COleVariant &OleVar) +{ + //if(m_Name.GetLength()<=0) + //return; + CString Log; + switch(m_Type) + { + case _PROP_TYPE_BOOL: + Log.Format("[%s]---->[%s]",Bool2Str(*((bool *)m_pVal)),Bool2Str(OleVar.boolVal)); + *((bool *)m_pVal) = OleVar.boolVal; + break; + case _PROP_TYPE_COLOR: + *((COLORREF *)m_pVal) = (COLORREF)OleVar.lVal; + break; + case _PROP_TYPE_DOUBLE: + Log.Format("[%lf]---->[%lf]",(*((double *)m_pVal)),(OleVar.dblVal)); + *((double *)m_pVal) = OleVar.dblVal; + break; + case _PROP_TYPE_INT: + Log.Format("[%ld]---->[%ld]",(*((int *)m_pVal)),(OleVar.lVal)); + *((int *)m_pVal) = OleVar.lVal; + break; + case _PROP_TYPE_STRING: + Log.Format("[%s]---->[%s]",(*((CString *)m_pVal)),(OleVar.bstrVal)); + *((CString *)m_pVal) = OleVar.bstrVal; + break; + default: + break; + } + CString str("PropertyChange :"); + Log = m_Name + Log; + Log = str + Log; + gLogMgr->WriteDebugLog(Log); + //дļ + WriteRead(false); + //֪ͨӦģԱ仯 + if(m_pModule) + { + m_pModule->OnPropertyChanged(); + } +} +void CPropertie::WriteRead(bool bRead) +{ + CString FileName = _T("\\Parameter\\") + m_Path + _T("\\")+m_Name+_T(".var"); + if(bRead) + ReadFromFile(FileName); + else + WriteToFile(FileName); +} +//浽ļ +void CPropertie::WriteToFile(CString &FileName) +{ + CFileMgr FileMgr; + char filepath[1024]; + FileMgr.GetFullFilePath(filepath,FileName);//ȡ· + CFile file(filepath,CFile::modeReadWrite|CFile::modeCreate); + CArchive ar(&file,CArchive::store); + + switch(m_Type) + { + case _PROP_TYPE_BOOL: + ar<<(*((bool *)m_pVal)); + break; + case _PROP_TYPE_DOUBLE: + ar<<(*((double *)m_pVal)); + break; + case _PROP_TYPE_INT: + ar<<(*((int *)m_pVal)); + break; + case _PROP_TYPE_COLOR: + ar<<(*((int *)m_pVal)); + break; + case _PROP_TYPE_STRING: + ar<<(*((CString *)m_pVal)); + break; + default: + break; + } +} +void CPropertie::WriteToStream(ofstream &FileStream) +{ + bool b; + switch(m_Type) + { + case _PROP_TYPE_BOOL: + b = (*((bool *)m_pVal)); + FileStream<>(*((bool *)m_pVal)); + break; + case _PROP_TYPE_DOUBLE: + ar>>(*((double *)m_pVal)); + break; + case _PROP_TYPE_INT: + ar>>(*((int *)m_pVal)); + break; + case _PROP_TYPE_COLOR: + ar>>(*((int *)m_pVal)); + break; + case _PROP_TYPE_STRING: + ar>>(*((CString *)m_pVal)); + break; + default: + break; + } + } +} + diff --git a/LaipuDrawing/Propertie.h b/LaipuDrawing/Propertie.h new file mode 100644 index 0000000..a5f65d5 --- /dev/null +++ b/LaipuDrawing/Propertie.h @@ -0,0 +1,42 @@ +#pragma once +#include "GlobalDefine.h" +#include "EnumPropertieType.h" + + +class CModule; +//ģ +class CPropertie +{ + friend class CPropertieMgr; +public: + CPropertie(); + ~CPropertie(); + void SetpVal(void *pVal){m_pVal = pVal;}; + void SetType(PROPERTIE_TYPE Type){m_Type = Type;}; + void SetpModule(CModule *pModule){m_pModule = pModule;}; + void SetName(CString &Name){m_Name = Name;}; + void SetPath(CString &Path){m_Path = Path;}; + void SetGroupName(CString &s){m_GroupName = s;}; + void SetShowName(CString &s){m_ShowName = s;}; + void SetModuleName(CString &s){m_ModuleName = s;}; + void PropertyChangeVal(const COleVariant &OleVar); + void WriteRead(bool bRead); + CString GetPropertieName(){return m_Name;}; + void WriteToStream(ofstream &FileStream); +private: + void WriteToFile(CString &FileName); + void ReadFromFile(CString &FileName); +private: + void * m_pVal;//ڴַ + PROPERTIE_TYPE m_Type;//Ե + CModule* m_pModule;//ģĵַ + CString m_Path;//洢· + CString m_Name;// + + CString m_ModuleName;//ģ + CString m_GroupName;// + CString m_ShowName;//ʾ + +}; + + diff --git a/LaipuDrawing/PropertieMgr.cpp b/LaipuDrawing/PropertieMgr.cpp new file mode 100644 index 0000000..c35aee2 --- /dev/null +++ b/LaipuDrawing/PropertieMgr.cpp @@ -0,0 +1,140 @@ +#include "StdAfx.h" +#include "PropertieMgr.h" +#include "Propertie.h" +#include "LogMgr.h" + + +CPropertieMgr gDevicePropertieMgr;//豸Թ +CPropertieMgr gDrawPropertieMgr;//Թ + +CPropertieMgr::CPropertieMgr(void) +{ + m_bSaveAllPropertie = true;//Ҫ洢 +} +CPropertieMgr::~CPropertieMgr(void) +{ + //ɾ + DelAllPropertie(); + DelAllPropertieVec(); +} +//ӦԱ仯-->֪ͨӦģ +void CPropertieMgr::OnPropertyChanged(LPARAM lParam) +{ + CMFCPropertyGridProperty*pProp = (CMFCPropertyGridProperty*)lParam; + //ȡӳ + if (m_PropertieValMap.count(pProp)) + { + CPropertie *pPropertie = m_PropertieValMap[pProp]; + pPropertie->PropertyChangeVal(pProp->GetValue());//ֵ + } +} +//ӳ +void CPropertieMgr::Insert(CMFCPropertyGridProperty* p1,CPropertie* p2) +{ + if(m_bSaveAllPropertie) + { + m_AllPropertieVec.push_back(p2); + } + else + { + m_PropertieValMap.insert(make_pair(p1, p2)); + } +} +void CPropertieMgr::DelAllPropertieVec() +{ + vector::iterator iter = m_AllPropertieVec.begin(); + vector::iterator iter_end = m_AllPropertieVec.end(); + for(;iter!=iter_end;iter++) + { + CPropertie *pPropertie = (*iter); + if(pPropertie) + { + delete pPropertie; + } + } +} +//ɾ +void CPropertieMgr::DelAllPropertie() +{ + map::iterator iter = m_PropertieValMap.begin(); + map::iterator iter_end = m_PropertieValMap.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).second) + { + delete (*iter).second; + } + } + m_PropertieValMap.clear(); +} + +//ֵָIJ(Ҫ޸ĵIJ) +void CPropertieMgr::SavePropertieByName(vector &PropertieNameVec) +{ + vector::iterator iter = m_AllPropertieVec.begin(); + vector::iterator iter_end = m_AllPropertieVec.end(); + for(;iter!=iter_end;iter++) + { + CPropertie *pPropertie = (*iter); + if(pPropertie) + { + int size = PropertieNameVec.size(); + for(int k=0;kGetPropertieName()==PropertieNameVec[k]) + { + pPropertie->WriteRead(false); + CString s; + s = "Par---->Save Par By Name: "+PropertieNameVec[k]; + gLogMgr->WriteDebugLog(s); + break; + } + } + } + } +} +#if 1 +//Եһıļ +void CPropertieMgr::SaveAllPropertieToTxtFile(CString FilePath) +{ + gLogMgr->WriteDebugLog("Func---->SaveAllPropertieToTxtFile"); + ofstream FileStream; + FileStream.open(FilePath); + set PropertieSet; + + CString CurGroupName; + CString NewGroupName; + CString CurModuleName; + CString NewModuleName; + + vector::iterator iter = m_AllPropertieVec.begin(); + vector::iterator iter_end = m_AllPropertieVec.end(); + for(;iter!=iter_end;iter++) + { + CPropertie *pPropertie = (*iter); + if(PropertieSet.count(pPropertie->m_pVal))//ظIJ + continue; + PropertieSet.insert(pPropertie->m_pVal); + + if(pPropertie && pPropertie->m_ShowName !="") + { + NewModuleName = (pPropertie->m_ModuleName); + if(NewModuleName != "" && CurGroupName != NewModuleName) + { + CurModuleName = NewModuleName; + FileStream<<"<--------------------------["<\n"; + } + NewGroupName = (pPropertie->m_GroupName); + if(NewGroupName != "" && CurGroupName != NewGroupName) + { + CurGroupName = NewGroupName; + FileStream<<"<---------------["<\n"; + } + FileStream<<"["<<(pPropertie->m_ShowName)<<"]"; + FileStream<<"["; + pPropertie->WriteToStream(FileStream); + FileStream<<"]\n"; + } + } +} +#endif \ No newline at end of file diff --git a/LaipuDrawing/PropertieMgr.h b/LaipuDrawing/PropertieMgr.h new file mode 100644 index 0000000..9563199 --- /dev/null +++ b/LaipuDrawing/PropertieMgr.h @@ -0,0 +1,27 @@ +#pragma once +#include "GlobalDefine.h" + +class CPropertie; + +//ģ--Եӳ +class CPropertieMgr +{ +public: + CPropertieMgr(void); + ~CPropertieMgr(void); + void Insert(CMFCPropertyGridProperty* p1,CPropertie* p2); + void OnPropertyChanged(LPARAM lParam); + void DelAllPropertie(); + void SetSaveAllPropertie(bool b){m_bSaveAllPropertie = b;}; + void SavePropertieByName(vector &PropertieNameVec); + void SaveAllPropertieToTxtFile(CString FilePath); +private: + void DelAllPropertieVec(); +private: + map m_PropertieValMap;//ӳ + bool m_bSaveAllPropertie;//Ҫ洢 + vector m_AllPropertieVec;//Ҫ洢(ǿƱ) +}; + +extern CPropertieMgr gDevicePropertieMgr; +extern CPropertieMgr gDrawPropertieMgr;//Թ \ No newline at end of file diff --git a/LaipuDrawing/PropertiesWnd.cpp b/LaipuDrawing/PropertiesWnd.cpp new file mode 100644 index 0000000..11f3489 --- /dev/null +++ b/LaipuDrawing/PropertiesWnd.cpp @@ -0,0 +1,199 @@ + +#include "stdafx.h" + +#include "PropertiesWnd.h" +#include "Resource.h" +#include "MainFrm.h" +#include "LaiPuLaser.h" +#include "Propertie.h" +#include "Module.h" +#include "LogMgr.h" +#include "PropertieMgr.h" +#include "ModuleDeviceMgr.h" + + +#ifdef _DEBUG +#undef THIS_FILE +static char THIS_FILE[]=__FILE__; +#define new DEBUG_NEW +#endif + +///////////////////////////////////////////////////////////////////////////// +// CResourceViewBar + +CPanePropertiesWnd::CPanePropertiesWnd() +{ + m_bUseObjectCombo = true;//ʹб +} +CPanePropertiesWnd::~CPanePropertiesWnd() +{ +} + +BEGIN_MESSAGE_MAP(CPanePropertiesWnd, CDockablePane) + ON_WM_CREATE() + ON_WM_SIZE() + ON_COMMAND(ID_EXPAND_ALL, OnExpandAllProperties) + ON_UPDATE_COMMAND_UI(ID_EXPAND_ALL, OnUpdateExpandAllProperties) + ON_COMMAND(ID_SORTPROPERTIES, OnSortProperties) + ON_UPDATE_COMMAND_UI(ID_SORTPROPERTIES, OnUpdateSortProperties) + ON_WM_SETFOCUS() + ON_WM_SETTINGCHANGE() +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CResourceViewBar Ϣ +void CPanePropertiesWnd::DoDataExchange(CDataExchange* pDX) +{ + CDockablePane::DoDataExchange(pDX); + DDX_Control(pDX, ID_PROPERTY_COMB, m_wndObjectCombo); +} +#if 1 +int CPanePropertiesWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) +{ + if (CDockablePane::OnCreate(lpCreateStruct) == -1) + return -1; + + CRect rectDummy; + rectDummy.SetRectEmpty(); + + // : + //const DWORD dwViewStyle = WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_BORDER | CBS_SORT | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; + const DWORD dwViewStyle = WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_BORDER | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; + + if(m_bUseObjectCombo) + { + if (!m_wndObjectCombo.Create(dwViewStyle, rectDummy, this, ID_PROPERTY_COMB)) + { + TRACE0("δܴ \n"); + return -1; // δܴ + } + IniObjectCombo(); + } + if (!m_wndPropList.Create(WS_VISIBLE | WS_CHILD, rectDummy, this, 2)) + { + TRACE0("δܴ\n"); + return -1; // δܴ + } + + InitPropList(); + + m_wndToolBar.Create(this, AFX_DEFAULT_TOOLBAR_STYLE, IDR_PROPERTIES); + m_wndToolBar.LoadToolBar(IDR_PROPERTIES, 0, 0, TRUE /* */); + m_wndToolBar.CleanUpLockedImages(); + m_wndToolBar.LoadBitmap(theApp.m_bHiColorIcons ? IDB_PROPERTIES_HC : IDR_PROPERTIES, 0, 0, TRUE /* */); + + m_wndToolBar.SetPaneStyle(m_wndToolBar.GetPaneStyle() | CBRS_TOOLTIPS | CBRS_FLYBY); + m_wndToolBar.SetPaneStyle(m_wndToolBar.GetPaneStyle() & ~(CBRS_GRIPPER | CBRS_SIZE_DYNAMIC | CBRS_BORDER_TOP | CBRS_BORDER_BOTTOM | CBRS_BORDER_LEFT | CBRS_BORDER_RIGHT)); + m_wndToolBar.SetOwner(this); + + // ͨ˿ؼ·ɣͨ·: + m_wndToolBar.SetRouteCommandsViaFrame(FALSE); + + AdjustLayout(); + return 0; +} +void CPanePropertiesWnd::OnSize(UINT nType, int cx, int cy) +{ + CDockablePane::OnSize(nType, cx, cy); + AdjustLayout(); +} +#endif +void CPanePropertiesWnd::OnExpandAllProperties() +{ + m_wndPropList.ExpandAll(); +} + +void CPanePropertiesWnd::OnUpdateExpandAllProperties(CCmdUI* /* pCmdUI */) +{ +} + +void CPanePropertiesWnd::OnSortProperties() +{ + m_wndPropList.SetAlphabeticMode(!m_wndPropList.IsAlphabeticMode()); +} + +void CPanePropertiesWnd::OnUpdateSortProperties(CCmdUI* pCmdUI) +{ + pCmdUI->SetCheck(m_wndPropList.IsAlphabeticMode()); +} + +void CPanePropertiesWnd::InitPropList() +{ + SetPropListFont(); + m_wndPropList.EnableHeaderCtrl(FALSE); + m_wndPropList.EnableDescriptionArea();//˵area + m_wndPropList.SetVSDotNetLook(); + //m_wndPropList.MarkModifiedProperties();//DZ޸ĵ +} +//һ +void CPanePropertiesWnd::InsertGridProperty(CMFCPropertyGridProperty* pProp) +{ + if(pProp) + { + m_wndPropList.AddProperty(pProp); + } +} +void CPanePropertiesWnd::OnSetFocus(CWnd* pOldWnd) +{ + CDockablePane::OnSetFocus(pOldWnd); + m_wndPropList.SetFocus(); +} + +void CPanePropertiesWnd::OnSettingChange(UINT uFlags, LPCTSTR lpszSection) +{ + CDockablePane::OnSettingChange(uFlags, lpszSection); + SetPropListFont(); +} + +void CPanePropertiesWnd::SetPropListFont() +{ + ::DeleteObject(m_fntPropList.Detach()); + + LOGFONT lf; + afxGlobalData.fontRegular.GetLogFont(&lf); + + NONCLIENTMETRICS info; + info.cbSize = sizeof(info); + + afxGlobalData.GetNonClientMetrics(info); + + lf.lfHeight = info.lfMenuFont.lfHeight; + lf.lfWeight = info.lfMenuFont.lfWeight; + lf.lfItalic = info.lfMenuFont.lfItalic; + + m_fntPropList.CreateFontIndirect(&lf); + + m_wndPropList.SetFont(&m_fntPropList); + if(m_bUseObjectCombo) + { + m_wndObjectCombo.SetFont(&m_fntPropList); + } +} +#if 1 +//ˢ¿ؼλ +void CPanePropertiesWnd::AdjustLayout() +{ + if (GetSafeHwnd() == NULL) + { + return; + } + + CRect rectClient,rectCombo; + GetClientRect(rectClient); + + int cyCmb = 0; + if(m_bUseObjectCombo) + { + m_wndObjectCombo.GetWindowRect(&rectCombo); + cyCmb = rectCombo.Size().cy; + } + int cyTlb = m_wndToolBar.CalcFixedLayout(FALSE, TRUE).cy; + if(m_bUseObjectCombo) + { + //300 ĸ߶ + m_wndObjectCombo.SetWindowPos(NULL, rectClient.left, rectClient.top, rectClient.Width(), 300, SWP_NOACTIVATE | SWP_NOZORDER); + } + m_wndToolBar.SetWindowPos(NULL, rectClient.left, rectClient.top + cyCmb, rectClient.Width(), cyTlb, SWP_NOACTIVATE | SWP_NOZORDER); + m_wndPropList.SetWindowPos(NULL, rectClient.left, rectClient.top + cyCmb + cyTlb, rectClient.Width(), rectClient.Height() -(cyCmb+cyTlb), SWP_NOACTIVATE | SWP_NOZORDER); +} +#endif diff --git a/LaipuDrawing/PropertiesWnd.h b/LaipuDrawing/PropertiesWnd.h new file mode 100644 index 0000000..659ea8f --- /dev/null +++ b/LaipuDrawing/PropertiesWnd.h @@ -0,0 +1,56 @@ + +#pragma once + +#include "GlobalDefine.h" +#include "EnumPropertieType.h" + + +class CPropertiesToolBar : public CMFCToolBar +{ +public: + virtual void OnUpdateCmdUI(CFrameWnd* /*pTarget*/, BOOL bDisableIfNoHndler) + { + CMFCToolBar::OnUpdateCmdUI((CFrameWnd*) GetOwner(), bDisableIfNoHndler); + } + virtual BOOL AllowShowOnList() const { return FALSE; } +}; +//ͣ +class CPanePropertiesWnd : public CDockablePane +{ +public: + CPanePropertiesWnd(); + virtual ~CPanePropertiesWnd(); +public: + void AdjustLayout(); + void InsertGridProperty(CMFCPropertyGridProperty* pProp); + void SetVSDotNetLook(BOOL bSet) + { + m_wndPropList.SetVSDotNetLook(bSet); + m_wndPropList.SetGroupNameFullWidth(bSet); + } + void NoUseObjectCombo(){m_bUseObjectCombo = false;};//Ҫʹб +protected: + CFont m_fntPropList; + CComboBox m_wndObjectCombo; + CPropertiesToolBar m_wndToolBar; + CMFCPropertyGridCtrl m_wndPropList; + + bool m_bUseObjectCombo;//ʹб +protected: + virtual void RemoveAllProperty(){}; + virtual void IniObjectCombo(){}; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); + afx_msg void OnSize(UINT nType, int cx, int cy); + afx_msg void OnExpandAllProperties(); + afx_msg void OnUpdateExpandAllProperties(CCmdUI* pCmdUI); + afx_msg void OnSortProperties(); + afx_msg void OnUpdateSortProperties(CCmdUI* pCmdUI); + afx_msg void OnSetFocus(CWnd* pOldWnd); + afx_msg void OnSettingChange(UINT uFlags, LPCTSTR lpszSection); + DECLARE_MESSAGE_MAP() + void InitPropList(); + void SetPropListFont(); +}; + diff --git a/LaipuDrawing/ReadMe.txt b/LaipuDrawing/ReadMe.txt new file mode 100644 index 0000000..54374e3 --- /dev/null +++ b/LaipuDrawing/ReadMe.txt @@ -0,0 +1,145 @@ +================================================================================ +MICROSOFT : LaiPuLaser Ŀ +=============================================================================== + +ӦóΪ LaiPuLaser Ӧó򡣴Ӧó򲻽ʾ Microsoft Ļʹ÷ΪдӦó㡣 + +ļҪ LaiPuLaser Ӧóÿļݡ + +LaiPuLaser.vcxproj +ʹӦóɵ VC++ ĿĿļ +ɸļ Visual C++ İ汾ϢԼйʹӦóѡƽ̨úĿܵϢ + +LaiPuLaser.vcxproj.filters + ʹáӦó򵼡ɵ VC++ Ŀɸѡļ + йĿļɸѡ֮ĹϢ IDE УֹͨضڵԷʽʾչļ磬.cppļ롰Դļɸѡ + +LaiPuLaser.h +ӦóҪͷļĿضͷļ( Resource.h) CLaiPuLaserApp Ӧóࡣ + +LaiPuLaser.cpp +ǰӦó CLaiPuLaserApp ҪӦóԴļ + +LaiPuLaser.rc +dzʹõ Microsoft Windows Դб RES Ŀ¼д洢ͼꡢλͼ͹ꡣļֱ Microsoft Visual C++ нб༭ĿԴλ 2052 С + +res\LaiPuLaser.ico +ӦóͼͼļͼҪԴļ LaiPuLaser.rc С + +res\LaiPuLaser.rc2 +ļ Microsoft Visual C++ нб༭ԴӦýԴ༭༭ԴڴļС + +LaiPuLaser.reg +һʾ .reg ļʾ˿ܽΪõעõࡣԽ +Ӧóһʹõ .reg ļԽɾĬϵ RegisterShellFileTypes עᡣ + + +///////////////////////////////////////////////////////////////////////////// + +ܴ: +Ŀ׼ MFC 档 + +MainFrm.h, MainFrm.cpp +Щļ CMainFrame +CMDIFrameWnd MDI ܹܡ + +///////////////////////////////////////////////////////////////////////////// + +ӿܴ: + +ChildFrm.hChildFrm.cpp +Щļ岢ʵ CChildFrame ֧࣬ MDI ӦóеӴڡ + +///////////////////////////////////////////////////////////////////////////// + +Ӧó򵼴һĵͺһͼ: + +LaiPuLaserDoc.hLaiPuLaserDoc.cpp - ĵ +Щļ CLaiPuLaserDoc ࡣ༭Щļĵݲʵļͼ(ͨ CLaiPuLaserDoc::Serialize) +ĵַ: +ļչ: mak +ļ ID: LaiPuLaser.Document +ܱ: LaiPuLaser +ĵ: LaiPuLaser +ɸѡ: LaiPuLaser Files (*.mak) +ļ¼: LaiPuLaser +ļȫ: LaiPuLaser.Document + +LaiPuLaserView.hLaiPuLaserView.cpp - ĵͼ +Щļ CLaiPuLaserView ࡣ +CLaiPuLaserView ڲ鿴 CLaiPuLaserDoc + +res\LaiPuLaserDoc.ico +ͼļ CLaiPuLaserDoc MDI ӴڵͼꡣͼҪԴļ LaiPuLaser.rc С + + + +///////////////////////////////////////////////////////////////////////////// + +֧: + +hlp\LaiPuLaser.hhp +ļǰĿļļΪ .chm ļݡ + +hlp\LaiPuLaser.hhc +ļгĿݡ + +hlp\LaiPuLaser.hhk +ļ + +hlp\afxcore.htm +ļ׼ MFC Ļı׼⡣ԼİӵļС + +hlp\afxprint.htm +ļӡİ⡣ + +makehtmlhelp.bat +ļϵͳļ + +hlp\Images\*.gif +Щ Microsoft ׼ı׼ļλͼļ + + +///////////////////////////////////////////////////////////////////////////// + +: + +ActiveX ؼ +Ӧóʹ ActiveX ؼ֧֡ + +ӡӡԤ֧ +Ӧóͨ MFC CView еijԱڴӡӡúʹӡԤĴ롣 + +MAPI ֧ +ɵĿʹ洢ʼĴ롣 + +Windows Sockets +Ӧó֧ͨ TCP/IP 罨ͨš + +///////////////////////////////////////////////////////////////////////////// + +׼ļ: + +StdAfx.hStdAfx.cpp +ЩļΪ LaiPuLaser.pch Ԥͷ (PCH) ļΪ StdAfx.obj Ԥļ + +Resource.h +DZ׼ͷļµԴ ID +Microsoft Visual C++ ȡ´ļ + +LaiPuLaser.manifest + Ӧó嵥ļ Windows XP Ӧó + ض汾г򼯵ԡسʹô + Ϣӳ򼯻ʵij򼯻 + Ӧó˽ϢӦó嵥Ϊ·ַΪ + Ӧóִļװͬļеⲿ .manifest ļ + ҲԴʽڸÿִļС +///////////////////////////////////////////////////////////////////////////// + +ע: + +ӦóʹáTODO:ָʾӦӻԶԴ벿֡ + +Ӧóڹ DLL ʹ MFCҪ·Щ MFC DLLӦóõϵͳĵǰòͬҪ·ӦıػԴ MFC100XXX.DLLйĸϢμ MSDN ĵй Redistributing Visual C++ applications (· Visual C++ Ӧó)½ڡ + +///////////////////////////////////////////////////////////////////////////// diff --git a/LaipuDrawing/RecipeMgr.cpp b/LaipuDrawing/RecipeMgr.cpp new file mode 100644 index 0000000..ca94737 --- /dev/null +++ b/LaipuDrawing/RecipeMgr.cpp @@ -0,0 +1,2470 @@ +#include "StdAfx.h" +#include "RecipeMgr.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "CStringFuc.h" +#include "WaferRecipeDataMgr.h" +#include "MsgBox.h" +#include "DlgChildRecipe.h" +#include "CommonParaMgr.h" +#include "GlobalFunction.h" +#include "Laser.h" +#include "ProgramLaserTuiHuo.h" +#include "RecipeMgr.h" +#include "DlgRecipeCtrl.h" +#include "MyXmlMgr.h" +#include "ExceptionMsg.h" +#include "AuthorityMgr.h" +#include "CommonParaMgr.h" +#include "Propertie.h" +#include "PropertieMgr.h" + + + +#define RECIPE_FILE_PATH _T("\\RecipePar\\") +#define RECIPE_GROUP_NAME_FILE _T("\\font\\GroupNameList")//бļ +#define SECS_RECIPE_FILE_PATH _T("\\SecsRecipe") + +#define RECIPE_GROUP_CNT 10 //recipe +#define ONE_GROUP_PAR_CNT 50 //һrecipe + +#define NEW_RECIPE_FILE_PATH _T("\\Recipe\\") + + +#define RECIPE_FILE_SUFFIX "rcp" //recipe ļʹõĺ׺ + + +#define XML_ITEM_PAR_TYPE "ParType" +#define XML_ITEM_PAR_VAL "ParVal" + +#define RCP_PAR_TYPE_DOUBLE "Double" +#define RCP_PAR_TYPE_STRING "String" +#define RCP_PAR_TYPE_BOOL "Bool" +#define RCP_PAR_TYPE_INT "Int" + +#define NULL_RECIPE_NAME "" //Чrecipe +#define PARA_MODIFY_DATA_PATH _T("\\ParaModifyRecord\\") + +#define OFFSET_TAB_FILE_PATH "\\OffsetTable\\TableFile\\" + +#define MFC_CTRLSCAL _T("\\CommPar\\MFC_CtrlScal.bin") // MFCϵ + +#if 1 +CSubRecipe::CSubRecipe(void) +{ + m_bUseSubRecipe = true;//Ƿʹ + ReadMFCCtrlScalFile(); + //ʼrecipe + IntiRecipeParVec(); +} + +//ָļжȡMfcϵ +void CSubRecipe::ReadMFCCtrlScalFile() +{ + CFileMgr FileMgr; + CString FilePath; + vector> StrVec; + FileMgr.GetFullFilePath(FilePath, MFC_CTRLSCAL); + FileMgr.ReadFileToStrVec(FilePath, StrVec); + int StrSize = StrVec.size(); + for (int i = 0; i < StrSize; i++) + { + if (2 == StrVec[i].size()) + { + MFCScalStrVec.push_back(StrVec[i]); + } + } + return; +} +//ʼrecipe (мµIJ) +void CSubRecipe::IntiRecipeParVec() +{ + //Ա༭IJҪǰ涨 + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER_FRE; + RecipePar.m_ParShowName = "Laser1 Frequency"; + RecipePar.m_ParUnit = "Hz";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 1000;//Ĭֵ + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_FRE); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER2_FRE; + RecipePar.m_ParShowName = "Laser2 Frequency"; + RecipePar.m_ParUnit = "Hz";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 1000;//Ĭֵ + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_FRE); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_PRF2_DELAY; + RecipePar.m_ParShowName = "Two Pulse Delay"; + RecipePar.m_ParUnit = "ns";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_PULSE_DELAY); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER_CURR_1; + RecipePar.m_ParShowName = "Laser1 Current"; + RecipePar.m_ParUnit = "A";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_CURR_1); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER_CURR_2; + RecipePar.m_ParShowName = "Laser2 Current"; + RecipePar.m_ParUnit = "A";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_CURR_2); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER_EDI_1; + RecipePar.m_ParShowName = "Laser1 Edi"; + RecipePar.m_ParUnit = "J/cm2";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_EDI_1); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER_EDI_2; + RecipePar.m_ParShowName = "Laser2 Edi"; + RecipePar.m_ParUnit = "J/cm2";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_EDI_2); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER_EDI_OFFSET_1; + RecipePar.m_ParShowName = "Laser1 Edi Offset"; + RecipePar.m_ParUnit = "J/cm2";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = -2; + RecipePar.m_DoubleMaxVal = 2; + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER_EDI_OFFSET_2; + RecipePar.m_ParShowName = "Laser2 Edi Offset"; + RecipePar.m_ParUnit = "J/cm2";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = -2; + RecipePar.m_DoubleMaxVal = 2; + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_EDI_CHECK_SCOPE; + RecipePar.m_ParShowName = "Edi Check Scope"; + RecipePar.m_ParUnit = "J/cm2";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = 5; + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_OVERLAP_RATIO_X; + RecipePar.m_ParShowName = "Overlap Rate X"; + RecipePar.m_ParUnit = "%";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = 99; + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_OVERLAP_RATIO_Y; + RecipePar.m_ParShowName = "Overlap Rate Y"; + RecipePar.m_ParUnit = "%";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = 99; + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_FOCUS_ADJUST_VAL; + RecipePar.m_ParShowName = "Foucs Adjust Val"; + RecipePar.m_ParUnit = "mm";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MIN_FOCUS_ADJUST); + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_FOCUS_ADJUST); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_FIX_SCAN_SPEED; + RecipePar.m_ParShowName = "Fix Scan Speed"; + RecipePar.m_ParUnit = "mm/s";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MIN_SCAN_SPEED); + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_SCAN_SPEED); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_FIX_SCAN_LINE_GAP; + RecipePar.m_ParShowName = "Fix Scan Line Gap"; + RecipePar.m_ParUnit = "mm";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_FIX_SCAN_LINE_GAP); + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_SCAN_LINE_START_IDX; + RecipePar.m_ParShowName = "Start Scan Line Idx"; + //RecipePar.m_ParUnit = "mm";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = 100000; + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_ALIGNER_ANG; + RecipePar.m_ParShowName = "Wafer Aligner Angle"; + RecipePar.m_ParUnit = "degree";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 270; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = 360; + m_RecipeParVec.push_back(RecipePar); + } + { + int StrSize = MFCScalStrVec.size(); + double m_MinVal = 0.0; + double m_MaxVal = 0.0; + if (StrSize > 0) + { + m_MinVal = CStringToDouble(MFCScalStrVec[0][1]); + m_MaxVal = CStringToDouble(MFCScalStrVec[StrSize - 1][1]); + } + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_N2_VAL; + RecipePar.m_ParShowName = "N2 Val"; + RecipePar.m_ParUnit = "L";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = m_MinVal; + RecipePar.m_DoubleMinVal = m_MinVal; + RecipePar.m_DoubleMaxVal = m_MaxVal; + m_RecipeParVec.push_back(RecipePar); + } + //------------------------------------------------ + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_SCAN_AREA; + RecipePar.m_ParShowName = "Scan Area"; + RecipePar.m_ParType = _RecipeParType_CString;// + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_AREA_IDX; + RecipePar.m_ParShowName = "Area Idx"; + RecipePar.m_ParType = _RecipeParType_Int;// + RecipePar.m_ParIntVal = 1; + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_N2_STATE; + RecipePar.m_ParShowName = "N2"; + RecipePar.m_ParType = _RecipeParType_Bool;// + RecipePar.m_ParBoolVal = true; + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_USE_CUR_N2VAL; + RecipePar.m_ParShowName = "Use CurN2Val"; + RecipePar.m_ParType = _RecipeParType_Bool;// + RecipePar.m_ParBoolVal = false; + m_RecipeParVec.push_back(RecipePar); + } + #ifdef __OFFSET_TABLE__ + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_OFFSET_TAB; + RecipePar.m_ParShowName = "Offset Table"; + RecipePar.m_ParType = _RecipeParType_CString;// + RecipePar.m_ParStrVal = RECIPE_OFFSET_TBL_NULL; + m_RecipeParVec.push_back(RecipePar); + } + #endif + + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_RUNTIMES; + RecipePar.m_ParShowName = "Run Times"; + RecipePar.m_ParType = _RecipeParType_Int;// + RecipePar.m_ParIntVal = 1;//Ĭֵ + m_RecipeParVec.push_back(RecipePar); + } + + //ܱ༭IJ--------------------------------------------------------------- + #if 1 + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER1_POW; + RecipePar.m_ParShowName = "Laser1 Power"; + RecipePar.m_ParUnit = "w";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_POW_1); + RecipePar.m_bRcpInfoPar = true;//ǷΪ(ܱ༭) + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_LASER2_POW; + RecipePar.m_ParShowName = "Laser2 Power"; + RecipePar.m_ParUnit = "w";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_LASER_POW_2); + RecipePar.m_bRcpInfoPar = true;//ǷΪ(ܱ༭) + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_SCAN_SPEED; + RecipePar.m_ParShowName = "Scan Speed"; + RecipePar.m_ParUnit = "mm/s";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MIN_SCAN_SPEED); + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_SCAN_SPEED); + RecipePar.m_bRcpInfoPar = true;//ǷΪ(ܱ༭) + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_ROTATO_DIMMER_ANG; + RecipePar.m_ParShowName = "Dimmer1 Angle"; + RecipePar.m_ParUnit = "degree";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_DIMMER_ANG_1); + RecipePar.m_bRcpInfoPar = true;//ǷΪ(ܱ༭) + m_RecipeParVec.push_back(RecipePar); + } + { + CRecipeParameter RecipePar; + RecipePar.m_ParName = RECIPE_PAR_NAME_ROTATO_DIMMER_ANG2; + RecipePar.m_ParShowName = "Dimmer2 Angle"; + RecipePar.m_ParUnit = "degree";//ĵλ,ʾ + RecipePar.m_ParType = _RecipeParType_Double;// + RecipePar.m_ParDoubleVal = 0; + RecipePar.m_DoubleMinVal = 0; + RecipePar.m_DoubleMaxVal = gCommonParaMgr->GetCommonParaVal(RECIPE_PAR_MAX_DIMMER_ANG_2); + RecipePar.m_bRcpInfoPar = true;//ǷΪ(ܱ༭) + m_RecipeParVec.push_back(RecipePar); + } + #endif +} +#endif +#if 1 +//ݲͷCString ֵ +CString CRecipeParameter::GetParStr() +{ + CString ParStr; + switch(m_ParType) + { + case _RecipeParType_Double: + ParStr = Db2CString(m_ParDoubleVal); + break; + case _RecipeParType_Bool: + ParStr = (m_ParBoolVal)?(BOOL_STR_ON):(BOOL_STR_OFF); + break; + case _RecipeParType_CString: + ParStr = m_ParStrVal; + break; + case _RecipeParType_Int: + ParStr = Int2CString(m_ParIntVal); + break; + default: + break; + } + return ParStr; +} +CString CRecipeParameter::GetParTypeStr() +{ + CString Str; + switch(m_ParType) + { + case _RecipeParType_Double: + Str = RCP_PAR_TYPE_DOUBLE; + break; + case _RecipeParType_Bool: + Str = RCP_PAR_TYPE_BOOL; + break; + case _RecipeParType_CString: + Str = RCP_PAR_TYPE_STRING; + break; + case _RecipeParType_Int: + Str = RCP_PAR_TYPE_INT; + break; + default: + break; + } + return Str; +} + +void CRecipeParameter::SetValByStr(CString s) +{ + switch(m_ParType) + { + case _RecipeParType_Double: + m_ParDoubleVal = CStringToDouble(s); + break; + case _RecipeParType_Bool: + m_ParBoolVal = ((s==BOOL_STR_ON))?(true):(false); + break; + case _RecipeParType_CString: + m_ParStrVal = s; + break; + case _RecipeParType_Int: + m_ParIntVal = CStringToInt(s); + break; + default: + break; + } +} + +void CRecipeParameter::SetTypeByStr(CString TypeStr) +{ + if(TypeStr==RCP_PAR_TYPE_DOUBLE) + { + m_ParType = _RecipeParType_Double; + } + if(TypeStr==RCP_PAR_TYPE_STRING) + { + m_ParType = _RecipeParType_CString; + } + if(TypeStr==RCP_PAR_TYPE_BOOL) + { + m_ParType = _RecipeParType_Bool; + } + if(TypeStr==RCP_PAR_TYPE_INT) + { + m_ParType = _RecipeParType_Int; + } +} +void CRecipeParameter::GetRangeStr(CString &Min,CString &Max) +{ + if(m_ParType==_RecipeParType_Double) + { + Min = Db2CString(m_DoubleMinVal); + Max = Db2CString(m_DoubleMaxVal); + } + else + { + Min = Max = "---"; + } +} + +#endif +#if 1 +CRecipe::CRecipe(void) +{ + m_DoubleValCnt = 0;//double Ͳ + m_GroupIdx = -1;//ı + m_RecipeIdx = -1;//еı + + m_CurSubRecipeIdx = 0;//ǰʹõSubRecipe + m_bEnableEdit = true;//ǰʱԱ༭ + RecipeReset(); + + CSubRecipe SubRecipe; + SubRecipe.m_SubRecipeName = "SubRecipe1"; + m_SubRecipeVec.push_back(SubRecipe);//ĬһSubRecipe +} +void CRecipe::RecipeReset() +{ + m_RecipeName = NULL_RECIPE_NAME;//Recipe +} +bool CRecipe::IsValid() +{ + return (m_RecipeName != NULL_RECIPE_NAME); +} +vector &CRecipe::GetRecipeParVec() +{ + return m_SubRecipeVec[m_CurSubRecipeIdx].m_RecipeParVec; +}; + +//RecipePar ļ +void CRecipe::SaveRecipeParToFile(CString FilePath) +{ + +} +//ļȡrecipe +void CRecipe::ReadRecipeParFromFile(CString FilePath) +{ + +} +//ͨȡ +CRecipeParameter CRecipe::GetRecipePar(CString ParName) +{ + CRecipeParameter Par; + vector &RecipeParVec = GetRecipeParVec(); + int size = RecipeParVec.size(); + for(int i=0;i &RecipeParVec = GetRecipeParVec(); + int size = RecipeParVec.size(); + for(int i=0;iWriteDebugLog("Func---->Check Recipe Par Range"); + vector &RecipeParVec = GetRecipeParVec(); + int size = RecipeParVec.size(); + for(int i=0;iGetCommonParaVal(RecipePar.m_ParName); + if(IsDbEqualZero(DoubleMaxVal)) + DoubleMaxVal = RecipePar.m_DoubleMaxVal; + + if(ParValDoubleMaxVal) + { + CString s,s1; + s += "["; + s += RecipePar.m_ParShowName; + s += "]"; + s1.Format(" : %.2f",ParVal); + s += s1; + s1.Format("\nΧ[%.2f~%.2f]",RecipePar.m_DoubleMinVal,DoubleMaxVal); + s += s1; + if(bShowMsg) + { + CMsgBox MsgBox; + MsgBox.Show(s); + } + return false; + } + return true; +} +//ParName ķΧ +bool CRecipe::CheckParRangeByName(CString ParName,double val) +{ + CRecipeParameter RecipePar = GetRecipePar(ParName); + return CheckParRangeExt(RecipePar,val,true); +} +//ȡʾõ +CString CRecipe::GetShowName() +{ + CString s(""); + if(m_GroupIdx>=0 && m_RecipeIdx>=0) + { + s.Format("[%d][%d]",m_GroupIdx+1,m_RecipeIdx+1); + s += m_RecipeName; + } + else//ָrecipe + { + s = "Recover : "+m_RecipeName; + } + return s; +} +void CRecipe::AddSubRecipe(CString SubRecipeName) +{ + int size = m_SubRecipeVec.size(); + if(size>0) + { + CSubRecipe SubRecipe = m_SubRecipeVec[m_CurSubRecipeIdx];//õǰѡsub recipe и + SubRecipe.m_SubRecipeName = SubRecipeName; + m_SubRecipeVec.push_back(SubRecipe); + } +} +void CRecipe::DelSubRecipe(CString SubRecipeName) +{ + int size = m_SubRecipeVec.size(); + if(m_SubRecipeVec.size()>1)//ϲɾ + { + vector::iterator iter = m_SubRecipeVec.begin(); + vector::iterator iter_end = m_SubRecipeVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).m_SubRecipeName == SubRecipeName) + { + m_SubRecipeVec.erase(iter); + m_CurSubRecipeIdx = 0; + break; + } + } + } +} + +CString CRecipe::GetCurSubRecipeName() +{ + CString RecipeName; + if(m_CurSubRecipeIdx>=0 && m_CurSubRecipeIdx=0 && m_CurSubRecipeIdxGetOffsetTablePath(TableName); + CSubRecipe &SubRecipe = m_SubRecipeVec[m_CurSubRecipeIdx]; + bool Ret = SubRecipe.m_OffsetTable.ReadOffsetTableFile(TableFilePath); + if(TableName==RECIPE_OFFSET_TBL_NULL) + Ret = true; + return Ret; +} +//ȡOffsetTableֵָ +double CRecipe::GetOffsetParVal(CString ParName) +{ + CSubRecipe &SubRecipe = m_SubRecipeVec[m_CurSubRecipeIdx]; + return SubRecipe.m_OffsetTable.GetOffsetParVal(ParName); +} +#endif + + + +CRecipeMgr *gRecipeMgr = new CRecipeMgr; +CRecipeMgr::CRecipeMgr(void) +{ + m_CurSelGroupIdx = 0;//ǰѡgourp ֵ + m_CurSelRecipeIdx = 0;//ǰѡrecipe ֵ + m_CurSelRecipeParIdx = -1;//ǰѡpar ֵ + m_pRecipeGroupComb = NULL; + + m_FocusAdjustMin = 0;//ΧСֵ + m_FocusAdjustMax = 0;//Χֵ + + +} +CRecipeMgr::~CRecipeMgr(void) +{ + +} +void CRecipeMgr::OnAppInitialize() +{ + //recipe Ŀ¼ + CreatRecipeFilePath(); + //ʼrecipe dlg + CDlgChildRecipe *pDlg = dynamic_cast(gChildRecipe); + pDlg->InitDialogItem(); +} +//ȡlist ļ· +CString CRecipeMgr::GetRecipeNameListPath() +{ + CFileMgr FileMgr; + CString FilePath; + FileMgr.GetFullFilePath(FilePath,RECIPE_GROUP_NAME_FILE);//ȡ· + return FilePath; +} +//ȡ·GroupIdx(0~RECIPE_GROUP_CNT) +CString CRecipeMgr::GetGroupDirPath(int GroupIdx) +{ + CFileMgr FileMgr; + CString FilePath; + CString GroupDirName; + GroupDirName.Format("ParGroup%d\\",GroupIdx); + GroupDirName = RECIPE_FILE_PATH + GroupDirName; + FileMgr.GetFullFilePath(FilePath,GroupDirName);//ȡ· + return FilePath; +} +//õǰѡеRecipe ֵ +void CRecipeMgr::SetCurSelRecipeIdx(int Idx) +{ + int size = m_CurGroupRecipeVec.size(); + if(Idx>=0 && IdxWriteDebugLog(s); + } +} +#if 1 +//浱ǰѡRecipe +void CRecipeMgr::SaveCurSelRecipe(CRecipe Recipe) +{ + int size = m_CurGroupRecipeVec.size(); + if(m_CurSelRecipeIdx>=0 && m_CurSelRecipeIdx",m_CurSelGroupIdx+1); + Num2.Format("<%d>",m_CurSelRecipeIdx+1); + CString GroupRecipeStr; + GroupRecipeStr += Num1; + GroupRecipeStr += m_RecipeGroupNameVec[m_CurSelGroupIdx]; + GroupRecipeStr += Num2; + GroupRecipeStr += m_CurGroupRecipeVec[m_CurSelRecipeIdx].m_RecipeName; + return GroupRecipeStr; +} + +//ǰrecipe ɨ· +void CRecipeMgr::CreatRecipeScanPath(CRecipe *pRecipe,int SubRecipeIdx) +{ + pRecipe->SetCurSubRecipeIdx(SubRecipeIdx);//ΪǰSubRecipeIdx + CRecipeParameter RecipePar; + //ɨ + CString AreaName; + RecipePar = pRecipe->GetRecipePar(RECIPE_PAR_NAME_SCAN_AREA); + AreaName = RecipePar.m_ParStrVal; + if(!gWaferRecipeDataMgr->SelScanAreaByName(AreaName)) + { + CString Msg("ɨ򲻴: "); + Msg += AreaName; + CExceptionMsg ExceptionMsg; + ExceptionMsg.SetMsg(Msg); + throw ExceptionMsg; + } + //ɨ· + int AreaIdx; + RecipePar = pRecipe->GetRecipePar(RECIPE_PAR_NAME_AREA_IDX); + AreaIdx = RecipePar.m_ParIntVal-1; + gWaferRecipeDataMgr->CreatScanPath(AreaIdx); + + m_pView->RefreshView(); +} +void CRecipeMgr::CreatScanPath(CString AreaName,int AreaIdx) +{ + //· + if(!gWaferRecipeDataMgr->SelScanAreaByName(AreaName)) + { + return; + } + //ɨ· + gWaferRecipeDataMgr->CreatScanPath(AreaIdx); + //Ĭѡarea + //CObjContainer &ObjContainer = gLayer.GetObjContainer(); + //ObjContainer.SelObjByIdx(AreaIdx); + m_pView->RefreshView(); +} +#endif + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#if 1 +#if 1 +CString CRecipeMgr::GetRecipePath() +{ + CString DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(NEW_RECIPE_FILE_PATH); + return DirPath; +} +void CRecipeMgr::CreatRecipeFilePath() +{ + CString DirPath = GetRecipePath(); + CFileMgr FileMgr; + if(!FileMgr.IsDirectoryExists(DirPath)) + FileMgr.CreatDir(DirPath); + DirPath += "\\"; +} +//ȡRecipeļ·(RecipeName ޺׺) +CString CRecipeMgr::GetCtrlRecipeFilePath(CString GroupName,CString RecipeName) +{ + CString Path = GetRecipePath(); + Path += GroupName; + Path += "\\"; + Path += RecipeName; + Path += "."; + Path += RECIPE_FILE_SUFFIX; + return Path; +} +#endif +#if 1 +//õǰѡеgroup ֵ +void CRecipeMgr::SetCurSelGourpIdx(int Idx) +{ + int size = m_NewRecipeGroupNameVec.size(); + if(Idx>=0 && Idx &SubRecipeVec = m_CurEditRecipe.GetSubRecipeVec(); + CString Name; + Name.Format("SubRecipe%ld",SubRecipeVec.size()+1); + EditName1 = m_CurSelRecipeName; + EditName2 = Name; + } + break; + case _RecipeCtrl_DelSubRecipe: + { + CtrlItem.m_DlgTitle = "Delete Sub Recipe"; + vector &SubRecipeVec = m_CurEditRecipe.GetSubRecipeVec(); + EditName1 = m_CurSelRecipeName; + EditName2 = SubRecipeVec[m_CurEditRecipe.m_CurSubRecipeIdx].m_SubRecipeName; + } + break; + case _RecipeCtrl_SubRecipeName: + { + CtrlItem.m_DlgTitle = "Sub Recipe ReName"; + vector &SubRecipeVec = m_CurEditRecipe.GetSubRecipeVec(); + EditName1 = SubRecipeVec[m_CurEditRecipe.m_CurSubRecipeIdx].m_SubRecipeName; + EditName2 = EditName1; + } + break; + default: + break; + } +} +//б +void CRecipeMgr::BindingRecipeGroupComb(CComboBox *p) +{ + m_pRecipeGroupComb = p; + UpdateRecipeGroupVec(); + UpdateRecipeGroupComb(m_pRecipeGroupComb); +}; +//ˢRecipeGroup Ϣ +void CRecipeMgr::UpdateRecipeGroupInfo() +{ + UpdateRecipeGroupVec(); + UpdateRecipeGroupComb(m_pRecipeGroupComb); +} +//б +void CRecipeMgr::UpdateRecipeGroupVec() +{ + m_NewRecipeGroupNameVec.clear(); + CString DirPath = GetRecipePath(); + CFileMgr FileMgr; + vector FilePathVec; + FileMgr.GetChildFileOrDirName(true,GetRecipePath(),FilePathVec,""); + int size = FilePathVec.size(); + for(int k=0;k=0) + ComboBox.SetCurSel(idx); +} +void CRecipeMgr::UpdateSelRecipeComb(CComboBox &ComboBox,vector &SelGroupRecipeNameVec) +{ + ComboBox.ResetContent();// + //ӵǰѡеrecipe Ŀ¼ȡrecipe ļб + ReadCurGroupRecipeName(SelGroupRecipeNameVec); + int size = SelGroupRecipeNameVec.size(); + for(int k=0;k &SubRecipeVec = Recipe.GetSubRecipeVec(); + int size = SubRecipeVec.size(); + for(int k=0;k &SubRecipeVec = m_CurEditRecipe.GetSubRecipeVec(); + int size = SubRecipeVec.size(); + for(int k=0;k &RecipeParVec = m_CurEditRecipe.GetRecipeParVec(); + int size = RecipeParVec.size(); + if(size<=0) + return; + int RecipeListIdx = 0; + int RecipeInfoListIdx = 0; + for(int k=0;k &RecipeParVec = Recipe.GetRecipeParVec(); + int size = RecipeParVec.size(); + if(size<=0) + return; + int RecipeListIdx = 0; + int RecipeInfoListIdx = 0; + for(int k=0;k &RecipeParVec = Recipe.GetRecipeParVec(); + int size = RecipeParVec.size(); + int RecipeListIdx = 0; + int RecipeInfoListIdx = 0; + for(int k=0;kGetCurUserName(),true); + CsvData.AddData("ʱ",false); + CsvData.AddData(WorkTime.GetDateTime("/",":"),true); + CsvData.AddData("Group ·",false); + CsvData.AddData(Path,true); + CsvData.AddData("",false); + CsvData.AddData("ɾrecipe group",true); + + vector RcpPathVec; + FileMgr.GetChildFileOrDirName(false,Path,RcpPathVec,RECIPE_FILE_SUFFIX); + int size1 = RcpPathVec.size(); + for(int i=0;iWriteDebugLog(RecipeFilePath); + + CRecipe Recipe; + SaveRecipeToXml(RecipeFilePath,Recipe); + + CRecipeCtrlPar RecipeCtrlPar; + RecipeCtrlPar.m_CtrlType = _RecipeCtrl_AddRecipe; + RecipeCtrlPar.m_FilePath = RecipeFilePath; + RecipeCtrlPar.m_RcpName = RecipeName; + SaveRecipeHistoy(RecipeCtrlPar); +} +//ɾRecipe +void CRecipeMgr::DeletRecipe(CString RecipeName) +{ + CString Path = GetCtrlRecipeFilePath(m_CurSelGroupName,RecipeName); + CFileMgr FileMgr; + FileMgr.DeleteFolder(Path); + + CRecipeCtrlPar RecipeCtrlPar; + RecipeCtrlPar.m_CtrlType = _RecipeCtrl_DelRecipe; + RecipeCtrlPar.m_FilePath = Path; + RecipeCtrlPar.m_RcpName = RecipeName; + SaveRecipeHistoy(RecipeCtrlPar); +} +//ƶrecipe GroupName +void CRecipeMgr::MoveRecipe(CString GroupName,CString RecipeName) +{ + CString OldPath = GetCtrlRecipeFilePath(m_CurSelGroupName,RecipeName); + CString NewPath = GetCtrlRecipeFilePath(GroupName,RecipeName); + CFileMgr FileMgr; + FileMgr.MoveFolder(OldPath,NewPath); + + CRecipeCtrlPar RecipeCtrlPar; + RecipeCtrlPar.m_CtrlType = _RecipeCtrl_MoveRecipe; + RecipeCtrlPar.m_FilePath = OldPath; + RecipeCtrlPar.m_NewFilePath = NewPath; + RecipeCtrlPar.m_RcpName = RecipeName; + SaveRecipeHistoy(RecipeCtrlPar); +} +//ѡrecipe ǰgroup +void CRecipeMgr::CopyRecipe(CString NewRecipeName) +{ + if(!CheckRecipeNameExist(NewRecipeName)) + return; + CString OldPath = GetCtrlRecipeFilePath(m_CurSelGroupName,m_CurSelRecipeName); + CString NewPath = GetCtrlRecipeFilePath(m_CurSelGroupName,NewRecipeName); + CFileMgr FileMgr; + FileMgr.CopyFolder(OldPath,NewPath); + + CRecipeCtrlPar RecipeCtrlPar; + RecipeCtrlPar.m_CtrlType = _RecipeCtrl_CopyRecipe; + RecipeCtrlPar.m_FilePath = OldPath; + RecipeCtrlPar.m_RcpName = m_CurSelRecipeName; + RecipeCtrlPar.m_RcpNameNew = NewRecipeName; + SaveRecipeHistoy(RecipeCtrlPar); +} +bool CRecipeMgr::ReadEditRecipeFromFile() +{ + CString RecipeFilePath = GetCtrlRecipeFilePath(m_CurSelGroupName,m_CurSelRecipeName); + if(ReadRecipeFromXml(RecipeFilePath,m_CurEditRecipe)) + { + m_CurEditRecipe.m_RecipeName = m_CurSelRecipeName; + return true; + } + return false; +} +bool CRecipeMgr::ReadEditRecipeFromFile(CRecipe &Recipe,int SelGroupIdx,CString SelRecipeName) +{ + int size = m_NewRecipeGroupNameVec.size(); + if(SelGroupIdx<0||SelGroupIdx>=size) + return false; + CString SelGroupName = m_NewRecipeGroupNameVec[SelGroupIdx]; + CString RecipeFilePath = GetCtrlRecipeFilePath(SelGroupName,SelRecipeName); + Recipe.m_RecipeName = SelRecipeName; + return ReadRecipeFromXml(RecipeFilePath,Recipe); +} +//ı +void CRecipeMgr::ChangeGroupName(CString NewGroupName) +{ + CString OldGroupPath = GetRecipePath(); + CString NewGroupPath = OldGroupPath + NewGroupName; + OldGroupPath += m_CurSelGroupName; + CFileMgr FileMgr; + FileMgr.ReNameFolder(OldGroupPath,NewGroupPath); + m_CurSelGroupName = NewGroupName; + m_CurEditRecipe.m_FilePath = GetCtrlRecipeFilePath(m_CurSelGroupName,m_CurSelRecipeName); +} +//ırecipe +void CRecipeMgr::ChangeRecipeName(CString NewRcpName) +{ + if(!CheckRecipeNameExist(NewRcpName)) + return; + CString OldPath = GetCtrlRecipeFilePath(m_CurSelGroupName,m_CurSelRecipeName); + CString NewPath = GetCtrlRecipeFilePath(m_CurSelGroupName,NewRcpName); + CFileMgr FileMgr; + FileMgr.ReNameFolder(OldPath,NewPath); + SetCurSelRecipeName(NewRcpName); + m_CurEditRecipe.m_FilePath = NewPath; +} +//ıSubRecipe +void CRecipeMgr::ChangeSubRecipeName(CString NewRcpName) +{ + m_CurEditRecipe.SetCurSubRecipeName(NewRcpName); + // + CString RecipeFilePath = GetCtrlRecipeFilePath(m_CurSelGroupName,m_CurEditRecipe.m_RecipeName); + SaveRecipeToXml(m_CurEditRecipe.m_FilePath,m_CurEditRecipe); +} + +CString CRecipeMgr::GetRecipeCtrlName(ERecipeCtrlType RecipeCtrlType) +{ + CString CtrlName; + switch(RecipeCtrlType) + { + case _RecipeCtrl_AddGroup: + CtrlName = "Add Group"; + break; + case _RecipeCtrl_DelGroup: + CtrlName = "Delete Group"; + break; + case _RecipeCtrl_GroupName: + CtrlName = "Group ReName"; + break; + case _RecipeCtrl_AddRecipe: + CtrlName = "Add Recipe"; + break; + case _RecipeCtrl_DelRecipe: + CtrlName = "Delete Recipe"; + break; + case _RecipeCtrl_CopyRecipe: + CtrlName = "Copy Recipe"; + break; + case _RecipeCtrl_MoveRecipe: + CtrlName = "Move Recipe"; + break; + case _RecipeCtrl_RecipeName: + CtrlName = "Recipe ReName"; + break; + case _RecipeCtrl_AddSubRecipe: + CtrlName = "Add SubRecipe"; + break; + case _RecipeCtrl_DelSubRecipe: + CtrlName = "Delete SubRecipe"; + break; + case _RecipeCtrl_SubRecipeName: + CtrlName = "SubRecipe ReName"; + break; + default: + break; + } + return CtrlName; +} +//ӵǰѡеrecipe Ŀ¼ȡrecipe ļб +void CRecipeMgr::ReadCurGroupRecipeName(vector &SelGroupRecipeNameVec) +{ + SelGroupRecipeNameVec.clear(); + CString RecipePath = GetRecipePath(); + RecipePath += m_CurSelGroupName; + CFileMgr FileMgr; + vector FilePathVec; + FileMgr.GetChildFileOrDirName(false,RecipePath,FilePathVec,RECIPE_FILE_SUFFIX); + int size = FilePathVec.size(); + for(int k=0;k" + EditName2; + bUpdateRecipeGroup = true; + break; + case _RecipeCtrl_RecipeName: + ChangeRecipeName(EditName2); + CtrlStr = EditName1 + "->" + EditName2; + bUpdateRecipeGroup = false; + break; + case _RecipeCtrl_AddRecipe: + AddRecipe(SelGroupName,EditName2); + CtrlStr = EditName2 + " To Group : " + SelGroupName; + break; + case _RecipeCtrl_DelRecipe: + DeletRecipe(EditName2); + CtrlStr = EditName2 + "Delete From Group: " + EditName1; + break; + case _RecipeCtrl_MoveRecipe: + MoveRecipe(SelGroupName,EditName2); + CtrlStr = EditName2 + " To Group : " + SelGroupName; + break; + case _RecipeCtrl_CopyRecipe: + CopyRecipe(EditName2); + CtrlStr = EditName1 + "Copy To: " + EditName2; + break; + case _RecipeCtrl_AddSubRecipe: + AddSubRecipe(EditName2); + CtrlStr = EditName2 + " To Recipe : " + EditName1; + break; + case _RecipeCtrl_DelSubRecipe: + DelSubRecipe(EditName2); + CtrlStr = EditName2 + " From Recipe : " + EditName1; + break; + case _RecipeCtrl_SubRecipeName: + ChangeSubRecipeName(EditName2); + CtrlStr = EditName1 + "->" + EditName2; + break; + default: + break; + } + if(bUpdateRecipeGroup) + { + UpdateRecipeGroupVec(); + UpdateRecipeGroupComb(m_pRecipeGroupComb); + } + CString CtrlName = "RecipeCtrl-->"; + CtrlName += GetRecipeCtrlName(RecipeCtrlType); + CtrlName += " : "; + CString Log = CtrlName + CtrlStr; + gLogMgr->WriteDebugLog(Log); + + return ErrMsg; +} + +bool CRecipeMgr::EditRecipeByCtrlType(ERecipeCtrlType CtrlType) +{ + CString ErrMsg; + //ִ + switch(CtrlType) + { + case _RecipeCtrl_AddGroup: + + break; + case _RecipeCtrl_AddRecipe: + + break; + case _RecipeCtrl_GroupName: + if(m_CurSelGroupName=="") + { + ErrMsg = "ûѡҪgroup"; + } + break; + case _RecipeCtrl_RecipeName: + case _RecipeCtrl_MoveRecipe: + case _RecipeCtrl_CopyRecipe: + case _RecipeCtrl_DelRecipe: + case _RecipeCtrl_AddSubRecipe: + case _RecipeCtrl_DelSubRecipe: + if(!IsbSelEditRecipe()) + ErrMsg = "ûѡҪRecipe"; + break; + default: + break; + } + if(ErrMsg=="" && CtrlType==_RecipeCtrl_DelSubRecipe) + { + if(m_CurEditRecipe.GetSubRecipeVec().size()<=1) + ErrMsg = "ֻһsub Recipe ɾ"; + } + if(ErrMsg!="") + { + CMsgBox MsgBox; + MsgBox.Show(ErrMsg); + return false; + } + m_CurRecipeCtrlType = CtrlType; + CDlgRecipeCtrl dlg; + return (dlg.DoModal()==IDOK); +} +//һsub recipe ǰ༭recipe +void CRecipeMgr::AddSubRecipe(CString SubRecipeName) +{ + m_CurEditRecipe.AddSubRecipe(SubRecipeName); + // + CString RecipeFilePath = GetCtrlRecipeFilePath(m_CurSelGroupName,m_CurEditRecipe.m_RecipeName); + SaveRecipeToXml(m_CurEditRecipe.m_FilePath,m_CurEditRecipe); + + CRecipeCtrlPar RecipeCtrlPar; + RecipeCtrlPar.m_CtrlType = _RecipeCtrl_AddSubRecipe; + RecipeCtrlPar.m_FilePath = RecipeFilePath; + RecipeCtrlPar.m_RcpName = m_CurEditRecipe.m_RecipeName; + RecipeCtrlPar.m_SubRcpName = SubRecipeName; + SaveRecipeHistoy(RecipeCtrlPar); +} +void CRecipeMgr::DelSubRecipe(CString SubRecipeName) +{ + m_CurEditRecipe.DelSubRecipe(SubRecipeName); + // + CString RecipeFilePath = GetCtrlRecipeFilePath(m_CurSelGroupName,m_CurEditRecipe.m_RecipeName); + SaveRecipeToXml(m_CurEditRecipe.m_FilePath,m_CurEditRecipe); + + CRecipeCtrlPar RecipeCtrlPar; + RecipeCtrlPar.m_CtrlType = _RecipeCtrl_DelSubRecipe; + RecipeCtrlPar.m_FilePath = RecipeFilePath; + RecipeCtrlPar.m_RcpName = m_CurEditRecipe.m_RecipeName; + RecipeCtrlPar.m_SubRcpName = SubRecipeName; + SaveRecipeHistoy(RecipeCtrlPar); +} +//ƶSubRecipe ˳ +bool CRecipeMgr::MoveSubRecipe(bool bMoveUp) +{ + if(!IsbSelEditRecipe()) + { + CMsgBox MsgBox; + MsgBox.Show("ûѡҪRecipe"); + return false; + } + int CurSubRecipeIdx = m_CurEditRecipe.m_CurSubRecipeIdx; + int SwapSubRecipeIdx = (bMoveUp)?(CurSubRecipeIdx-1):(CurSubRecipeIdx+1);//ֵ + vector &SubRecipeVec = m_CurEditRecipe.GetSubRecipeVec(); + int size = SubRecipeVec.size(); + if(SwapSubRecipeIdx >=0 && SwapSubRecipeIdx &SubRecipeVec = m_CurEditRecipe.GetSubRecipeVec(); + int size = SubRecipeVec.size(); + if(idx>=0&&idx=0&&idxWriteDebugLog(Log); + CMyXmlMgr XmlMgr; + XmlMgr.SaveXmlItemToFile(FilePath,XmlItemRoot); + + Log += " Complete" ; + gLogMgr->WriteDebugLog(Log); +} +//xml ļжȡRecipe +bool CRecipeMgr::ReadRecipeFromXml(CString FilePath,CRecipe &Recipe) +{ + CMyXmlMgr XmlMgr; + CMyXmlItem XmlItemRoot; + XmlMgr.ReadXmlItemFromFile(FilePath,XmlItemRoot); + vector &SubRecipeVec = XmlItemRoot.m_XmlItemVec; + int SubRecipeCnt = SubRecipeVec.size(); + if(SubRecipeCnt<=0) + { + return false; + } + Recipe.m_FilePath = FilePath; + Recipe.m_SubRecipeVec.clear(); + Recipe.m_CurSubRecipeIdx = 0; + for(int i=0;i &RecipeParVec = XmlItemSubRecipe.m_XmlItemVec; + int ParCnt = RecipeParVec.size(); + for(int j=0;j &RecipeParInfoVec = XmlItemRecipePar.m_XmlItemVec; + int ParInfoCnt = RecipeParInfoVec.size(); + for(int k=0;k &RecipeParInfoValVec = XmlItemParInfo.m_XmlItemVec; + if(!RecipeParInfoValVec.empty()) + { + ParInfoVal = RecipeParInfoValVec[0].m_XmlItemName; + } + if(ParInfoName==XML_ITEM_PAR_TYPE) + { + XmlRecipePar.SetTypeByStr(ParInfoVal); + } + if(ParInfoName==XML_ITEM_PAR_VAL) + { + XmlRecipePar.SetValByStr(ParInfoVal); + } + } + vector &SubRecipeParVec = SubRecipe.m_RecipeParVec; + int SubRecipeParCnt = SubRecipeParVec.size(); + for(int m=0;mWriteDebugLog(Log); + return true; +} +//ǰĿ¼ +CString CRecipeMgr::CreatCurParDataPath() +{ + CString MonitoringDataPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(PARA_MODIFY_DATA_PATH); + CString Path = MonitoringDataPath; + CFileMgr FileMgr; + CWorkTime WorkTime; + Path += WorkTime.GetCurYear(); + Path += "\\"+WorkTime.GetCurMonth(); + Path += "\\"+WorkTime.GetCurDay(); + Path += "\\"; + if(!FileMgr.IsDirectoryExists(Path)) + { + FileMgr.CreatDir(Path); + } + return Path; +} +void CRecipeMgr::ResetParIdxSet() +{ + m_ErrRangeParIdxSet.clear(); + m_ChangeParIdxSet.clear(); +} +//浱ǰ༭recipe +bool CRecipeMgr::SaveEditRecipePar(CListCtrl &ListCtrl,CListCtrl &RecipeInfoList) +{ + CMsgBox MsgBox; + ResetParIdxSet(); + if(!IsbSelEditRecipe()) + { + MsgBox.Show("ûѡҪRecipe"); + return false; + } + CWorkTime WorkTime; + bool bHasParChange = false;//Ƿв仯 + CCsvData CsvData; + CsvData.AddData("û",false); + CsvData.AddData(gAuthorityMgr->GetCurUserName(),true); + CsvData.AddData("ʱ",false); + CsvData.AddData(WorkTime.GetDateTime("/",":"),true); + CsvData.AddData("Recipe Name",false); + CsvData.AddData(m_CurEditRecipe.m_RecipeName,true); + CsvData.AddData("SubRecipe Name",false); + CsvData.AddData(m_CurEditRecipe.GetCurSubRecipeName(),true); + CsvData.AddData("SubRecipe Idx",false); + CsvData.AddData(Int2CString(m_CurEditRecipe.GetCurSubRecipeIdx()),true); + CsvData.AddData("rcp·",false); + CsvData.AddData(m_CurEditRecipe.m_FilePath,true); + + CsvData.AddData(" ",false); + CsvData.AddData(" ",true); + + CsvData.AddData("",false); + CsvData.AddData("ֵ",false); + CsvData.AddData("޸ֵ",true); + + CRecipe RecipeTmp = m_CurEditRecipe;//ʱrecipe ¼range ʱʱֵ + bool bLaser1EdiZero = false;//Edi ǷΪ0 + bool bLaser2EdiZero = false; + + bool bRangeCheckOk = true;//Χ + vector &RecipeParVec = m_CurEditRecipe.GetRecipeParVec(); + vector &RecipeParVecTmp = RecipeTmp.GetRecipeParVec(); + int size = RecipeParVec.size(); + for(int k=0;k=RecipePar.m_DoubleMinVal && Val<=RecipePar.m_DoubleMaxVal)) + { + bRangeCheckOk = false; + RecipeParTmp.m_ParDoubleVal = CStringToDouble(ParValStr); + m_ErrRangeParIdxSet.insert(k); + } + else + { + RecipePar.m_ParDoubleVal = CStringToDouble(ParValStr); + RecipeParTmp.m_ParDoubleVal = RecipePar.m_ParDoubleVal; + if(RecipePar.m_ParName==RECIPE_PAR_NAME_LASER_EDI_1 && IsDbEqualZero(RecipePar.m_ParDoubleVal)) + { + bLaser1EdiZero = true; + } + if(RecipePar.m_ParName==RECIPE_PAR_NAME_LASER_EDI_2 && IsDbEqualZero(RecipePar.m_ParDoubleVal)) + { + bLaser2EdiZero = true; + } + } + + } + else if(RecipePar.m_ParType==_RecipeParType_Bool) + { + RecipePar.m_ParBoolVal = (ParValStr==BOOL_STR_ON)?true:false; + RecipeParTmp.m_ParBoolVal = RecipePar.m_ParBoolVal; + } + else if(RecipePar.m_ParType==_RecipeParType_Int) + { + RecipePar.m_ParIntVal = CStringToDouble(ParValStr); + RecipeParTmp.m_ParIntVal = RecipePar.m_ParIntVal; + } + else if(RecipePar.m_ParType==_RecipeParType_CString) + { + RecipePar.m_ParStrVal = ParValStr; + RecipeParTmp.m_ParStrVal = RecipePar.m_ParStrVal; + } + ParValNew = RecipePar.GetParStr(); + Log += ParValNew; + Log += "]"; + gLogMgr->WriteDebugLog(Log); + + //ֻ¼Ǽ + if(!RecipePar.m_bRcpInfoPar) + { + if(ParValOld!=ParValNew) + { + bHasParChange = true; + m_ChangeParIdxSet.insert(k); + } + else//ޱ仯 + { + ParValNew = ""; + } + CsvData.AddData(RecipePar.m_ParShowName,false); + CsvData.AddData(ParValOld,false); + CsvData.AddData(ParValNew,true); + } + } + //recipe ķò + UpdateEditRecipeList(ListCtrl,RecipeInfoList,false); + //ķΧ + { + vector &RecipeParVec = m_CurEditRecipe.GetRecipeParVec(); + int size = RecipeParVec.size(); + for(int k=0;k=RecipePar.m_DoubleMinVal && RecipePar.m_ParDoubleVal<=RecipePar.m_DoubleMaxVal)) + { + //ediΪ0ʱdimmer ang == nanҪʾ + if(RecipePar.m_ParName==RECIPE_PAR_NAME_ROTATO_DIMMER_ANG && bLaser1EdiZero) + continue; + if(RecipePar.m_ParName==RECIPE_PAR_NAME_ROTATO_DIMMER_ANG2 && bLaser2EdiZero) + continue; + bRangeCheckOk = false; + m_ErrRangeParIdxSet.insert(k); + } + } + } + } + //ˢlist ʾ + UpdateEditRecipeListExt(ListCtrl,RecipeTmp); + if(!bRangeCheckOk) + { + MsgBox.Show("Χʧ"); + return false; + } + //޸ļ¼ + if(bHasParChange)//б仯ʱű + { + CString FileName = WorkTime.GetCurTime("_"); + FileName += "_"; + FileName += m_CurEditRecipe.m_RecipeName; + CString DataPath = CreatCurParDataPath(); + CFileMgr FileMgr; + FileMgr.WriteDataToExcel(DataPath,FileName,CsvData,false); + } + CString RecipeFilePath = GetCtrlRecipeFilePath(m_CurSelGroupName,m_CurEditRecipe.m_RecipeName); + SaveRecipeToXml(m_CurEditRecipe.m_FilePath,m_CurEditRecipe); + + CString s = m_CurEditRecipe.m_RecipeName; + if(bHasParChange) + s += " ޸ijɹ"; + else + s += " ޱ仯"; + MsgBox.Show(s); + return true; +} +//recipeIJ¼ +void CRecipeMgr::SaveRecipeHistoy(CRecipeCtrlPar RecipeCtrlPar) +{ + CWorkTime WorkTime; + CCsvData CsvData; + CsvData.AddData("û",false); + CsvData.AddData(gAuthorityMgr->GetCurUserName(),true); + CsvData.AddData("ʱ",false); + CsvData.AddData(WorkTime.GetDateTime("/",":"),true); + CsvData.AddData("rcp·",false); + CsvData.AddData(RecipeCtrlPar.m_FilePath,true); + CsvData.AddData("",false); + CsvData.AddData(GetRecipeCtrlName(RecipeCtrlPar.m_CtrlType),true); + + CsvData.AddData("Recipe Name",false); + CsvData.AddData(RecipeCtrlPar.m_RcpName,true); + + + switch(RecipeCtrlPar.m_CtrlType) + { + case _RecipeCtrl_CopyRecipe: + { + CsvData.AddData("Copy Recipe Name",false); + CsvData.AddData(RecipeCtrlPar.m_RcpNameNew,true); + } + break; + case _RecipeCtrl_RecipeName: + { + CsvData.AddData("New Recipe Name",false); + CsvData.AddData(RecipeCtrlPar.m_RcpNameNew,true); + } + break; + case _RecipeCtrl_MoveRecipe: + { + CsvData.AddData("rcpƶ·",false); + CsvData.AddData(RecipeCtrlPar.m_NewFilePath,true); + } + break; + case _RecipeCtrl_AddSubRecipe: + case _RecipeCtrl_DelSubRecipe: + { + CsvData.AddData("Sub Recipe Name",false); + CsvData.AddData(RecipeCtrlPar.m_SubRcpName,true); + } + break; + default: + break; + } + + CString FileName = WorkTime.GetCurTime("_"); + FileName += "_"; + FileName += RecipeCtrlPar.m_RcpName; + CString DataPath = CreatCurParDataPath(); + CFileMgr FileMgr; + FileMgr.WriteDataToExcel(DataPath,FileName,CsvData,false); +} +//µǰЧֵ +void CRecipeMgr::UpdateInvalidParIdxSet(CRecipe &Recipe) +{ + m_InvalidParIdxSet.clear(); + CRecipeParameter RecipePar; + //edi check scope Ϊ0 ʱЧ,ʹconfig + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_EDI_CHECK_SCOPE); + if(IsDbEqualZero(RecipePar.m_ParDoubleVal)) + m_InvalidParIdxSet.insert(Rcp_EdiScope_Idx); + //˹̶ɨٶ,صX Ч + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_FIX_SCAN_SPEED); + if(!IsDbEqualZero(RecipePar.m_ParDoubleVal)) + m_InvalidParIdxSet.insert(Rcp_OverlapX_Idx); + else + m_InvalidParIdxSet.insert(Rcp_FixSpeed_Idx); + //˹̶ɨ,صY Ч + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_FIX_SCAN_LINE_GAP); + if(!IsDbEqualZero(RecipePar.m_ParDoubleVal)) + m_InvalidParIdxSet.insert(Rcp_OverlapY_Idx); + else + m_InvalidParIdxSet.insert(Rcp_FixGap_Idx); + + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_OFFSET_TAB); + if(RecipePar.m_ParStrVal ==RECIPE_OFFSET_TBL_NULL) + m_InvalidParIdxSet.insert(Rcp_OffsetTab_Idx); +} + +#endif +#if 1 +//recipe ķò +bool CRecipeMgr::UpdateRecipeInfoPar(CRecipe &Recipe) +{ + CString log; + log = "Flow---->UpdateRecipeInfoPar : "; + log += Recipe.m_RecipeName; + gLogMgr->WriteDebugLog(log); + //ϵͳ + gLaser->UpdateLaserProp(); + int BakSubRecipeIdx = Recipe.GetCurSubRecipeIdx();//ڻָ + vector &SubRecipeVec = Recipe.GetSubRecipeVec(); + int size = SubRecipeVec.size(); + for(int k=0;kGetSpotSize(_LaserDeviceType_MainLaser1);//߳ߴ + + if(gLaser->IsbScanByDirX()) + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_OVERLAP_RATIO_X); + else + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_OVERLAP_RATIO_Y); + OverlapRatio = RecipePar.m_ParDoubleVal; + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER_FRE); + Laser1Fre = RecipePar.m_ParDoubleVal; + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER2_FRE); + Laser2Fre = RecipePar.m_ParDoubleVal; + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER_EDI_1); + Laser1Edi = RecipePar.m_ParDoubleVal; + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER_EDI_2); + Laser2Edi = RecipePar.m_ParDoubleVal; + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER_EDI_OFFSET_1); + Laser1EdiOffset = RecipePar.m_ParDoubleVal; + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER_EDI_OFFSET_2); + Laser2EdiOffset = RecipePar.m_ParDoubleVal; + + //ص/Ƶ/߳ߴ---->ɨٶ + double ScanSpeed = gWaferRecipeDataMgr->CalScanSpeedByOverlapRatio(OverlapRatio,Laser1Fre); + if(ScanSpeed>0) + { + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_SCAN_SPEED); + RecipePar.m_ParDoubleVal = ScanSpeed; + Recipe.SetRecipePar(RECIPE_PAR_NAME_SCAN_SPEED,RecipePar); + } + //Recipe е趨ֵ + //ǹ̶ӦĹֵ(Ƶй) + double Laser1FixCurr = 0; + double Laser2FixCurr = 0; + { + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER_CURR_1); + Laser1FixCurr = RecipePar.m_ParDoubleVal; + Recipe.SetRecipePar(RECIPE_PAR_NAME_LASER_CURR_1,RecipePar); + } + { + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER_CURR_2); + Laser2FixCurr = RecipePar.m_ParDoubleVal; + Recipe.SetRecipePar(RECIPE_PAR_NAME_LASER_CURR_2,RecipePar); + } + double Laser1FixPow = 0; + double Laser2FixPow = 0; + gLaser->GetLaserFixedCurrentPow(_LaserDeviceType_MainLaser1,Laser1Fre,Laser1FixCurr,Laser1FixPow); + gLaser->GetLaserFixedCurrentPow(_LaserDeviceType_MainLaser2,Laser2Fre,Laser2FixCurr,Laser2FixPow); + { + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER1_POW); + RecipePar.m_ParDoubleVal = Laser1FixPow; + Recipe.SetRecipePar(RECIPE_PAR_NAME_LASER1_POW,RecipePar); + } + { + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_LASER2_POW); + RecipePar.m_ParDoubleVal = Laser2FixPow; + Recipe.SetRecipePar(RECIPE_PAR_NAME_LASER2_POW,RecipePar); + } + //ȡʲ + { + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_OFFSET_TAB); + CString OffsetTableName = RecipePar.m_ParStrVal; + if(!Recipe.ReadOffsetTableFile(OffsetTableName)) + { + //Ϊ쳣 + m_ErrRangeParIdxSet.insert(Rcp_OffsetTab_Idx); + } + } + //[ܶ/Ƶ/߳ߴ]--->[˥תǶ] + { + double OffsetTabEdi = Recipe.GetOffsetParVal(RECIPE_OFFSET_PAR_LASER1_EDI); + double Edi = Laser1Edi + Laser1EdiOffset + OffsetTabEdi; + double RotatoDimmerAng = gWaferRecipeDataMgr->CalRotatoDimmerAng(SpotSize.w,SpotSize.h,Edi,Laser1Fre,Laser1FixPow); + if(!(RotatoDimmerAng>-180 && RotatoDimmerAng<180))//Ч㷶Χ + { + log.Format("Err Ang = %lf",RotatoDimmerAng); + gLogMgr->WriteDebugLog(log); + } + + { + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_ROTATO_DIMMER_ANG); + RecipePar.m_ParDoubleVal = RotatoDimmerAng; + Recipe.SetRecipePar(RECIPE_PAR_NAME_ROTATO_DIMMER_ANG,RecipePar); + } + } + { + double OffsetTabEdi = Recipe.GetOffsetParVal(RECIPE_OFFSET_PAR_LASER2_EDI); + double Edi = Laser2Edi + Laser2EdiOffset + OffsetTabEdi; + double RotatoDimmerAng = gWaferRecipeDataMgr->CalRotatoDimmerAng(SpotSize.w,SpotSize.h,Edi,Laser2Fre,Laser2FixPow); + if(!(RotatoDimmerAng>-180 && RotatoDimmerAng<180))//Ч㷶Χ + { + log.Format("Err Ang = %lf",RotatoDimmerAng); + gLogMgr->WriteDebugLog(log); + } + { + RecipePar = Recipe.GetRecipePar(RECIPE_PAR_NAME_ROTATO_DIMMER_ANG2); + RecipePar.m_ParDoubleVal = RotatoDimmerAng; + Recipe.SetRecipePar(RECIPE_PAR_NAME_ROTATO_DIMMER_ANG2,RecipePar); + } + } + } + + Recipe.SetCurSubRecipeIdx(BakSubRecipeIdx);//ָ + return true; +} +//ͨȡǰrecipe +CRecipeParameter CRecipeMgr::GetCurRecipePar(CString ParName) +{ + return m_CurWorkRecipe.GetRecipePar(ParName); +} +void CRecipeMgr::CreatCurEditRecipeScanPath() +{ + //ɨ + CRecipe &CurEditRecipe = m_CurEditRecipe; + CRecipeParameter RecipePar = CurEditRecipe.GetRecipePar(RECIPE_PAR_NAME_SCAN_AREA); + CString AreaName = RecipePar.m_ParStrVal; + RecipePar = CurEditRecipe.GetRecipePar(RECIPE_PAR_NAME_AREA_IDX); + int AreaIdx = RecipePar.m_ParIntVal-1; + CreatScanPath(AreaName,AreaIdx); +} +#endif + +#if 1 +void CRecipeMgr::UpdateEditRecipeListExt(CRecipe &Recipe,CListCtrl &RecipeList,CListCtrl &RecipeInfoList) +{ + if(!Recipe.IsValid()) + return; + RecipeList.DeleteAllItems(); + RecipeInfoList.DeleteAllItems(); + //recipe ķò + UpdateRecipeInfoPar(Recipe); + + vector &RecipeParVec = Recipe.GetRecipeParVec(); + int size = RecipeParVec.size(); + if(size<=0) + return; + int RecipeListIdx = 0; + int RecipeInfoListIdx = 0; + for(int k=0;k &SubRecipeVec = Recipe.GetSubRecipeVec(); + int size = SubRecipeVec.size(); + if(size<=0) + return; + for(int k=0;k RcpGroupPathVec; + CString DirPath = GetRecipePath(); + CFileMgr FileMgr; + //ҵļе· + FileMgr.GetChildFileOrDirName(true,DirPath,RcpGroupPathVec,""); + //ȡļ + int size = RcpGroupPathVec.size(); + for(int k=0;k RcpPathVec; + FileMgr.GetChildFileOrDirName(false,RcpGroupPathVec[k],RcpPathVec,RECIPE_FILE_SUFFIX); + int size1 = RcpPathVec.size(); + for(int i=0;iWriteDebugLog("Func---->UpdateLaserFocusProp"); + //⽹ֵ + double FocusZMoveUpVal = 0; + { + //Աӳ + CString Path = "Laser"; + CString Name = _T("m_FocusZMoveUpVal");// + CPropertie Propertie; + Propertie.SetpVal((void*)&FocusZMoveUpVal); + Propertie.SetType(_PROP_TYPE_DOUBLE); + Propertie.SetPath(Path); + Propertie.SetName(Name); + Propertie.WriteRead(true);//ȡ + } + //Z + double DistanceMeterPosZ = 0; + { + //Աӳ + CString Path = "PlatSpecialPosMgr"; + CString Name = _T("m_SpecialPosTypeDistance_MeterPos_z");// + CPropertie Propertie; + Propertie.SetpVal((void*)&DistanceMeterPosZ); + Propertie.SetType(_PROP_TYPE_DOUBLE); + Propertie.SetPath(Path); + Propertie.SetName(Name); + Propertie.WriteRead(true);//ȡ + } + //Zᰲȫ + double MotorZSafeCoord = 0; + { + //Աӳ + CString Path = "PlatSpecialPosMgr"; + CString Name = _T("m_MotorZSafeCoord");// + CPropertie Propertie; + Propertie.SetpVal((void*)&MotorZSafeCoord); + Propertie.SetType(_PROP_TYPE_DOUBLE); + Propertie.SetPath(Path); + Propertie.SetName(Name); + Propertie.WriteRead(true);//ȡ + } + + CString log; + log.Format("FocusZMoveUpVal=%f,DistanceMeterPosZ=%f,MotorZSafeCoord=%f",FocusZMoveUpVal,DistanceMeterPosZ,MotorZSafeCoord); + gLogMgr->WriteDebugLog(log); + + //㽹΢Χ + double LaserFocusZ = DistanceMeterPosZ + FocusZMoveUpVal; + + m_FocusAdjustMin = (MotorZSafeCoord - LaserFocusZ)+0.5;//ϵ0.5mm + m_FocusAdjustMax = (LaserFocusZ*-1)-1;////µ1 mm + + log.Format("LaserFocusZ=%f,FocusAdjustMin=%f,FocusAdjustMax=%f",LaserFocusZ,m_FocusAdjustMin,m_FocusAdjustMax); + gLogMgr->WriteDebugLog(log); +} +//ȡTabName · +CString CRecipeMgr::GetOffsetTablePath(CString TabName) +{ + CString TabPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(OFFSET_TAB_FILE_PATH); + TabPath += TabName; + TabPath += ".tbl"; + return TabPath; +} +#endif + +#endif diff --git a/LaipuDrawing/RecipeMgr.h b/LaipuDrawing/RecipeMgr.h new file mode 100644 index 0000000..70e4147 --- /dev/null +++ b/LaipuDrawing/RecipeMgr.h @@ -0,0 +1,324 @@ +#pragma once +#include "GlobalDefine.h" +#include "module.h" +#include "OffsetTable.h" + + + + +#define Rcp_AreaName_Idx 18 //ɨƲֵ(ǰ˲Ҫֵ) +#define Rcp_AreaIdx_Idx (Rcp_AreaName_Idx+1) +#define Rcp_N2_Idx (Rcp_AreaIdx_Idx+1)//N2 +#define Rcp_UseCurN2Val_Idx (Rcp_N2_Idx+1)//ʹRecipeMFCֵ +#define Rcp_OffsetTab_Idx (Rcp_UseCurN2Val_Idx+1)// +#define Rcp_RunTimes_Idx (Rcp_OffsetTab_Idx+1)//д + +#define Rcp_CalInfo_Start_Idx (Rcp_RunTimes_Idx+1) //ʼֵ + + + + +#define Rcp_EdiScope_Idx 9 //ܶȸ쾫 +#define Rcp_OverlapX_Idx (Rcp_EdiScope_Idx+1) +#define Rcp_OverlapY_Idx (Rcp_OverlapX_Idx+1) +#define Rcp_FixSpeed_Idx (Rcp_OverlapY_Idx+2) +#define Rcp_FixGap_Idx (Rcp_FixSpeed_Idx+1) + + + +#define Rcp_List_Val_Col 6//list ек + + +// +enum ERecipeParType +{ + _RecipeParType_Null = 0, + _RecipeParType_Double, + _RecipeParType_Bool, + _RecipeParType_CString, + _RecipeParType_Int, +}; + +enum ERecipeCtrlType +{ + _RecipeCtrl_AddGroup = 0, + _RecipeCtrl_DelGroup, + _RecipeCtrl_GroupName, + _RecipeCtrl_AddRecipe, + _RecipeCtrl_DelRecipe, + _RecipeCtrl_CopyRecipe, + _RecipeCtrl_MoveRecipe, + _RecipeCtrl_RecipeName, + _RecipeCtrl_AddSubRecipe, + _RecipeCtrl_DelSubRecipe, + _RecipeCtrl_SubRecipeName, +}; + +//һrecipe +class CRecipeParameter +{ +public: + CRecipeParameter() + { + m_ParDoubleVal = 0;//ֵ + m_DoubleMinVal = 0;//Сֵ + m_DoubleMaxVal = 0;//ֵ + m_ParIntVal = 0; + m_ParType = _RecipeParType_Double;// + m_ListItemWidht = 100;//б + m_bRcpInfoPar = false;//ǷΪ(ܱ༭) + m_ParUnit = "/";//ĵλ,ʾ + }; + CString GetParStr(); + void SetValByStr(CString s); + CString GetParTypeStr(); + void SetTypeByStr(CString TypeStr); + void GetRangeStr(CString &Min,CString &Max); +public: + CString m_ParName;//() + double m_ParDoubleVal;//ֵ() + bool m_ParBoolVal;//bool ֵ() + CString m_ParStrVal;//ֵַ() + int m_ParIntVal;//ֵ() + + CString m_ParShowName;// + ERecipeParType m_ParType;// + int m_ListItemWidht;//б + + double m_DoubleMinVal;//Сֵ + double m_DoubleMaxVal;//ֵ + + bool m_bRcpInfoPar;//ǷΪ(ܱ༭) + CString m_ParUnit;//ĵλ,ʾ +}; + +class CRecipeCtrlItem +{ +public: + CRecipeCtrlItem(){}; +public: + CString m_DlgTitle; + CString *m_EditName1; + CString *m_EditName2; + CComboBox *m_RecipeCtrlGroupComb; + CString m_SelGroupName; +}; + +class CRecipeParCtrlItem +{ +public: + CRecipeParCtrlItem(){}; +public: + double *m_EditParVal; + CString *m_EditParName; + CComboBox *m_SelScanAreaComb; + CComboBox *m_SelScanAreaIdxComb; + CComboBox *m_SelBoolValComb; + CComboBox *m_SelOffsetTableComb; + + CString m_SelScanAreaStr; + +}; + +class CSubRecipe +{ +public: + CSubRecipe(); + void IntiRecipeParVec(); + void ReadMFCCtrlScalFile(); +public: + CString m_SubRecipeName; + bool m_bUseSubRecipe;//Ƿʹ + vector m_RecipeParVec;// + + COffsetTable m_OffsetTable;// + + vector> MFCScalStrVec; +}; + +class CRecipeCtrlPar +{ +public: + CRecipeCtrlPar(){}; +public: + ERecipeCtrlType m_CtrlType; + CString m_FilePath; + CString m_NewFilePath; + CString m_RcpName; + CString m_RcpNameNew; + CString m_SubRcpName; + CString m_SubRcpNameNew; +}; + + + +//һRecipe (иֵ) +class CRecipe +{ +public: + CRecipe(); + void RecipeReset(); + bool IsValid(); + void SaveRecipeParToFile(CString FilePath); + void ReadRecipeParFromFile(CString FilePath); + CRecipeParameter GetRecipePar(CString ParName);//ȡΪParName ֵ + void SetRecipePar(CString ParName,CRecipeParameter RecipePar);//òΪParName ֵ + + bool CheckParRange(bool bShowMsg); + bool CheckParRangeByName(CString ParName,double val); + bool CheckParRangeExt(CRecipeParameter &RecipePar,double ParVal,bool bShowMsg); + CString GetShowName(); + + vector &GetRecipeParVec(); + vector &GetSubRecipeVec(){return m_SubRecipeVec;}; + void AddSubRecipe(CString SubRecipeName); + int GetCurSubRecipeIdx(){return m_CurSubRecipeIdx;}; + void SetCurSubRecipeIdx(int idx){m_CurSubRecipeIdx = idx;}; + CString GetCurSubRecipeName(); + void SetCurSubRecipeName(CString Name); + void DelSubRecipe(CString SubRecipeName); + bool ReadOffsetTableFile(CString TableName); + double GetOffsetParVal(CString ParName); +public: + int m_GroupIdx;//ı(1~10) + int m_RecipeIdx;//еı(1~50) + double m_DoubleValCnt;//double Ͳ + + //µIJ + CString m_RecipeName;//Recipe + CString m_FilePath;//洢Ŀ¼ + bool m_bEnableEdit;//ǰʱԱ༭ + int m_CurSubRecipeIdx;//ǰʹõSubRecipe (ֵܳΧ)(༭ͼӹʱõ) + vector m_SubRecipeVec;//һƬwafer recipe ִ(ҪһSubRecipe ᱨ) + + + +}; + +//recipe +class CRecipeMgr:public CModule +{ +public: + CRecipeMgr(void); + virtual ~CRecipeMgr(void); + virtual void OnAppInitialize(); + void InitRecipeGourpFile(); + CRecipeParameter GetCurRecipePar(CString ParName); + void SelRecipeScanArea(CComboBox &ComboBox); + void SetCurSelGourpIdx(int Idx); + void SetCurSelRecipeIdx(int Idx); + void SetbChangeName(bool b){m_bChangeGroupName = b;}; + bool GetbChangeName(){return m_bChangeGroupName;}; + void SaveCurSelRecipe(CRecipe Recipe); + CRecipe GetCurWorkRecipe(){return m_CurWorkRecipe;}; + void SetCurWorkRecipe(CRecipe Recipe){m_CurWorkRecipe = Recipe;}; + CString GetCurSelGroupName(); + CString GetSelGroupRecipeStr(); + void UpdateSelRecipeList(CListCtrl &List,bool bInsert); + void CreatRecipeScanPath(CRecipe *pRecipe,int SubRecipeIdx); + bool EditRecipeByCtrlType(ERecipeCtrlType t); + ERecipeCtrlType GetCurRecipeCtrlType(){return m_CurRecipeCtrlType;}; + CString RecipeCtrlExcute(CRecipeCtrlItem &CtrlItem); + void BindingRecipeGroupComb(CComboBox *p); + void RecipeCtrlInit(CRecipeCtrlItem &CtrlItem); + void InitGroupRecipeList(CListCtrl &List); + void UpdateGroupRecipeList(CListCtrl &List); + void InitEditRecipeList(CListCtrl &List,bool bShowParRange); + void InitEditSubRecipeList(CListCtrl &List); + void UpdateEditRecipeList(CListCtrl &RecipeList,CListCtrl &RecipeInfoList,bool bResetErrRangeParIdxSet=true); + void UpdateEditSubRecipeList(CListCtrl &List); + bool SaveEditRecipePar(CListCtrl &ListCtrl,CListCtrl &RecipeInfoList); + void AddSubRecipe(CString SubRecipeName); + void SetSubRecipeIdx(int idx); + bool MoveSubRecipe(bool bMoveUp); + void OnSelRecipeIdxChange(int idx); + bool ReadEditRecipeFromFile(); + CString GetCurEditRecipeInfo(); + CString GetCurEditSubRecipeInfo(); + void ChangeRecipeName(CString NewRcpName); + void DelSubRecipe(CString SubRecipeName); + void SetCurSelRecipeName(CString s){m_CurSelRecipeName = s;}; + void UpdatParBoolComb(CComboBox &Comb); + void UpdateAreaIdxCombo(CComboBox &AreaIdxComb); + bool UpdateRecipeInfoPar(CRecipe &Recipe); + void UpdateRecipeGroupComb(CComboBox *pComb); + void UpdateSelRecipeComb(CComboBox &ComboBox,vector &SelGroupRecipeNameVec); + bool ReadEditRecipeFromFile(CRecipe &Recipe,int SelGroupIdx,CString SelRecipeName); + void UpdateAllRecipeParToList(CRecipe Recipe,CListCtrl &RecipeList); + CString GetCtrlRecipeFilePath(CString GroupName,CString RecipeName); + void UpdateSelSubRecipeComb(CComboBox &ComboBox,CRecipe Recipe); + void CreatScanPath(CString AreaName,int AreaIdx); + CRecipe GetCurEditRecipe(){return m_CurEditRecipe;}; + void CreatCurEditRecipeScanPath(); + void UpdateRecipeGroupVec(); + void UpdateEditRecipeListExt(CRecipe &Recipe,CListCtrl &RecipeList,CListCtrl &RecipeInfoList); + void UpdateEditSubRecipeListExt(CRecipe &Recipe,CListCtrl &List); + CString GetAreaIdxStr(int k); + CString CreatCurParDataPath(); + void SaveRecipeHistoy(CRecipeCtrlPar RecipeCtrlPar); + bool CheckRecipeNameExist(CString RecipeName); + CString GetRecipePathByName(CString RecipeName); + void DeleteRecipeGroup(CString GroupName); + bool IsErrRangeParIdx(int idx){return m_ErrRangeParIdxSet.count(idx);}; + bool IsChangeParIdx(int idx){return m_ChangeParIdxSet.count(idx);}; + bool IsInvalidParIdx(int idx){return m_InvalidParIdxSet.count(idx);}; + void UpdateEditRecipeListExt(CListCtrl &RecipeList,CRecipe &Recipe); + void UpdateInvalidParIdxSet(CRecipe &Recipe); + void UpdateLaserFocusProp(); + void UpdateRecipeGroupInfo(); + CString GetOffsetTablePath(CString TabName); +private: + CString GetGroupDirPath(int GroupIdx); + CString GetRecipeNameListPath(); + CString GetRecipeFilePath(int GroupIdx,int RecipeIdx); + + CString GetRecipePath(); + void CreatRecipeFilePath(); + + void AddRecipeGroup(CString GroupName); + void AddRecipe(CString GroupName,CString RecipeName); + + void ChangeGroupName(CString NewGroupName); + CString GetRecipeCtrlName(ERecipeCtrlType RecipeCtrlType); + void ChangeSubRecipeName(CString NewRcpName); + void SaveRecipeToXml(CString FilePath,CRecipe &Recipe); + void ReadCurGroupRecipeName(vector &SelGroupRecipeNameVec); + bool ReadRecipeFromXml(CString FilePath,CRecipe &Recipe); + void MoveRecipe(CString GroupName,CString RecipeName); + void CopyRecipe(CString NewRecipeName); + void DeletRecipe(CString RecipeName); + bool IsbSelEditRecipe(); + void ResetParIdxSet(); + +private: + CRecipe m_CurWorkRecipe;//ǰӹʹõrecipe + + bool m_bChangeGroupName;//true group ,false recipe + vector m_RecipeGroupNameVec; + int m_CurSelGroupIdx;//ǰѡgourp ֵ + vector m_CurGroupRecipeVec;//ǰrecipe + int m_CurSelRecipeIdx;//ǰѡrecipe ֵ + + //µIJ + vector m_NewRecipeGroupNameVec;// + vector m_CurSelGroupRecipeNameVec;//ǰѡеrecipe + ERecipeCtrlType m_CurRecipeCtrlType;//ǰIJ + CComboBox *m_pRecipeGroupComb; + int m_CurSelRecipeParIdx;//ǰѡpar ֵ + + CString m_CurSelGroupName;//ǰѡGroup + CString m_CurSelRecipeName;//ǰѡrecipe + CRecipe m_CurEditRecipe;//ǰ༭recipe + + //recipe list ʾֵ + set m_ErrRangeParIdxSet;//Χֵ + set m_ChangeParIdxSet;//仯ֵ + set m_InvalidParIdxSet;//Чֵ + + double m_FocusAdjustMin;//ΧСֵ + double m_FocusAdjustMax;//Χֵ + + +}; + +extern CRecipeMgr *gRecipeMgr; \ No newline at end of file diff --git a/LaipuDrawing/Ruler.cpp b/LaipuDrawing/Ruler.cpp new file mode 100644 index 0000000..75efaa7 --- /dev/null +++ b/LaipuDrawing/Ruler.cpp @@ -0,0 +1,484 @@ +#include "StdAfx.h" +#include "Ruler.h" +#include "GlobalDrawMgr.h" +#include "GlobalFunction.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "WorkAreaMgr.h" + + + +#define RULER_WIDETH (22) //ߵĿ--(λ:)view仯 +#define RULER_GAP (1) //ߵļ--(λ:) +#define RULER_NUM_WIDTH (6) //ֵĿ--(λ:)view仯 +#define RULER_NUM_HEIGHT (10) //ֵĸ߶--(λ:)view仯 + +CRuler *gRuler = new CRuler; +CRuler::CRuler(void) +{ + m_bDrawRuler = true;//ǷƱ + m_MousePointTmp.x = -1;//¼ʱλ + m_MousePointTmp.y = -1; +} +CRuler::~CRuler(void) +{ +} +CMFCPropertyGridProperty *CRuler::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = _T("LogMgr");;//洢· + CString Name; +//-------------------------------------------------------------------------------// + PropertyName = _T(""); + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + { + //Աӳ + Name = _T("m_bDrawRuler");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bDrawRuler); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ʾ"); + Description = _T("Ƿʾ(Сλ: mm)"); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bDrawRuler, Description); + pGroup->AddSubItem(p1); + + gDevicePropertieMgr.Insert(p1, pPropertie); + } +//-------------------------------------------------------------------------------// + return pGroup; +} +void CRuler::OnPropertyChanged() +{ + //ȡǰָ + CLaiPuLaserView *pView = GetCurViewPtr(); + if(pView) + { + pView->RefreshView(); + } +} +void CRuler::Draw(CDC* pDC) +{ + DrawRuler(pDC); +} +//Ʊ +void CRuler::DrawRuler(CDC* pDC) +{ + if(!m_bDrawRuler) + return; + //ȡͻΧ + CRect rect; + GetCurViewPtr()->GetClientRect(&rect);//ȡڿͻ + pDC->DPtoLP(rect);//תΪ߼ +// + int RulerWideth = GetCurViewPtr()->GetCurrScaleVal(RULER_WIDETH); + //ߵij + int ShortLen = RulerWideth/4; + int ShortLen2 = RulerWideth/6; + int MidLen = RulerWideth/2; + int LongLen; + double zoomScale = GetCurViewPtr()->GetCurZoomScale(); + if(zoomScale>VIEW_SCALE9) + { + LongLen = RulerWideth/2; + } + else//̫Сʱ̵ + { + LongLen = RulerWideth/3; + } + + CPen pen; + pen.CreatePen(PS_SOLID,0.5,RGB_BLACK); + CBrush brush ; + brush.CreateSolidBrush(RGB_GRAY) ; + CPen* pOldPen = (CPen*)pDC->SelectObject(&pen); + CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&brush); + + int RulerX,RulerY; + RulerX = rect.left+RulerWideth; + RulerY = rect.top+RulerWideth; + //ˮƽ() + CRect DrawRectH(0,rect.top,SCROLL_SIZE_CX,RulerY); + pDC->Rectangle(DrawRectH); + //ֱ() + CRect DrawRectV(rect.left,0,RulerX,SCROLL_SIZE_CY); + pDC->Rectangle(DrawRectV); + + int count;// + int StartX = LOGIC_CENTER_X; + int StartY = LOGIC_CENTER_Y; + int gap;// + + gap = gDraw->Double2Int(1);//ÿ10 + + pDC->SetBkMode(TRANSPARENT);//͸ + CString FontTypeStr(""); + double TextHeight = GetCurViewPtr()->GetCurrScaleVal(RULER_NUM_HEIGHT);//߶ + double TextWidth = GetCurViewPtr()->GetCurrScaleVal(RULER_NUM_WIDTH);// +//ˮƽ-------------------------------------------------------- + //------------------------------------------------------ + SetCurFont(pDC,TextHeight,TextWidth,0,FALSE,FontTypeStr); + + DbSize size = gWorkAreaMgr->GetWorkArea().GetSize(); + int WorkSpaceWeidth = size.w; + int WorkSpaceHeight = size.h; + + double Scale1 = VIEW_SCALE1; + double Scale2 = VIEW_SCALE1; + double Scale3 = VIEW_SCALE1; +#if 1// + count = 0;// + for(int i=0;i<=(WorkSpaceWeidth);i += gap) + { + //ڹռ䷶Χʾ + if(zoomScale>Scale1)//ȫʾ + { + DrawRulerNum(pDC,count*10,StartX+i,RulerY-RulerWideth,TextWidth,TRUE); + } + else if(zoomScale>Scale2)//ÿ20 ʾ + { + if(count%2 == 0) + { + DrawRulerNum(pDC,count*10,StartX+i,RulerY-RulerWideth,TextWidth,TRUE); + } + } + else if(zoomScale>Scale3)//ÿ50 ʾ + { + if(count%5 == 0) + { + DrawRulerNum(pDC,count*10,StartX+i,RulerY-RulerWideth,TextWidth,TRUE); + } + } + else//ÿ200 ʾ + { + if(count%20 == 0) + { + DrawRulerNum(pDC,count*10,StartX+i,RulerY-RulerWideth,TextWidth,TRUE); + } + } + count++; + } +#endif + +#if 1// + count = 0;// + for(int i=0;i<=(WorkSpaceWeidth);i += gap) + { + if(count !=0) + { + //ڹռ䷶Χʾ + if(zoomScale>Scale1)//ȫʾ + { + DrawRulerNum(pDC,count*10,StartX-i,RulerY-RulerWideth,TextWidth,TRUE); + } + else if(zoomScale>Scale2)//ÿ20 ʾ + { + if(count%2 == 0) + { + DrawRulerNum(pDC,count*10,StartX-i,RulerY-RulerWideth,TextWidth,TRUE); + } + } + else if(zoomScale>Scale3)//ÿ50 ʾ + { + if(count%5 == 0) + { + DrawRulerNum(pDC,count*10,StartX-i,RulerY-RulerWideth,TextWidth,TRUE); + } + } + else//ÿ200 ʾ + { + if(count%20 == 0) + { + DrawRulerNum(pDC,count*10,StartX-i,RulerY-RulerWideth,TextWidth,TRUE); + } + } + } + count++; + } +#endif + +//ƴֱ-------------------------------------------------------- + //------------------------------------------------------ + SetCurFont(pDC,TextHeight,TextWidth,90,FALSE,FontTypeStr); + count = 0;// + // + for(int i=0;i<=(WorkSpaceWeidth);i += gap) + { + //ڹռ䷶Χʾ + if(zoomScale>Scale1)//ȫʾ + { + DrawRulerNum(pDC,count*10,RulerX-RulerWideth,StartY-i,TextWidth,FALSE); + } + else if(zoomScale>Scale2)//ÿ20 ʾ + { + if(count%2 == 0) + { + DrawRulerNum(pDC,count*10,RulerX-RulerWideth,StartY-i,TextWidth,FALSE); + } + } + else if(zoomScale>Scale3)//ÿ50 ʾ + { + if(count%5 == 0) + { + DrawRulerNum(pDC,count*10,RulerX-RulerWideth,StartY-i,TextWidth,FALSE); + } + } + else//ÿ200 ʾ + { + if(count%20 == 0) + { + DrawRulerNum(pDC,count*10,RulerX-RulerWideth,StartY-i,TextWidth,FALSE); + } + } + count++; + } + // + count = 0;// + for(int i=0;i<=(WorkSpaceWeidth);i += gap) + { + if(count != 0) + { + //ڹռ䷶Χʾ + if(zoomScale>Scale1)//ȫʾ + { + DrawRulerNum(pDC,count*10,RulerX-RulerWideth,StartY+i,TextWidth,FALSE); + } + else if(zoomScale>Scale2)//ÿ20 ʾ + { + if(count%2 == 0) + { + DrawRulerNum(pDC,count*10,RulerX-RulerWideth,StartY+i,TextWidth,FALSE); + } + } + else if(zoomScale>Scale3)//ÿ50 ʾ + { + if(count%5 == 0) + { + DrawRulerNum(pDC,count*10,RulerX-RulerWideth,StartY+i,TextWidth,FALSE); + } + } + else//ÿ200 ʾ + { + if(count%20 == 0) + { + DrawRulerNum(pDC,count*10,RulerX-RulerWideth,StartY+i,TextWidth,FALSE); + } + } + } + count++; + } +//ˮƽߵĺ + pDC->MoveTo(0,RulerY); + pDC->LineTo(SCROLL_SIZE_CX,RulerY); +//ֱߵ + pDC->MoveTo(RulerX,0); + pDC->LineTo(RulerX,SCROLL_SIZE_CY); +//---------------------------------------------------------- + count = 0;// + gap = gDraw->Double2Int(RULER_GAP); + for(int i=0;i<(SCROLL_SIZE_CX/2);i += gap) + { + if(count%10 == 0)//ÿ10 ׻ + { + if(zoomScale>VIEW_SCALE3)//Сʾ + { + //ˮƽ + pDC->MoveTo(StartX+i,RulerY); + pDC->LineTo(StartX+i,RulerY-LongLen); + pDC->MoveTo(StartX-i,RulerY); + pDC->LineTo(StartX-i,RulerY-LongLen); + //ֱ + pDC->MoveTo(RulerX,StartY+i); + pDC->LineTo(RulerX-LongLen,StartY+i); + pDC->MoveTo(RulerX,StartY-i); + pDC->LineTo(RulerX-LongLen,StartY-i); + } + } + else if(count%5 == 0)//ÿ5 ׻еȵ + { + if(zoomScale>VIEW_SCALE7)//Сʾ + { + //ˮƽ + pDC->MoveTo(StartX+i,RulerY); + pDC->LineTo(StartX+i,RulerY-MidLen); + pDC->MoveTo(StartX-i,RulerY); + pDC->LineTo(StartX-i,RulerY-MidLen); + //ֱ + pDC->MoveTo(RulerX,StartY+i); + pDC->LineTo(RulerX-MidLen,StartY+i); + pDC->MoveTo(RulerX,StartY-i); + pDC->LineTo(RulerX-MidLen,StartY-i); + } + } + else//ÿ1 + { + if(zoomScale>VIEW_SCALE12)//Сʾ + { + //ˮƽ + pDC->MoveTo(StartX+i,RulerY); + pDC->LineTo(StartX+i,RulerY-ShortLen); + pDC->MoveTo(StartX-i,RulerY); + pDC->LineTo(StartX-i,RulerY-ShortLen); + //ֱ + pDC->MoveTo(RulerX,StartY+i); + pDC->LineTo(RulerX-ShortLen,StartY+i); + pDC->MoveTo(RulerX,StartY-i); + pDC->LineTo(RulerX-ShortLen,StartY-i); + } + } + count++; + } + if(zoomScale>VIEW_SCALE20)//Ŵʾ0.1 ׼ + { + gap /= 10;//Ϊ0.1 + //ֻڹռķΧʾ + int max = max((int)WorkSpaceHeight,(int)WorkSpaceWeidth); + for(int i=0;i<(max);i += gap) + { + //ˮƽ + pDC->MoveTo(StartX+i,RulerY); + pDC->LineTo(StartX+i,RulerY-ShortLen2); + pDC->MoveTo(StartX-i,RulerY); + pDC->LineTo(StartX-i,RulerY-ShortLen2); + //ֱ + pDC->MoveTo(RulerX,StartY+i); + pDC->LineTo(RulerX-ShortLen2,StartY+i); + pDC->MoveTo(RulerX,StartY-i); + pDC->LineTo(RulerX-ShortLen2,StartY-i); + } + } + //IJ + CRect DrawRect(rect.left,rect.top,rect.left+RulerWideth,rect.top+RulerWideth); + pDC->Rectangle(DrawRect); + + pDC->SelectObject(pOldBrush); + pDC->SelectObject(pOldPen); + + m_MousePointTmp.x = -1; + m_MousePointTmp.y = -1; +} + +//Ʊߵ,bIsX == TRUEΪX +void CRuler::DrawRulerNum(CDC* pDC,int Num,int CurX,int CurY,double TextWidth,BOOL bIsX) +{ +//Num мλ + int NumTmp = Num; + int cnt = 0; + while(NumTmp>0) + { + NumTmp /=10; + cnt++; + } + if(cnt==0)//ֻһλʱ + { + cnt = 1; + } + if(bIsX) + { + CurX -= (cnt*TextWidth)/2;//ˮƽƫһ + } + else + { + CurY += (cnt*TextWidth)/2;//ֱ±ƫһ + } + CString TextString; + TextString.Format("%d",Num); + const char* pStr=(const char*)TextString; + int StrLen = strlen(pStr); + while(StrLen>0) + { + unsigned char char1; + char Char[3]; + char1 = *pStr; + strncpy(Char,pStr,1); + Char[1]='\0'; + pStr += 1; + StrLen -= 1; + pDC->TextOut(CurX,CurY,Char); + //һʼ + if(bIsX) + { + CurX += TextWidth; + } + else + { + CurY -= TextWidth; + } + } +} + +//õǰ +CFont* CRuler::SetCurFont(CDC *pDC,double TextHeight,double TextWidth,double RotateAngle,bool bIsItalic,CString FontTypeStr) +{ + //ʹõǰͼε + CFont font,*pOldFont; + font.CreateFont ( + TextHeight, // + 0,//TextWidth, // + RotateAngle*10, //Ƕ + 0, + FW_NORMAL, + bIsItalic, //б + 0, + 0, + DEFAULT_CHARSET, //ַ + OUT_CHARACTER_PRECIS, + CLIP_CHARACTER_PRECIS, + DEFAULT_QUALITY, + DEFAULT_PITCH |FF_DONTCARE, + FontTypeStr);// + + pOldFont = pDC->SelectObject(&font); + return pOldFont; +} + +//λ +void CRuler::DrawMousePos(CDC* pDC,CPoint point) +{ + if(!m_bDrawRuler) + return; + + double zoomScale = GetCurViewPtr()->GetCurZoomScale(); + int RulerWideth = RULER_WIDETH/zoomScale; + int CheckGap = RulerWideth/2;//ƫ +//ȡͻΧ + CRect rect; + GetCurViewPtr()->GetClientRect(&rect);//ȡڿͻ + pDC->DPtoLP(rect);//תΪ߼ + + //ǰµ,ػ + if(m_MousePointTmp.x == -1) + { + DrawRuler(pDC); + } + int old_rop = pDC->SetROP2(R2_XORPEN); + CPen pen; + pen.CreatePen(PS_SOLID,0.5,RGB_GRAY); + CPen* pOldPen = (CPen*)pDC->SelectObject(&pen); + + int RulerX,RulerY; + RulerX = rect.left+RulerWideth; + RulerY = rect.top+RulerWideth; + RulerX -= 1;// + RulerY -= 1;// + //ˮƽ + pDC->MoveTo(m_MousePointTmp.x,RulerY); + pDC->LineTo(m_MousePointTmp.x,RulerY-RulerWideth); + pDC->MoveTo(RulerX,m_MousePointTmp.y); + pDC->LineTo(RulerX-RulerWideth,m_MousePointTmp.y); + //ֱ + pDC->MoveTo(point.x,RulerY); + pDC->LineTo(point.x,RulerY-RulerWideth); + pDC->MoveTo(RulerX,point.y); + pDC->LineTo(RulerX-RulerWideth,point.y); + + pDC->SelectObject(pOldPen); + pDC->SetROP2(old_rop); +} \ No newline at end of file diff --git a/LaipuDrawing/Ruler.h b/LaipuDrawing/Ruler.h new file mode 100644 index 0000000..9a0cc2e --- /dev/null +++ b/LaipuDrawing/Ruler.h @@ -0,0 +1,23 @@ +#pragma once +#include "module.h" +class CRuler :public CModule +{ +public: + CRuler(void); + ~CRuler(void); + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual void OnPropertyChanged(); + virtual MODULE GetModuleType(){return _RULER_PROP;}; + virtual void Draw(CDC* pDC);//pDC һЩ + + void DrawMousePos(CDC* pDC,CPoint point); +private: + void DrawRuler(CDC* pDC); + void DrawRulerNum(CDC* pDC,int Num,int CurX,int CurY,double TextWidth,BOOL bIsX); + CFont* SetCurFont(CDC *pDC,double TextHeight,double TextWidth,double RotateAngle,bool bIsItalic,CString FontTypeStr); +private: + bool m_bDrawRuler;//ǷƱ + CPoint m_MousePointTmp;//¼ʱλ,ڱ +}; + +extern CRuler *gRuler; \ No newline at end of file diff --git a/LaipuDrawing/SFillPar.h b/LaipuDrawing/SFillPar.h new file mode 100644 index 0000000..1191d23 --- /dev/null +++ b/LaipuDrawing/SFillPar.h @@ -0,0 +1,14 @@ +#pragma once + +struct SFillPar{ +SFillPar() +{ + m_FillGap = 0.01;// + m_FillAngle = 90;//Ƕ(0~90)(360 Ƚ) + bFill = false;//Ƿ +} +bool bFill;//Ƿ +double m_FillGap;// +double m_FillAngle;//Ƕ(0~90)(360 Ƚ) +}; + diff --git a/LaipuDrawing/SFontPar.h b/LaipuDrawing/SFontPar.h new file mode 100644 index 0000000..83f598f --- /dev/null +++ b/LaipuDrawing/SFontPar.h @@ -0,0 +1,39 @@ +#pragma once + +struct SFontPar{ + enum TxtParGapType + { + _Center=0,//ĵ + _Boundary,//߽ + }; +SFontPar() +{ + m_CharGap = 1;//ַ + m_bArc = false;//ǷΪԲı + m_bReverse = false;//Ƿ + m_bOutDir = false;//ǷΪı + m_bVertical = false;//Ƿֱ + m_ArcRadius = 12;//Բ뾶 + m_CharHeight = 2;//ַ߶ + m_ItalicAngle = 0;//бǶ + m_ArcAngle = 0;//׼Ƕ + m_GapType = _Boundary;//ķʽ +} +//࣬߶ȣ +double m_CharHeight;//ַ߶ +double m_CharGap;//ַ +//бǶ +double m_ItalicAngle;//бǶ +double m_ArcRadius;//Բ뾶 +//׼Ƕ +double m_ArcAngle;//׼Ƕ + +TxtParGapType m_GapType;//ķʽ +//Ƿ +bool m_bReverse;//Ƿ +//з +bool m_bOutDir;//ǷΪı +bool m_bArc;//ǷΪԲı +bool m_bVertical;//Ƿֱ +}; + diff --git a/LaipuDrawing/SStringPar.h b/LaipuDrawing/SStringPar.h new file mode 100644 index 0000000..a20d5f8 --- /dev/null +++ b/LaipuDrawing/SStringPar.h @@ -0,0 +1,19 @@ +#pragma once +#include "ValString.h" + +struct SStringPar{ +SStringPar(){}; +void Copy(SStringPar &rhs); +public: +CValString m_ValString;//ɱı +CString m_FontTypeName;//͵ +CString m_FontName;// +}; + +inline void SStringPar::Copy(SStringPar &rhs) +{ + m_ValString.Copy(rhs.m_ValString); + m_FontTypeName = rhs.m_FontTypeName; + m_FontName = rhs.m_FontName; +} + diff --git a/LaipuDrawing/SequentialPoint.cpp b/LaipuDrawing/SequentialPoint.cpp new file mode 100644 index 0000000..98bc185 --- /dev/null +++ b/LaipuDrawing/SequentialPoint.cpp @@ -0,0 +1,487 @@ +#include "StdAfx.h" +#include "SequentialPoint.h" +#include "GlobalFunction.h" +#include "GlobalDrawMgr.h" +#include "DrawSimpleShape.h" +#include "WorkFileLable.h" +#include "WorkFileMgr.h" +#include "LogMgr.h" + + + +CSequentialPoint::CSequentialPoint(void) +{ +} +CSequentialPoint::~CSequentialPoint(void) +{ +} +#if 1 +void CSequentialPoint::WriteWorkFile(vector &LabVec) +{ + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + LabVec.push_back(CLab(LAB_POINT_START));//ݵ㿪ʼ + + Dbxy pt = (*iter).GetPt(); + LabVec.push_back(CLab(LAB_POINT_X,pt.x)); + LabVec.push_back(CLab(LAB_POINT_Y,pt.y)); + LabVec.push_back(CLab(LAB_POINT_IS_NODE,(*iter).IsNode()));//ǷΪڵ + + LabVec.push_back(CLab(LAB_POINT_END));//ݵ + } +} +void CSequentialPoint::ReadWorkFile(CLabVecRang &LabVecRang) +{ + //ݵ--------------------------------------------------- + vector LabVecRangVec; + CWorkFileMgr WorkFileMgr; + WorkFileMgr.SeparateStrVec(LabVecRang,LabVecRangVec,LAB_POINT_START,LAB_POINT_END); + + //ÿ + if(!LabVecRangVec.empty()) + { + vector::iterator iter = LabVecRangVec.begin(); + vector::iterator iter_end = LabVecRangVec.end(); + for(;iter!=iter_end;iter++) + { + Dbxy pt; + bool bIsNode; + {//X + CLab Lab = WorkFileMgr.FindLab((*iter),LAB_POINT_X); + if(Lab.m_ValType != _TYPE_NULL) + { + pt.x = Lab.m_Double; + } + } + {//Y + CLab Lab = WorkFileMgr.FindLab((*iter),LAB_POINT_Y); + if(Lab.m_ValType != _TYPE_NULL) + { + pt.y = Lab.m_Double; + } + } + {//ǷΪNODE + CLab Lab = WorkFileMgr.FindLab((*iter),LAB_POINT_IS_NODE); + if(Lab.m_ValType != _TYPE_NULL) + { + bIsNode = Lab.m_Bool; + } + } + CDataPoint DataPoint(pt); + DataPoint.SetIsNode(bIsNode); + AddDataPoint(DataPoint); + } + } +} +#endif +#if 1 +void CSequentialPoint::AddDataPoint(CDataPoint DataPt) +{ + m_PtContainer.push_back(DataPt); +} +//һ +void CSequentialPoint::Load(CSequentialPoint &rhs) +{ + vector::iterator iter = rhs.m_PtContainer.begin(); + vector::iterator iter_end = rhs.m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + m_PtContainer.push_back(*iter); + } +} + +bool CSequentialPoint::Empty()//Ƿݵ +{ + return m_PtContainer.empty(); +}; +void CSequentialPoint::DelAllPt()//ɾݵ +{ + m_PtContainer.clear(); +}; +void CSequentialPoint::DelLastDataPoint()//ɾһڵ +{ + if(!Empty()) + { + m_PtContainer.pop_back(); + } +} +//һڵ +void CSequentialPoint::SetLastPoint(CDataPoint &pt) +{ + if(!Empty()) + { + CDataPoint &LastPt = m_PtContainer[m_PtContainer.size()-1]; + LastPt = pt; + } +} +//ʹʱҪ֤m_Container ǿ +Dbxy CSequentialPoint::GetFirstPt() +{ + return m_PtContainer[0].GetPt(); +} +//ʹʱҪ֤m_Container ǿ +Dbxy CSequentialPoint::GetLastPt() +{ + return m_PtContainer[m_PtContainer.size()-1].GetPt(); +} +//ȡnode +int CSequentialPoint::GetNodePtIdx(Dbxy pt) +{ + int idx = -1; + int size = m_PtContainer.size(); + for(int i=0;i::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + int i=0; + for(;iter!=iter_end;iter++) + { + if(i==idx && (*iter).IsNode()) + { + m_PtContainer.erase(iter); + break; + } + i++; + } +} +//idx Ӧnode ֵΪpt +void CSequentialPoint::SetNodePtByIdx(int idx,Dbxy pt) +{ + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + int i=0; + for(;iter!=iter_end;iter++) + { + if(i==idx && (*iter).IsNode()) + { + (*iter).SetPt(pt); + break; + } + i++; + } +} + +void CSequentialPoint::InsertNode(int idx,Dbxy pt) +{ + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + int i=0; + for(;iter!=iter_end;iter++) + { + if(i==idx) + { + CDataPoint DataPoint(pt); + DataPoint.SetIsNode(true); + m_PtContainer.insert(iter,DataPoint); + break; + } + i++; + } +} + +#endif +#if 1 +//Ƿھ +bool CSequentialPoint::IsInRect(DbRect rect,bool bNeedAllIn) +{ + //߶ + { + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + if(iter != m_PtContainer.begin()) + { + Dbxy pt1 = (*(iter-1)).GetPt(); + Dbxy pt2 = (*iter).GetPt(); + if(bNeedAllIn)//ҪȫھηΧ + { + if(!IsPointInRect(pt1,rect)||!IsPointInRect(pt2,rect)) + { + return false; + } + } + else //(ҵҲ) + { + if(IsLineInRect(pt1,pt2,rect)) + return true; + } + } + } + } + if(bNeedAllIn) + return true; + else + return false; +} +//ȡ߽ +DbRect CSequentialPoint::GetRect() +{ + DbRect rect; + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + AdjustRectByPoint(rect,(*iter).GetPt()); + } + return rect; +} +//Ƿнڵrect +bool CSequentialPoint::HasNodeInRect(DbRect rect) +{ + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + if((*iter).IsNode()&&IsPointInRect((*iter).GetPt(),rect)) + { + return true; + } + } + return false; +} + +#endif +#if 1 +void CSequentialPoint::Operate(SObjOperatePar par) +{ + if(par.OpType == _OP_REVERSE) + { + //תڵ + Reverse(); + } + else + { + OperateExt(par); + } +} +void CSequentialPoint::OperateExt(SObjOperatePar par) +{ + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + (*iter).Operate(par); + } +} +//תڵ +void CSequentialPoint::Reverse() +{ + //ȱ + vector vec; + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + vec.push_back((*iter)); + } + // + m_PtContainer.clear(); + //򵹻 + int size = vec.size(); + for(int i=size-1;i>=0;i--) + { + m_PtContainer.push_back(vec[i]); + } +} +#endif +#if 1// +//߶ +void CSequentialPoint::DrawDataPointVec(CDC* pDC,vector &vec) +{ + if(vec.size()>1)// + { + //ÿ߶ + vector::iterator iter = vec.begin(); + vector::iterator iter_end = vec.end(); + for(;iter!=iter_end;iter++) + { + CDataPoint &DataPt = (*iter); + CPoint pt = DataPt.GetDevicePt(); + if(iter == vec.begin()) + { + pDC->MoveTo(pt.x,pt.y); + } + else + { + pDC->LineTo(pt.x,pt.y); + } + } + } +} +void CSequentialPoint::Draw(CDC* pDC,CPen&Pen) +{ + CPen *pOldPen; + pOldPen = pDC->SelectObject(&Pen); + //߶ + DrawDataPointVec(pDC,m_PtContainer); + pDC->SelectObject(pOldPen); +} +//һ߶ +void CSequentialPoint::DrawLastLine(CDC* pDC,CPen &Pen) +{ + CPen *pOldPen; + pOldPen = pDC->SelectObject(&Pen); + + if(!Empty()) + { + vector &vec = m_PtContainer; + + int size = vec.size(); + if(size>=2) + { + CPoint pt1 = vec[size-2].GetDevicePt(); + pDC->MoveTo(pt1.x,pt1.y); + CPoint pt2 = vec[size-1].GetDevicePt(); + pDC->LineTo(pt2.x,pt2.y); + } + } + pDC->SelectObject(pOldPen); +} +//ƽڵ +void CSequentialPoint::DrawNode(CDC* pDC) +{ + int size = m_PtContainer.size(); + for(int i=0;iGetObjFirstNodeColor(),gDraw->GetCurPointRect(m_PtContainer[i].GetPt())); + } + else + { + DrawSolidRect(pDC,gDraw->GetObjNodeColor(),gDraw->GetCurPointRect(m_PtContainer[i].GetPt())); + } + } + } +} +#endif +#if 1 +void CSequentialPoint::GetLineInRect(DbRect &rect,vector &DataPtLineVec) +{ + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + if(iter != m_PtContainer.begin()) + { + Dbxy pt1 = (*(iter-1)).GetPt(); + Dbxy pt2 = (*iter).GetPt(); + if(IsLineInRect(pt1,pt2,rect)) + { + DataPtLineVec.push_back(DbLine((*(iter-1)),(*iter))); + } + } + } +} +//ȡ߶ +void CSequentialPoint::GetNodePtLineInRect(DbRect &rect,vector &DataPtLineVec) +{ + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + Dbxy pt1 = (*iter).GetPt(); + Dbxy pt2 = (*iter).GetPt(); + if(IsLineInRect(pt1,pt2,rect)) + { + DataPtLineVec.push_back(DbLine((*iter),(*iter))); + } + } +} + +#endif +//Ѽݵvec (һӵ) (PenNumΪʺ) +void CSequentialPoint::GetPtData(vector> &vec,int PenNum) +{ + bool bhasLastPt = false;//Ƿһ + Dbxy LastPt; + //ȡ֮ǰһ + int size = vec.size(); + if(size>0) + { + if(vec[size-1].empty()==false) + { + int size1 = vec[size-1].size(); + LastPt = vec[size-1][size1-1]; + bhasLastPt = true; + } + } + + vector VecTmp; + bool bNeedConnect = false;//ǷҪ + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + if(iter == m_PtContainer.begin() && bhasLastPt)//жǷ + { + if((*iter).GetPt() == LastPt) + { + bNeedConnect = true; + } + } + Dbxy pt = (*iter).GetPt(); + pt.PenNum = PenNum;//õڵıʺ + VecTmp.push_back(pt); + } + + if(!VecTmp.empty()) + { + #if 0//Ҫ + if(bNeedConnect) + { + vector::iterator iter = VecTmp.begin(); + vector::iterator iter_end = VecTmp.end(); + for(;iter!=iter_end;iter++) + { + vec[size-1].push_back(*iter); + } + } + else + #endif + { + vec.push_back(VecTmp); + } + } +} +//Ƿline ཻ +bool CSequentialPoint::IntersectWithLine(DbLine &line) +{ + Dbxy pt1 = line.GetPt1(); + Dbxy pt2 = line.GetPt2(); + + vector::iterator iter = m_PtContainer.begin(); + vector::iterator iter_end = m_PtContainer.end(); + for(;iter!=iter_end;iter++) + { + if(iter != m_PtContainer.begin()) + { + if(IsTwoLineIntersect(pt1,pt2,(*(iter-1)).GetPt(),(*iter).GetPt())) + { + return true; + } + } + } + return false; +} \ No newline at end of file diff --git a/LaipuDrawing/SequentialPoint.h b/LaipuDrawing/SequentialPoint.h new file mode 100644 index 0000000..59bbe81 --- /dev/null +++ b/LaipuDrawing/SequentialPoint.h @@ -0,0 +1,47 @@ +#pragma once +#include "GlobalDefine.h" +#include "DataPoint.h" +#include "LabVecRang.h" + + +//һ߶εĵ +class CSequentialPoint +{ +public: + CSequentialPoint(void); + ~CSequentialPoint(void); + void WriteWorkFile(vector &LabVec); + void ReadWorkFile(CLabVecRang &LabVecRang); + void Load(CSequentialPoint &rhs); + bool Empty(); + void AddDataPoint(CDataPoint pt); + void DelAllPt();//ɾݵ + void DelLastDataPoint();//ɾһڵ + bool IsInRect(DbRect rect,bool bNeedAllIn); + DbRect GetRect(); + void Draw(CDC* pDC,CPen&Pen); + void DrawLastLine(CDC* pDC,CPen &Pen); + void DrawNode(CDC* pDC); + void GetLineInRect(DbRect &rect,vector &DataPtLineVec); + void GetNodePtLineInRect(DbRect &rect,vector &DataPtLineVec); + void Operate(SObjOperatePar par); + vector& GetPtContainer(){return m_PtContainer;}; + void SetLastPoint(CDataPoint &pt); + Dbxy GetFirstPt(); + Dbxy GetLastPt(); + int GetNodePtIdx(Dbxy pt); + void DelNodePtByIdx(int idx); + void SetNodePtByIdx(int idx,Dbxy pt); + void InsertNode(int idx,Dbxy pt); + int GetPtCnt(){return m_PtContainer.size();}; + bool HasNodeInRect(DbRect rect); + void GetPtData(vector> &vec,int PenNum = -1); + bool IntersectWithLine(DbLine &line); +private: + void DrawDataPointVec(CDC* pDC,vector &vec); + void Reverse(); + void OperateExt(SObjOperatePar par); +private: + vector m_PtContainer;//ݵ +}; + diff --git a/LaipuDrawing/SmartPtr.h b/LaipuDrawing/SmartPtr.h new file mode 100644 index 0000000..ba957ea --- /dev/null +++ b/LaipuDrawing/SmartPtr.h @@ -0,0 +1,59 @@ +#if !defined(__MY_SMART_PTR_TEMPLATE_H__) +#define __MY_SMART_PTR_TEMPLATE_H__ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +//Լָģ +template +class RefPtr +{ +//ԱȨȫΪprivateΪֱʹø + template friend class Sptr; + RefPtr(TYPE *ptr):p(ptr), count(1) { } + ~RefPtr() { delete p; } + TYPE *GetPtr(){return p;} + int count; //ü + TYPE *p; //ָ +}; + +template +class Sptr +{ +public: + Sptr(TYPE *ptr):rp(new RefPtr(ptr)) { } //캯 + Sptr(const Sptr &sp):rp(sp.rp) { ++rp->count; } //ƹ캯 + Sptr& operator=(const Sptr& rhs) + { //ظֵ + ++rhs.rp->count; //ȽҲü1 + if(--rp->count == 0) //Ȼü1ӦԸֵ + delete rp; + rp = rhs.rp; + return *this; + } + + ~Sptr() + { + if(--rp->count == 0) //üΪ0ʱɾָ룬Ӷɾ + delete rp; + } + //زģָΪ + TYPE &operator*() { return *rp->p; } + TYPE *operator->() { return rp->p; } + const TYPE &operator*() const { return *rp->p; } + const TYPE *operator->() const { return rp->p; } + TYPE *GetPtr(){return rp->GetPtr();}//ȡָ + bool IsNull() + { + if(rp->GetPtr()) + return false; + else + return true; + } +private: + RefPtr *rp; //ָ +}; + + +#endif//__MY_SMART_PTR_TEMPLATE_H__ \ No newline at end of file diff --git a/LaipuDrawing/SocketMgr.cpp b/LaipuDrawing/SocketMgr.cpp new file mode 100644 index 0000000..c487c16 --- /dev/null +++ b/LaipuDrawing/SocketMgr.cpp @@ -0,0 +1,67 @@ +#include "StdAfx.h" +#include "SocketMgr.h" +#include "LogMgr.h" + +#include +#pragma comment(lib, "ws2_32.lib") + +CSocketMgr *gSocketMgr = new CSocketMgr; + +CSocketMgr::CSocketMgr(void) +{ +} +CSocketMgr::~CSocketMgr(void) +{ +} +//ͨѶʼ +void CSocketMgr::OnAppInitialize() +{ + //ʼ׽socket + if(!AfxSocketInit()) + { + gLogMgr->WriteDebugLog("Err---->CSocketMgr : AfxSocketInit : Err"); + } + else + { + gLogMgr->WriteDebugLog("Func---->CSocketMgr : AfxSocketInit : OK"); + } +} + +//Socket S_addr:ӵIP ַ,port:˿ں +bool CSocketMgr::Connect(const char* S_addr,u_short port) +{ + m_Socket.Create(); + + SOCKADDR_IN addrSrv; + addrSrv.sin_addr.S_un.S_addr=inet_addr(S_addr); + addrSrv.sin_family=AF_INET; + addrSrv.sin_port=htons(port); + + if(m_Socket.Connect((SOCKADDR*)&addrSrv,sizeof(SOCKADDR))) + { + gLogMgr->WriteDebugLog("Socket ӳɹ"); + return true; + } + else + { + gLogMgr->WriteDebugLog("Socket ʧ",_LOG_ERROR); + Close(); + return false; + } +} +//رsocket +void CSocketMgr::Close() +{ + gLogMgr->WriteDebugLog("Socket ر"); + m_Socket.Close(); +} +//socket ˷ +void CSocketMgr::Send(char* lpBuf,int nBufLen) +{ + m_Socket.Send(lpBuf,nBufLen,0); +} +//socket ӷ˽ +void CSocketMgr::Receive(char* lpBuf,int nBufLen) +{ + m_Socket.Receive(lpBuf,nBufLen,0); +} diff --git a/LaipuDrawing/SocketMgr.h b/LaipuDrawing/SocketMgr.h new file mode 100644 index 0000000..06b4677 --- /dev/null +++ b/LaipuDrawing/SocketMgr.h @@ -0,0 +1,23 @@ + +#pragma once + + +#include "Module.h" + + +//Socket ͨѶ +class CSocketMgr :public CModule +{ +public: + CSocketMgr(void); + ~CSocketMgr(void); + virtual void OnAppInitialize(); + virtual MODULE GetModuleType(){return _SOCKET_PROP;}; + bool Connect(const char* S_addr,u_short port); + void Close(); + void Send(char* lpBuf,int nBufLen); + void Receive(char* lpBuf,int nBufLen); +public: + CSocket m_Socket;//Socket +}; +extern CSocketMgr *gSocketMgr; \ No newline at end of file diff --git a/LaipuDrawing/StaticCounter.cpp b/LaipuDrawing/StaticCounter.cpp new file mode 100644 index 0000000..4572544 --- /dev/null +++ b/LaipuDrawing/StaticCounter.cpp @@ -0,0 +1,371 @@ +// StaticCounter.cpp : implementation file +// + +#include "stdafx.h" +#include "StaticCounter.h" +#include "GlobalDefine.h" +#include "GlobalDrawMgr.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +///////////////////////////////////////////////////////////////////////////// +// CStaticCounter + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +CStaticCounter::CStaticCounter() +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + m_crBackground = RGB(0,0,0); + m_crForeground = RGB(100, 255, 100); + + m_bLDown = m_bRDown = false; + + m_uID=0; + m_nBlankPadding = 0; + + m_nBarHeight = BARHEIGHTMIN + 4; + m_nLastAmount = 0; + + m_bAllowInteraction = true; + m_bFloat=false; + m_strDisplay = "0"; + m_strFormat="%.3f"; + m_bSpecifiedFadeColour = false; + m_bDrawFadedNotches = true; + m_bGotMetrics = false; + m_bDraw3DBar = true; + m_fPos = 0; + SetRange(0,100); + + SetBlankPadding(0);//ǰ漸ո + SetBarHeight(); + + //m_LcdNum.SetColours(, 0, RGB(150, 0, 0)); + //m_LcdNum.SetColourFaded(RGB(40, 40, 40));//δɫ + + #if 1 + m_crForeground = RGB_GREEN; + m_crBackground = RGB_BLACK; + m_3DBar.SetBarColour(RGB(150, 0, 0)); + m_crDimForeground = RGB_BLACK; + #endif + #if 0//Ĭɫ + m_crForeground = RGB(255, 255,255); + m_crBackground = 0; + m_3DBar.SetBarColour(RGB(150, 0, 0)); + m_crDimForeground = RGB(40, 40, 40); + #endif + #if 0 + m_crForeground = RGB(252, 189,9); + m_crBackground = RGB(69, 69,69); + m_3DBar.SetBarColour(RGB(150, 0, 0)); + m_crDimForeground = RGB(69, 69,69); + #endif + m_bSpecifiedFadeColour = true; + +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +CStaticCounter::~CStaticCounter() +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ +} + +BEGIN_MESSAGE_MAP(CStaticCounter, CStatic) + //{{AFX_MSG_MAP(CStaticCounter) + ON_WM_PAINT() + ON_WM_LBUTTONDOWN() + ON_WM_LBUTTONUP() + ON_WM_MOUSEMOVE() + ON_WM_KEYDOWN() + ON_WM_RBUTTONDOWN() + ON_WM_RBUTTONUP() + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CStaticCounter message handlers + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void CStaticCounter::CalculateMetrics() +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + // Calculate the character metrics in proportion to the size of the control: + int nHeight = m_recClient.bottom; + + if (m_bDraw3DBar) nHeight -= (m_nBarHeight-2); + + (nHeight * 0.06) < 1 ? m_nMargin = 1 : m_nMargin = (int)(nHeight * 0.06); + (nHeight * 0.35) < 1 ? m_nNotchLength = 1 : m_nNotchLength = (int)(nHeight * 0.35); + m_nNotchWidth = gDraw->GetLCD_Txt_LineW(); + m_bGotMetrics = true; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void CStaticCounter::OnPaint() +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + GetClientRect(&m_recClient); + CPaintDC dc(this); + CStaticDC memDC(&dc, m_recClient); + CStaticDC* pDC = &memDC; + + pDC->FillSolidRect(&m_recClient, m_crBackground); + + if (!m_bGotMetrics) CalculateMetrics(); + + int nColPos = 0; + + CString strFormatted = m_strDisplay; + + ///////////////////////////////////////////////////////////////////////////////////////////// + // BLANK PADDING + if ( (m_nBlankPadding>0) && (m_strDisplay.GetLength() 0 ) + { + if (strFormatted[nCount] == ':') + nColPos+= m_nNotchLength+m_nMargin; + else if (strFormatted[nCount-1] == ':' ) + nColPos+= m_nNotchLength+1; + else + nColPos += m_nNotchLength + (m_nMargin*4); + } + + // First 'lay down' the faded notches: + if (m_bDrawFadedNotches && strFormatted[nCount] != ':' ) + Draw( pDC, STCOUNTERALL, nColPos ); + + if ( strFormatted[nCount] == '0' ) Draw( pDC, STCOUNTER0, nColPos ); + else if ( strFormatted[nCount] == '1' ) Draw( pDC, STCOUNTER1, nColPos ); + else if ( strFormatted[nCount] == '2' ) Draw( pDC, STCOUNTER2, nColPos ); + else if ( strFormatted[nCount] == '3' ) Draw( pDC, STCOUNTER3, nColPos ); + else if ( strFormatted[nCount] == '4' ) Draw( pDC, STCOUNTER4, nColPos ); + else if ( strFormatted[nCount] == '5' ) Draw( pDC, STCOUNTER5, nColPos ); + else if ( strFormatted[nCount] == '6' ) Draw( pDC, STCOUNTER6, nColPos ); + else if ( strFormatted[nCount] == '7' ) Draw( pDC, STCOUNTER7, nColPos ); + else if ( strFormatted[nCount] == '8' ) Draw( pDC, STCOUNTER8, nColPos ); + else if ( strFormatted[nCount] == '9' ) Draw( pDC, STCOUNTER9, nColPos ); + else if ( strFormatted[nCount] == '-' ) Draw( pDC, STCOUNTER10, nColPos ); + else if ( strFormatted[nCount] == '.' ) Draw( pDC, STCOUNTER11, nColPos ); + else if ( strFormatted[nCount] == ':' ) Draw( pDC, STCOUNTER12, nColPos ); + } + + if (m_bDraw3DBar) + { + // the reason I multiply by a hundred is to improve the visuals of ranges between 0 and 1 + float fRange = (float)abs( (int)( (m_fMax*100) - (m_fMin*100) ) ); + float fWidth = ((float)m_recClient.right/fRange) * // Split the width up into fRange number of 'portions' ... + ( (m_fPos*100)-(m_fMin*100) ); // .. and multiply by current value + + CRect BarBgRect( CPoint(m_recClient.left, m_recClient.bottom-m_nBarHeight), CSize((int)m_recClient.right, m_nBarHeight) ); + CBrush brBG(::GetSysColor(COLOR_BTNFACE)); + pDC->FillRect(BarBgRect, &brBG); + pDC->Draw3dRect( &BarBgRect, ::GetSysColor(COLOR_BTNSHADOW), ::GetSysColor(COLOR_BTNHILIGHT) ); + + CRect BarRect( CPoint(m_recClient.left, m_recClient.bottom-m_nBarHeight), CSize((int)fWidth, m_nBarHeight) ); + m_3DBar.DrawHorizontal( pDC, BarRect ); + } +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void CStaticCounter::Draw(CStaticDC* pDC, DWORD dwChar, int nCol) +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + COLORREF crNotchColor = m_crForeground; + + if (dwChar == STCOUNTERALL && !m_bSpecifiedFadeColour) // The colour used will be a dim version of normal foreground + { + int r = GetRValue(m_crForeground)/3; + int g = GetGValue(m_crForeground)/3; + int b = GetBValue(m_crForeground)/3; + crNotchColor = RGB(r,g,b); + } + else if (dwChar == STCOUNTERALL && m_bSpecifiedFadeColour) + crNotchColor = m_crDimForeground; + + // Create the Pen accordingly + CPen pen(PS_SOLID | PS_ENDCAP_ROUND, m_nNotchWidth, crNotchColor); + CPen* pOldPen=pDC->SelectObject(&pen); + + + if ( (dwChar & NOTCH1) || dwChar == STCOUNTERALL) { // should I draw the first bar in the display? + pDC->MoveTo( nCol + m_nMargin*2, m_nMargin ); + pDC->LineTo( nCol + m_nNotchLength, m_nMargin ); + } + + if ( dwChar & NOTCH2 || dwChar == STCOUNTERALL) { // should I draw the 2nd bar in the display? [minus sign] + pDC->MoveTo(nCol + m_nNotchLength + m_nMargin, m_nMargin*2); + pDC->LineTo(nCol + m_nNotchLength + m_nMargin, m_nNotchLength + (m_nMargin*2) ); + } + + if ( dwChar & NOTCH3 || dwChar == STCOUNTERALL) { // should I draw the 3rd bar in the display? + pDC->MoveTo(nCol + m_nNotchLength + m_nMargin, m_nNotchLength + (m_nMargin*4) ); + pDC->LineTo(nCol + m_nNotchLength + m_nMargin, m_nNotchLength*2 + (m_nMargin*3) ); + } + + if ( dwChar & NOTCH4 || dwChar == STCOUNTERALL) { // should I draw the 4th bar in the display? + pDC->MoveTo( nCol + m_nMargin*2, m_nNotchLength*2 + (m_nMargin*4) ); + pDC->LineTo( nCol + m_nNotchLength, m_nNotchLength*2 + (m_nMargin*4) ); + } + + if ( dwChar & NOTCH5 || dwChar == STCOUNTERALL) { // should I draw the 5th bar in the display? + pDC->MoveTo(nCol + m_nMargin, m_nNotchLength + (m_nMargin*4) ); + pDC->LineTo(nCol + m_nMargin, m_nNotchLength*2 + (m_nMargin*3) ); + } + + if ( dwChar & NOTCH6 || dwChar == STCOUNTERALL) { // should I draw the 6th bar in the display? + pDC->MoveTo(nCol + m_nMargin, m_nMargin*2); + pDC->LineTo(nCol + m_nMargin, m_nNotchLength + (m_nMargin*2) ); + } + + if ( dwChar & NOTCH7 || dwChar == STCOUNTERALL) { // should I draw the 7th bar in the display? + pDC->MoveTo(nCol + m_nMargin*2, m_nNotchLength + (m_nMargin*3) ); + pDC->LineTo(nCol + m_nMargin + m_nNotchLength - m_nMargin, m_nNotchLength + (m_nMargin*3) ); + } + + if ( dwChar == STCOUNTER11 ) { // should I draw the point? + pDC->MoveTo( nCol + m_nMargin*2, m_nNotchLength*2 + (m_nMargin*4) ); + pDC->LineTo( nCol + (m_nNotchLength/2), m_nNotchLength*2 + (m_nMargin*4) ); + } + + if ( dwChar == STCOUNTER12 ) { // should I draw the colon? + // Upper dot: + pDC->MoveTo( nCol + m_nMargin*2+(m_nMargin*2), m_nNotchLength ); + pDC->LineTo( nCol + (m_nNotchLength/2)+(m_nMargin*2), m_nNotchLength ); + + // Lower dot: + pDC->MoveTo( nCol + m_nMargin*2+(m_nMargin*2), m_nNotchLength*2 + (m_nMargin) ); + pDC->LineTo( nCol + (m_nNotchLength/2)+(m_nMargin*2), m_nNotchLength*2 + (m_nMargin) ); + } + + pDC->SelectObject(pOldPen); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +CRect CStaticCounter::GetRect(UINT uID, CDialog *pDlg) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// I wrote this static function here to save me re-writing it for every dialog app that uses this class (about time!) +{ + CWnd* pWnd = pDlg->GetDlgItem(uID); + ASSERT(pWnd); + + CRect rect; + pWnd->GetWindowRect( &rect ); + pDlg->ScreenToClient( &rect ); + + return rect; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void CStaticCounter::OnRButtonDown(UINT nFlags, CPoint point) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + SetCapture(); + m_bRDown = true; + m_nMovement = point.x; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void CStaticCounter::OnRButtonUp(UINT nFlags, CPoint point) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + ReleaseCapture(); + + if (m_nLastAmount==0 && m_bAllowInteraction) // ALLOW UNIT CHANGES WHEN IT'S HARD TO DRAG FOR SMALL NUMBERS + { + m_fPos+=(m_bFloat?0.01f:1); // INCREMENT + + if (m_fPosm_fMax) m_fPos = m_fMax; + if (m_bFloat) + DisplayFloat(m_fPos); + else + DisplayInt((int)m_fPos); + } + + #ifdef WM_UPDATE_STATIC + //#define WM_UPDATE_STATIC (WM_USER+0x411) // user defined WM message + ::PostMessage( GetParent()->m_hWnd, WM_UPDATE_STATIC, (WPARAM)m_uID, (LPARAM)m_fPos ); + #endif + + m_nLastAmount = 0; + m_bRDown = false; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void CStaticCounter::OnLButtonDown(UINT nFlags, CPoint point) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + m_bLDown = true; + m_nMovement = point.x; + SetCapture(); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void CStaticCounter::OnLButtonUp(UINT nFlags, CPoint point) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + ReleaseCapture(); + + if (m_nLastAmount==0 && m_bAllowInteraction) // ALLOW UNIT CHANGES WHEN IT'S HARD TO DRAG FOR SMALL NUMBERS + { + m_fPos-=(m_bFloat?0.01f:1); // DECREMENT + + if (m_fPosm_fMax) m_fPos = m_fMax; + if (m_bFloat) + DisplayFloat(m_fPos); + else + DisplayInt((int)m_fPos); + } + + #ifdef WM_UPDATE_STATIC + //#define WM_UPDATE_STATIC (WM_USER+0x411) // user defined WM message + ::PostMessage( GetParent()->m_hWnd, WM_UPDATE_STATIC, (WPARAM)m_uID, (LPARAM)m_fPos ); + #endif + + m_nLastAmount = 0; + m_bLDown = false; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header +void CStaticCounter::OnMouseMove(UINT nFlags, CPoint point) +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{ + if (! m_bLDown && !m_bRDown) return; // If neither mouse buttons are down, don't come here thinking this is an off-license, ok! + if (! m_bAllowInteraction) return; // "Sorry, I'm grounded and my dad says I'm not allowed visitors" + + m_nLastAmount = point.x-m_nMovement; + m_nMovement = point.x; + + if (m_bLDown) + m_fPos+=(float)m_nLastAmount; + else + m_fPos+=(float)((float)m_nLastAmount/(float)100); + + if (m_fPosm_fMax) m_fPos = m_fMax; + + if (m_bFloat) + DisplayFloat(m_fPos); + else + DisplayInt((int)m_fPos); +} diff --git a/LaipuDrawing/StaticCounter.h b/LaipuDrawing/StaticCounter.h new file mode 100644 index 0000000..ed925f8 --- /dev/null +++ b/LaipuDrawing/StaticCounter.h @@ -0,0 +1,300 @@ +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// CStaticCounter - CStatic derived numeric counter display +// +// Author: Jason Hattingh +// Email: jhattingh@greystonefx.com +// +// You may freely use or modify this code provided this +// notice is included in all derived versions. +// +// This class implements a LED style counter without the need for bitmap resources +// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//#define WM_UPDATE_STATIC (WM_USER+0x411) // user defined WM message + +#if !defined(AFX_STATICCOUNTER_H__F666A491_3847_11D3_A58E_00805FC1DE10__INCLUDED_) +#define AFX_STATICCOUNTER_H__F666A491_3847_11D3_A58E_00805FC1DE10__INCLUDED_ + +#include "stdafx.h" +#include "3DBar.h" + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +// StaticCounter.h : header file +// + +const unsigned short BARHEIGHTMIN = 0; + +const DWORD STCOUNTER0 = 252; +const DWORD STCOUNTER1 = 96; +const DWORD STCOUNTER2 = 218; +const DWORD STCOUNTER3 = 242; +const DWORD STCOUNTER4 = 102; +const DWORD STCOUNTER5 = 182; +const DWORD STCOUNTER6 = 190; +const DWORD STCOUNTER7 = 224; +const DWORD STCOUNTER8 = 254; +const DWORD STCOUNTER9 = 246; +const DWORD STCOUNTER10 = 2; // The minus sign [2] +const DWORD STCOUNTER11 = 256; // The "point" +const DWORD STCOUNTER12 = 257; // The "colon" (:) +const DWORD STCOUNTERALL = 999; + +const DWORD NOTCH1 = 128; +const DWORD NOTCH2 = 64; +const DWORD NOTCH3 = 32; +const DWORD NOTCH4 = 16; +const DWORD NOTCH5 = 8; +const DWORD NOTCH6 = 4; +const DWORD NOTCH7 = 2; // The minus sign +const DWORD NOTCH8 = 1; // Not used... + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// CStaticDC - memory DC +// +// Author: Keith Rule, keithr@europa.com, Copyright 1996-1997, Keith Rule +// +// You may freely use or modify this code provided this copyright is included in all derived versions. +// +// History - 10/3/97 Fixed scrolling bug. +// Added print support. +// - 14/7/99 Added optional clip rect parameter [jgh] +// + + class CStaticDC : public CDC { + private: + CBitmap m_bitmap; // Offscreen bitmap + CBitmap* m_oldBitmap; // bitmap originally found in CStaticDC + CDC* m_pDC; // Saves CDC passed in constructor + CRect m_rect; // Rectangle of drawing area. + BOOL m_bMemDC; // TRUE if CDC really is a Memory DC. + public: + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header + CStaticDC(CDC* pDC, CRect rect = CRect(0,0,0,0)) : CDC(), m_oldBitmap(NULL), m_pDC(pDC) + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + { + ASSERT(m_pDC != NULL); // If you asserted here, you passed in a NULL CDC. + + m_bMemDC = !pDC->IsPrinting(); + + if (m_bMemDC){ + // Create a Memory DC + CreateCompatibleDC(pDC); + if ( rect == CRect(0,0,0,0) ) + pDC->GetClipBox(&m_rect); + else + m_rect = rect; + + m_bitmap.CreateCompatibleBitmap(pDC, m_rect.Width(), m_rect.Height()); + m_oldBitmap = SelectObject(&m_bitmap); + SetWindowOrg(m_rect.left, m_rect.top); + } else { + // Make a copy of the relevent parts of the current DC for printing + m_bPrinting = pDC->m_bPrinting; + m_hDC = pDC->m_hDC; + m_hAttribDC = pDC->m_hAttribDC; + } + } + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Function Header + ~CStaticDC() + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + { + if (m_bMemDC) { + // Copy the offscreen bitmap onto the screen. + m_pDC->BitBlt(m_rect.left, m_rect.top, m_rect.Width(), m_rect.Height(), + this, m_rect.left, m_rect.top, SRCCOPY); + //Swap back the original bitmap. + SelectObject(m_oldBitmap); + } else { + // All we need to do is replace the DC with an illegal value, + // this keeps us from accidently deleting the handles associated with + // the CDC that was passed to the constructor. + m_hDC = m_hAttribDC = NULL; + } + } + + // Allow usage as a pointer + CStaticDC* operator->() {return this;} + + // Allow usage as a pointer + operator CStaticDC*() {return this;} + }; + + +// End CStaticDC +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Begin: class CStaticCounter +// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +class CStaticCounter : public CStatic +{ +// Operations +public: + +// Overrides + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CStaticCounter) + //}}AFX_VIRTUAL + +// Implementation +public: + CStaticCounter(); + virtual ~CStaticCounter(); + + void SetFormatString(CString strFormat=_T("%.3d")) { + m_strFormat = strFormat; + if (m_strFormat.Find('f')>0) m_bFloat=true; else m_bFloat=false; + Update(); + }; + + void SetID(UINT uID) { m_uID=uID; }; + + static CRect GetRect(UINT uID, CDialog* pDlg); + + void SetBarHeight(int nHeight=BARHEIGHTMIN) { + nHeightfMax ) nPos = (int)fMax; + } + m_fPos = (float)nPos; + DisplayInt( (int)m_fPos ); + }; + void SetPos( float fPos, bool bSetRange=false, float fMin=0, float fMax=100 ){ + m_bFloat=true; + if (bSetRange) { + ASSERT(fMin <= fMax); + SetRange(fMin, fMax); + if ( fPosfMax ) fPos = fMax; + } + m_fPos = fPos; + DisplayFloat( m_fPos ); + }; + + void SetBlankPadding(int nPadding){ m_nBlankPadding = nPadding;}; + + void SetRange( float fMin=0, float fMax=100 ) { + ASSERT(fMin <= fMax); + if ( m_fPosfMax ) m_fPos = fMax; + m_fMin = fMin; + m_fMax = fMax; + }; + + void SetDrawFaded(bool bState=true){ m_bDrawFadedNotches = bState; }; + void SetDraw3DBar(bool bState=false){ m_bDraw3DBar = bState; }; + + void Display( CString strDisplay ) { m_strDisplay = strDisplay; Invalidate(FALSE); }; + + void DisplayInt(int nValue, bool bSetFmtStr=false, CString strFormat=_T("%.3d")) { + m_bFloat=false; + if (bSetFmtStr) m_strFormat = strFormat; + m_strDisplay.Format(m_strFormat, nValue); + Invalidate(FALSE); + }; + void DisplayFloat(float fValue, bool bSetFmtStr=false, CString strFormat=_T("%.4f")) { + m_bFloat=true; + + if (bSetFmtStr) m_strFormat = strFormat; + + m_strDisplay.Format(m_strFormat, fValue); + + Update(); + }; + void DisplayTime( CString strFormat = _T("%H:%M:%S") ) { + m_bDraw3DBar=false; Display( (CTime::GetCurrentTime()).Format(strFormat) ); }; + void DisplayTime(UINT uSecs, UINT uMins=0, UINT uHours=0, UINT uDays=0, CString strFormat=_T("%D:%H:%M:%S")) { + m_bDraw3DBar=false; Display( (CTimeSpan(uDays, uHours, uMins, uSecs)).Format(strFormat) ); }; + + void SetColourFaded(COLORREF crColor ){ m_bSpecifiedFadeColour = true; m_crDimForeground = crColor; Invalidate(FALSE); }; + void SetColours(COLORREF crFG, COLORREF crBG = 0, COLORREF crChannel=RGB(0,100,0)){ + m_crForeground = crFG; + m_crBackground = crBG; + m_3DBar.SetBarColour(crChannel); + Invalidate(FALSE); + }; + +protected: + + void Update() + { + if (::IsWindow(m_hWnd)) Display(m_strDisplay); + } + + void CalculateMetrics(); + void Draw( CStaticDC* pDC, DWORD dwChar, int nCol); + + int m_nLastAmount; + + unsigned short m_nBarHeight; + + bool m_bDrawFadedNotches; + bool m_bGotMetrics; + bool m_bSpecifiedFadeColour; + + CString m_strDisplay; + CString m_strFormat; + + CRect m_recClient; + + float m_fMin, m_fMax; + +protected: + int m_nBlankPadding; + UINT m_uID; + int m_nMovement; + C3DBar m_3DBar; + + int m_nNotchWidth; + int m_nNotchLength; + int m_nMargin; + + COLORREF m_crBackground; + COLORREF m_crForeground; + COLORREF m_crDimForeground; + + float m_fPos; + + bool m_bDraw3DBar; + bool m_bLDown, m_bRDown; + bool m_bAllowInteraction; + bool m_bFloat; + + // Generated message map functions + + //{{AFX_MSG(CStaticCounter) + afx_msg void OnPaint(); + afx_msg void OnLButtonDown(UINT nFlags, CPoint point); + afx_msg void OnLButtonUp(UINT nFlags, CPoint point); + afx_msg void OnMouseMove(UINT nFlags, CPoint point); + afx_msg void OnRButtonDown(UINT nFlags, CPoint point); + afx_msg void OnRButtonUp(UINT nFlags, CPoint point); + //}}AFX_MSG + + DECLARE_MESSAGE_MAP() +}; + +///////////////////////////////////////////////////////////////////////////// + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STATICCOUNTER_H__F666A491_3847_11D3_A58E_00805FC1DE10__INCLUDED_) diff --git a/LaipuDrawing/Subject.cpp b/LaipuDrawing/Subject.cpp new file mode 100644 index 0000000..9624b52 --- /dev/null +++ b/LaipuDrawing/Subject.cpp @@ -0,0 +1,48 @@ +#include "StdAfx.h" +#include "Subject.h" + + +CSubject::CSubject(void) +{ +} +CSubject::~CSubject(void) +{ +} +//ע۲ +void CSubject::Attach(CObserver *p) +{ + m_ObserverVec.push_back(p); +} +//ɾ۲ +void CSubject::Delete(CObserver *p) +{ + vector::iterator iter = m_ObserverVec.begin(); + vector::iterator iter_end = m_ObserverVec.end(); + for(;iter!=iter_end;iter++) + { + if((*iter) == p) + { + m_ObserverVec.erase(iter); + break; + } + } +} +//֪ͨй۲߸ +void CSubject::NotifyObservers() +{ + vector::iterator iter = m_ObserverVec.begin(); + vector::iterator iter_end = m_ObserverVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->Update(); + } +} +void CSubject::SetObserversVal1(double val) +{ + vector::iterator iter = m_ObserverVec.begin(); + vector::iterator iter_end = m_ObserverVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->SetVal1(val); + } +} \ No newline at end of file diff --git a/LaipuDrawing/Subject.h b/LaipuDrawing/Subject.h new file mode 100644 index 0000000..2587739 --- /dev/null +++ b/LaipuDrawing/Subject.h @@ -0,0 +1,19 @@ +#pragma once +#include "Observer.h" +#include "GlobalDefine.h" + +//۲ģʽӿ +class CSubject +{ +public: + CSubject(void); + virtual ~CSubject(void); + void Attach(CObserver*);//ע۲ + void Delete(CObserver*);//ɾ۲ + void NotifyObservers();//֪ͨй۲ + void DeleteAllObservers(){m_ObserverVec.clear();};//ɾй۲ + void SetObserversVal1(double val); +protected: + vector m_ObserverVec;//۲ߵ +}; + diff --git a/LaipuDrawing/Template.cpp b/LaipuDrawing/Template.cpp new file mode 100644 index 0000000..686db49 --- /dev/null +++ b/LaipuDrawing/Template.cpp @@ -0,0 +1,36 @@ +#include "StdAfx.h" +#include "Template.h" +#include "WorkFileLable.h" +#include "DrawSimpleShape.h" + +CTemplate::CTemplate(void) +{ +} +CTemplate::~CTemplate(void) +{ +} +void CTemplate::WriteWorkFile(vector &LabVec) +{ + m_ObjContainer.WriteWorkFile(LabVec); +} +void CTemplate::ReadWorkFile(CLabVecRang &LabVecRang) +{ + m_ObjContainer.ReadWorkFile(LabVecRang); +} +void CTemplate::Draw(CDC* pDC,CPen&Pen) +{ + if(m_bCircle) + DrawCircle(pDC,Pen,m_Rect.GetCenterPt(),m_Rect.Width()/2,30); + else + DrawRect(pDC,Pen,m_Rect,false); +} +//ռ +void CTemplate::CollectWorkData(vector> &vec) +{ + m_ObjContainer.GetObjPtData(vec,false); +} +void CTemplate::SetRect(DbRect &rect,bool bCircle) +{ + m_Rect = rect; + m_bCircle = bCircle; +} \ No newline at end of file diff --git a/LaipuDrawing/Template.h b/LaipuDrawing/Template.h new file mode 100644 index 0000000..41845c5 --- /dev/null +++ b/LaipuDrawing/Template.h @@ -0,0 +1,23 @@ +#pragma once + +#include "ObjContainer.h" +#include "LabVecRang.h" +//ÿģԼobj Խobj layer ༭ +class CTemplate +{ +public: + CTemplate(void); + ~CTemplate(void); + CObjContainer &GetObjContainer(){return m_ObjContainer;}; + void WriteWorkFile(vector &LabVec); + void ReadWorkFile(CLabVecRang &LabVecRang); + void ClearObj(){m_ObjContainer.Clear();}; + void SetRect(DbRect &rect,bool bCircle); + void Draw(CDC* pDC,CPen&Pen); + void CollectWorkData(vector> &vec); +private: + CObjContainer m_ObjContainer;//ģobj + DbRect m_Rect;//ģı߽緶Χ + bool m_bCircle; +}; + diff --git a/LaipuDrawing/TemplateMgr.cpp b/LaipuDrawing/TemplateMgr.cpp new file mode 100644 index 0000000..6856049 --- /dev/null +++ b/LaipuDrawing/TemplateMgr.cpp @@ -0,0 +1,192 @@ +#include "StdAfx.h" +#include "TemplateMgr.h" +#include "Layer.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "WorkFileLable.h" +#include "WorkFileMgr.h" +#include "LogMgr.h" +#include "GlobalDrawMgr.h" + +#define MaxTempCnt 200 //ɱ༭ģ +#define NULL_IDX -1//жްģֵ +CTemplateMgr *gTemplateMgr = new CTemplateMgr; +CTemplateMgr::CTemplateMgr(void) +{ + m_bUseObjList = false;//Ƿʹöб + m_bClearOldObj = true;//ȡļʱǷɵobj +} +CTemplateMgr::~CTemplateMgr(void) +{ +} +#if 1//дmodule ĺ +CMFCPropertyGridProperty *CTemplateMgr::CreatGridProperty() +{ + CPropertieMgr &PropertieMgr = gDevicePropertieMgr; + + CString PropertyName;// + CString Description;// + CString Path = _T("Template");//洢· + CString Name; +//-------------------------------------------------------------------------------// + PropertyName = _T("ģ趨"); + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + { + PropertyName = _T("б"); + if(gAuthorityMgr->CheckAuthority(_Authority_Operator)) + { + //Աӳ + Name = _T("m_bUseObjList");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bUseObjList); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("б"); + Description = _T("ǷʹöбʹúӰˢٶ"); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bUseObjList, Description); + pGroup->AddSubItem(p); + + PropertieMgr.Insert(p, pPropertie); + } + } + return pGroup; +} +void CTemplateMgr::OnAppInitialize() +{ + // + m_TempVec.clear(); + //ʼģ + for(int i=0;i &LabVec) +{ + for(int i=0;i LabVecRangVec; + CWorkFileMgr WorkFileMgr; + WorkFileMgr.SeparateStrVec(LabVecRang,LabVecRangVec,LAB_TEMPLATE_START,LAB_TEMPLATE_END); + + //ÿģ + if(!LabVecRangVec.empty()) + { + size_t size = LabVecRangVec.size(); + for(size_t i=0;i=0&&idxGetTempRectPen()); +} + +//ָģķΧ(bCircle ʾǷΪԲ) +void CTemplateMgr::SetTempRect(int idx,DbRect &rect,bool bCircle) +{ + if(idx>=0&&idx> &vec) +{ + if(idx>=0&&idx &LabVec); + virtual void ReadWorkFile(CLabVecRang &LabVecRang); + virtual void Draw(CDC* pDC); + + + void BindCurTemp(); + bool IsUseObjList(){return m_bUseObjList;}; + bool IsbClearOldObj(){return m_bClearOldObj;}; + void SetbClearOldObj(bool b){m_bClearOldObj = b;}; + void EditTemp(int idx); + void SetTempRect(int idx,DbRect &rect,bool bCircle); + void ClearTempNull(); + void BindNullTemp(); + void CollectWorkData(int idx,vector> &vec); + CObjContainer &GetTemplateZeroObjContainer(); +private: + vector m_TempVec;//ɱ༭ģ + CTemplate m_TempNull;//һյģ + int m_CurTempIdx;//ǰ༭ģֵ(-1ʾûҪ༭ģ) + bool m_bUseObjList;//Ƿʹöб + bool m_bClearOldObj;//ȡļʱǷɵobj +}; + +extern CTemplateMgr *gTemplateMgr; \ No newline at end of file diff --git a/LaipuDrawing/TimingProgressMgr.cpp b/LaipuDrawing/TimingProgressMgr.cpp new file mode 100644 index 0000000..347f724 --- /dev/null +++ b/LaipuDrawing/TimingProgressMgr.cpp @@ -0,0 +1,86 @@ +#include "StdAfx.h" +#include "TimingProgressMgr.h" +#include "DlgTimingProgress.h" +#include "AllThreadMgr.h" +#include "GlobalFunction.h" + +UINT TimingProgressThread(LPVOID pParam) +{ + CTimingProgressMgr *p = (CTimingProgressMgr *)pParam; + p->StartTimingProgressExt(); + return 0; +} +CTimingProgressMgr gTimingProgressMgr; +CTimingProgressMgr::CTimingProgressMgr(void) +{ + m_StopExecute = true; + m_bExecuting = false;//Ƿִ + m_bCloseApp = false;//Ƿִйر + m_CurExecuteTime = 0;//ǰִʱms +} +CTimingProgressMgr::~CTimingProgressMgr(void) +{ +} + +//ýʾ +void CTimingProgressMgr::SetShowInfo(CString str) +{ + m_ShowInfo = str; +} +//ýʱ +void CTimingProgressMgr::SetTimingProgressTime(double ExecuteTime) +{ + //ִеʱҪ޸ʱ + if(m_bExecuting) + return; + m_ExecuteTime = ExecuteTime;//ִʱms +} +//ֹͣ +void CTimingProgressMgr::StopExecute() +{ + m_StopExecute = true; + m_ShowInfo = ""; + m_CurExecuteTime = 0;//ǰִʱms +} +// +void CTimingProgressMgr::StartTimingProgress() +{ + //ִеʱҪظ + if(m_bExecuting) + return; + m_StopExecute = false; + m_CurExecuteTime = 0;//ǰִʱms + + //µ߳Ի + //ԤȽ治ҪԻ + { + CWinThread* pThread = AfxBeginThread(TimingProgressThread,this); + if(m_bCloseApp) + { + WaitForThreadExit(pThread);//ȴ߳̽ + } + } +} +//ʱǷ񳬹CheckTime +bool CTimingProgressMgr::CheckCurExecuteTime(double CheckTime) +{ + if(CheckTime>0) + return (m_CurExecuteTime>CheckTime); + //CheckTime <0 ʱǷﵽ趨ʱ + return (m_CurExecuteTime>m_ExecuteTime); +} +//ȡʹõıֵ(0~99) +double CTimingProgressMgr::GetProgressVal() +{ + double val = 100; + if(m_CurExecuteTime>0) + { + val = (m_CurExecuteTime/m_ExecuteTime)*100; + } + return val; +} +void CTimingProgressMgr::StartTimingProgressExt() +{ + CDlgTimingProgress dlg; + dlg.DoModal(); +} \ No newline at end of file diff --git a/LaipuDrawing/TimingProgressMgr.h b/LaipuDrawing/TimingProgressMgr.h new file mode 100644 index 0000000..c185cc0 --- /dev/null +++ b/LaipuDrawing/TimingProgressMgr.h @@ -0,0 +1,38 @@ +#pragma once +#include "ObjContainer.h" + +class CTimingProgressMgr +{ +public: + CTimingProgressMgr(void); + ~CTimingProgressMgr(void); + void SetShowInfo(CString str); + void SetTimingProgressTime(double ExecuteTime); + void StartTimingProgress(); + void StartTimingProgressExt(); + void StopExecute();//ִֹͣ + int GetExecuteTime(){return m_ExecuteTime;}; + bool IsbStopExecute(){return m_StopExecute;}; + CString GetShowInfo(){return m_ShowInfo;}; + void SetbExecuting(bool b){m_bExecuting = b;}; + bool IsbExecuting(){return m_bExecuting;}; + void SetbCloseApp(){m_bCloseApp = true;}; + bool IsbCloseApp(){return m_bCloseApp;}; + void SetbStopBtn(bool b){m_bStopBtn = b;}; + bool IsbStopBtn(){return m_bStopBtn;}; + void AddCurExecuteTime(double AddTime){m_CurExecuteTime = m_CurExecuteTime+AddTime;}; + bool CheckCurExecuteTime(double CheckTime); + double GetProgressVal(); +private: + +private: + CString m_ShowInfo;//ʾϢ + double m_ExecuteTime;//ִʱms (ʱ) + double m_CurExecuteTime;//ǰִʱms + bool m_StopExecute;//ִֹͣ + bool m_bExecuting;//Ƿִ + bool m_bStopBtn;//Ƿstop ť + bool m_bCloseApp;//Ƿִйر + +}; +extern CTimingProgressMgr gTimingProgressMgr; \ No newline at end of file diff --git a/LaipuDrawing/ValStrBase.cpp b/LaipuDrawing/ValStrBase.cpp new file mode 100644 index 0000000..06b393b --- /dev/null +++ b/LaipuDrawing/ValStrBase.cpp @@ -0,0 +1,47 @@ +#include "StdAfx.h" +#include "ValStrBase.h" + + +CValStrBase::CValStrBase(void) +{ + m_str = "TEXT"; + m_ValStrType = _STR_ERROR; +} +CValStrBase::~CValStrBase(void) +{ +} +CString CValStrBase::GetValStr() +{ + CString str = GetStr(); + return str; +} +//ֻһλ߲0 +void CValStrBase::AddLeftZreo(CString &str) +{ + if(str.GetLength()==1) + { + str = "0"+str; + } +} +CString CValStrBase::GetValTypeStr() +{ + CString str; + switch(m_ValStrType) + { + case _STR_FIXED: + str = "̶ı"; + break; + case _STR_SN: + str = "к"; + break; + case _STR_DATE: + str = ""; + break; + case _STR_TIME: + str = "ʱ"; + break; + default: + break; + } + return str; +} \ No newline at end of file diff --git a/LaipuDrawing/ValStrBase.h b/LaipuDrawing/ValStrBase.h new file mode 100644 index 0000000..db08933 --- /dev/null +++ b/LaipuDrawing/ValStrBase.h @@ -0,0 +1,26 @@ +#pragma once +#include "GlobalDefine.h" +#include "EnumValStrType.h" + +class CValStrBase +{ +public: + CValStrBase(void); + virtual ~CValStrBase(void); + virtual CValStrBase * Clone(){return NULL;}; + virtual CString GetTypeStr(){return "";}; + virtual void SetValStr(CString str){m_str = str;}; + virtual void UpdateValStr(){}; +public: + CString GetValStr(); + CString GetValTypeStr(); + void SetValStrType(VAL_STR_TYPR t){m_ValStrType = t;}; + VAL_STR_TYPR GetValStrType(){return m_ValStrType;}; +protected: + virtual CString GetStr(){return m_str;}; + void AddLeftZreo(CString &str); +protected: + CString m_str;//ı + VAL_STR_TYPR m_ValStrType;//ɱı +}; + diff --git a/LaipuDrawing/ValStrDate.cpp b/LaipuDrawing/ValStrDate.cpp new file mode 100644 index 0000000..d629cea --- /dev/null +++ b/LaipuDrawing/ValStrDate.cpp @@ -0,0 +1,81 @@ +#include "StdAfx.h" +#include "ValStrDate.h" + + +CValStrDate::CValStrDate(void) +{ + m_DateType = _DATE_YEAR_FOUR; + m_ValStrType = _STR_DATE; +} +CValStrDate::~CValStrDate(void) +{ +} +CString CValStrDate::GetTypeStr() +{ + return "Date"; +} +CString CValStrDate::GetStr() +{ + //ȡǰϵͳʱ + CTime tm; tm=CTime::GetCurrentTime(); + + CString str; + switch(m_DateType) + { + case _DATE_YEAR_FOUR: + str = tm.Format("20%y"); + break; + case _DATE_YEAR_TWO: + str = tm.Format("%y"); + break; + case _DATE_MONTH: + str = tm.Format("%m"); + break; + case _DATE_DAY: + str = tm.Format("%d"); + break; + case _DATE_DAY_IN_YEAR: + + break; + case _DATE_WEEK: + str = tm.Format("%w"); + break; + case _DATE_WEEK_IN_YEAR: + + break; + default: + break; + } + //߲0 + AddLeftZreo(str); + return str; +} +CString CValStrDate::GetDateTypeStr() +{ + CString str; + switch(m_DateType) + { + case _DATE_YEAR_FOUR: + case _DATE_YEAR_TWO: + str = ""; + break; + case _DATE_MONTH: + str = ""; + break; + case _DATE_DAY: + str = ""; + break; + case _DATE_DAY_IN_YEAR: + str = ""; + break; + case _DATE_WEEK: + str = ""; + break; + case _DATE_WEEK_IN_YEAR: + str = ""; + break; + default: + break; + } + return str; +} \ No newline at end of file diff --git a/LaipuDrawing/ValStrDate.h b/LaipuDrawing/ValStrDate.h new file mode 100644 index 0000000..a549fab --- /dev/null +++ b/LaipuDrawing/ValStrDate.h @@ -0,0 +1,20 @@ +#pragma once +#include "valstrbase.h" +#include "GlobalDefine.h" +#include "EnumValStrType.h" + +class CValStrDate :public CValStrBase +{ +public: + CValStrDate(void); + ~CValStrDate(void); + virtual CValStrDate * Clone(){return new CValStrDate(*this);}; + virtual CString GetTypeStr(); + virtual CString GetStr(); + CString GetDateTypeStr(); + void SetDateType(VAL_DATE_TYPR t){m_DateType = t;}; + VAL_DATE_TYPR GetDateType(){return m_DateType;}; +private: + VAL_DATE_TYPR m_DateType;// +}; + diff --git a/LaipuDrawing/ValStrFixed.cpp b/LaipuDrawing/ValStrFixed.cpp new file mode 100644 index 0000000..6032611 --- /dev/null +++ b/LaipuDrawing/ValStrFixed.cpp @@ -0,0 +1,15 @@ +#include "StdAfx.h" +#include "ValStrFixed.h" + + +CValStrFixed::CValStrFixed(void) +{ + m_ValStrType = _STR_FIXED; +} +CValStrFixed::~CValStrFixed(void) +{ +} +CString CValStrFixed::GetTypeStr() +{ + return "Text"; +} \ No newline at end of file diff --git a/LaipuDrawing/ValStrFixed.h b/LaipuDrawing/ValStrFixed.h new file mode 100644 index 0000000..361181f --- /dev/null +++ b/LaipuDrawing/ValStrFixed.h @@ -0,0 +1,12 @@ +#pragma once +#include "valstrbase.h" +//̶ı +class CValStrFixed :public CValStrBase +{ +public: + CValStrFixed(void); + ~CValStrFixed(void); + virtual CValStrFixed * Clone(){return new CValStrFixed(*this);}; + virtual CString GetTypeStr(); +}; + diff --git a/LaipuDrawing/ValStrSN.cpp b/LaipuDrawing/ValStrSN.cpp new file mode 100644 index 0000000..64bc38f --- /dev/null +++ b/LaipuDrawing/ValStrSN.cpp @@ -0,0 +1,43 @@ +#include "StdAfx.h" +#include "ValStrSN.h" +#include "GlobalFunction.h" + +CValStrSN::CValStrSN(void) +{ + m_ValStrType = _STR_SN; + + m_SnMin = 0;//С + m_SnMax = 9999;// + m_SnCur = 1;//ǰ + m_SnInc = 1;// + m_EachMarkTimes = 1;//ÿ̴ + m_CurMarkTimes = 0;//ǰ̴ +} +CValStrSN::~CValStrSN(void) +{ +} +CString CValStrSN::GetTypeStr() +{ + return "SN"; +} +//㵱ǰк +void CValStrSN::UpdateValStr() +{ + //ǰֵ + m_SnCur += m_SnInc; +} +CString CValStrSN::GetStr() +{ + CString str; + //ȷǰҪ0 + int Cnt1 = GetNumDigit(m_SnMax); + int Cnt2 = GetNumDigit(m_SnCur); + for(int i=0;i<(Cnt1-Cnt2);i++) + { + str += "0"; + } + CString SnCurStr; + SnCurStr.Format("%ld",m_SnCur); + str += SnCurStr; + return str; +} \ No newline at end of file diff --git a/LaipuDrawing/ValStrSN.h b/LaipuDrawing/ValStrSN.h new file mode 100644 index 0000000..626ed0d --- /dev/null +++ b/LaipuDrawing/ValStrSN.h @@ -0,0 +1,27 @@ +#pragma once +#include "valstrbase.h" +#include "GlobalDefine.h" + + +class CValStrSN :public CValStrBase +{ + friend class CDlgValStrSN; +public: + CValStrSN(void); + ~CValStrSN(void); + virtual CValStrSN * Clone(){return new CValStrSN(*this);}; + virtual CString GetTypeStr(); + virtual CString GetStr(); + virtual void UpdateValStr(); + CString GetDateTypeStr(); +private: + +private: + int m_SnMin;//ʼ + int m_SnMax;// + int m_SnCur;//ǰ + int m_SnInc;// + int m_EachMarkTimes;//ÿ̴ + int m_CurMarkTimes;//ǰ̴ +}; + diff --git a/LaipuDrawing/ValStrTime.h b/LaipuDrawing/ValStrTime.h new file mode 100644 index 0000000..cf64e33 --- /dev/null +++ b/LaipuDrawing/ValStrTime.h @@ -0,0 +1,21 @@ +#pragma once +#include "valstrbase.h" +#include "GlobalDefine.h" +#include "EnumValStrType.h" + + +class CValStrTime :public CValStrBase +{ +public: + CValStrTime(void); + ~CValStrTime(void); + virtual CValStrTime * Clone(){return new CValStrTime(*this);}; + virtual CString GetTypeStr(); + virtual CString GetStr(); + CString GetTimeTypeStr(); + void SetTimeType(VAL_TIME_TYPR t){m_TimeType = t;}; + VAL_TIME_TYPR GetTimeType(){return m_TimeType;}; +private: + VAL_TIME_TYPR m_TimeType;// +}; + diff --git a/LaipuDrawing/ValString.cpp b/LaipuDrawing/ValString.cpp new file mode 100644 index 0000000..65cf00f --- /dev/null +++ b/LaipuDrawing/ValString.cpp @@ -0,0 +1,144 @@ +#include "StdAfx.h" +#include "ValString.h" + + +CValString::CValString(void) +{ + m_bValStr = false;//Ƿɱ +} +CValString::~CValString(void) +{ + m_ValStrVec.clear(); +} +// +void CValString::Copy(CValString &rhs) +{ + m_ValStrVec.clear(); + + m_bValStr = rhs.m_bValStr;//Ƿɱ + m_String = rhs.m_String; + //ɱıб + vector>::iterator iter = rhs.m_ValStrVec.begin(); + vector>::iterator iter_end = rhs.m_ValStrVec.end(); + for(;iter!=iter_end;iter++) + { + CValStrBase *p = (*iter)->Clone(); + AddValStr(p); + } +} +void CValString::AddValStr(CValStrBase *p) +{ + //浽ָ + Sptr sPtr(p); + m_ValStrVec.push_back(sPtr); +} + +void CValString::InsertList(CListCtrl &List) +{ + int size = m_ValStrVec.size(); + for(int i=0;iGetTypeStr());//һ + List.SetItemText(i,1,m_ValStrVec[i]->GetValStr());//ڶ + } +} +//idx ǷЧ +bool CValString::IdxValid(int idx) +{ + int size = m_ValStrVec.size(); + if(idx<0 || idx>= size) + return false; + return true; +} +void CValString::DelSelValStr(int &idx) +{ + if(!IdxValid(idx)) + return; + vector>::iterator iter = m_ValStrVec.begin(); + vector>::iterator iter_end = m_ValStrVec.end(); + int i=0; + for(;iter!=iter_end;iter++) + { + if(i==idx) + { + m_ValStrVec.erase(iter); + idx = -1; + break; + } + i++; + } +} +//ȡidx Ӧɱı +VAL_STR_TYPR CValString::GetSelValStrType(int idx) +{ + if(!IdxValid(idx)) + return _STR_ERROR; + vector>::iterator iter = m_ValStrVec.begin(); + vector>::iterator iter_end = m_ValStrVec.end(); + int i=0; + for(;iter!=iter_end;iter++) + { + if(i==idx) + { + return m_ValStrVec[i]->GetValStrType(); + break; + } + i++; + } + return _STR_ERROR; +} +// +void CValString::SwapValStr(int idx1,int idx2) +{ + if(!IdxValid(idx1) || !IdxValid(idx2)) + return; + Sptr p = m_ValStrVec[idx1]; + m_ValStrVec[idx1] = m_ValStrVec[idx2]; + m_ValStrVec[idx2] = p; +} +//ȡidx ӦĿɱַָ +CValStrBase *CValString::GetValStrPtr(int idx) +{ + if(!IdxValid(idx)) + return NULL; + return m_ValStrVec[idx].GetPtr(); +} +//ȡɱıǰַ +CString CValString::GetString() +{ + if(m_bValStr)//ɱı + { + m_String = ""; + vector>::iterator iter = m_ValStrVec.begin(); + vector>::iterator iter_end = m_ValStrVec.end(); + for(;iter!=iter_end;iter++) + { + m_String += (*iter)->GetValStr(); + } + } + if(m_String == "")//ַֹ + { + //m_String = "TEXT"; + m_String = "Text"; + } + return m_String; +} +void CValString::SetString(CString str) +{ + //ǿɱı + if(!m_bValStr) + { + m_String = str; + } +} +//¿ɱı +void CValString::UpdateValStr() +{ + vector>::iterator iter = m_ValStrVec.begin(); + vector>::iterator iter_end = m_ValStrVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter)->UpdateValStr(); + } +} \ No newline at end of file diff --git a/LaipuDrawing/ValString.h b/LaipuDrawing/ValString.h new file mode 100644 index 0000000..8fd8cd7 --- /dev/null +++ b/LaipuDrawing/ValString.h @@ -0,0 +1,32 @@ +#pragma once +#include "valstrbase.h" +#include "GlobalDefine.h" +#include "SmartPtr.h" +#include "EnumValStrType.h" + +//ɱı +class CValString +{ +public: + CValString(void); + ~CValString(void); + void Copy(CValString &rhs); + void SetString(CString str); + CString GetString(); + void AddValStr(CValStrBase *p); + void InsertList(CListCtrl &List); + void DelSelValStr(int &idx); + void SwapValStr(int idx1,int idx2); + CValStrBase *GetValStrPtr(int idx); + VAL_STR_TYPR GetSelValStrType(int idx); + void SetbValStr(bool b){m_bValStr = b;}; + bool GetbValStr(){return m_bValStr;}; + void UpdateValStr(); +private: + bool IdxValid(int idx); +private: + bool m_bValStr;//Ƿɱ + CString m_String;//ַ + vector> m_ValStrVec;//ɱıб +}; + diff --git a/LaipuDrawing/ValStrtime.cpp b/LaipuDrawing/ValStrtime.cpp new file mode 100644 index 0000000..d5d4f9c --- /dev/null +++ b/LaipuDrawing/ValStrtime.cpp @@ -0,0 +1,98 @@ +#include "StdAfx.h" +#include "ValStrTime.h" + + +CValStrTime::CValStrTime(void) +{ + m_TimeType = _TIME_HOUR_24; + m_ValStrType = _STR_TIME; +} +CValStrTime::~CValStrTime(void) +{ +} +CString CValStrTime::GetTypeStr() +{ + return "Time"; +} +CString CValStrTime::GetStr() +{ + //ȡǰϵͳʱ + CTime tm; tm=CTime::GetCurrentTime(); + + int time; + CString str; + switch(m_TimeType) + { + case _TIME_HOUR_24: + time = tm.GetHour(); + str.Format("%ld",time); + break; + case _TIME_HOUR_12: + time = tm.GetHour(); + str.Format("%ld",time%12); + break; + case _TIME_MINUTE: + time = tm.GetMinute(); + str.Format("%ld",time); + break; + case _TIME_SECOND: + time = tm.GetSecond(); + str.Format("%ld",time); + break; + case _TIME_AM_OR_PM_1: + time = tm.GetHour(); + if(time>=12) + { + str = "PM"; + } + else + { + str = "AM"; + } + break; + case _TIME_AM_OR_PM_2: + time = tm.GetHour(); + if(time>=12) + { + str = "pm"; + } + else + { + str = "am"; + } + break; + default: + break; + } + //߲0 + AddLeftZreo(str); + return str; +} +CString CValStrTime::GetTimeTypeStr() +{ + CString str; + switch(m_TimeType) + { + case _TIME_HOUR_24: + str = "Сʱ- 24"; + break; + case _TIME_HOUR_12: + str = "Сʱ- 12"; + break; + case _TIME_MINUTE: + str = ""; + break; + case _TIME_SECOND: + str = ""; + break; + case _TIME_AM_OR_PM_1: + str = "ʱ(AM,PM)"; + break; + case _TIME_AM_OR_PM_2: + str = "ʱ(am,pm)"; + break; + default: + break; + } + return str; +} \ No newline at end of file diff --git a/LaipuDrawing/ValVectorMgr.cpp b/LaipuDrawing/ValVectorMgr.cpp new file mode 100644 index 0000000..1f174c8 --- /dev/null +++ b/LaipuDrawing/ValVectorMgr.cpp @@ -0,0 +1,37 @@ +#include "StdAfx.h" +#include "ValVectorMgr.h" +#include "GlobalFunction.h" + + +CValVectorMgr::CValVectorMgr(void) +{ +} +CValVectorMgr::~CValVectorMgr(void) +{ +} +//һ +void CValVectorMgr::AddDoubleVal(double *pVal) +{ + if(pVal == NULL) + return; + CDoubleVal DoubleVal; + DoubleVal.m_pVal = pVal; + DoubleVal.m_OldVal = *pVal; + m_DoubleValVec.push_back(DoubleVal); +} +//Ƿֵ仯 +bool CValVectorMgr::HasValChange() +{ + bool Ret = false; + int size = m_DoubleValVec.size(); + for(int k=0;k m_DoubleValVec; + +}; + diff --git a/LaipuDrawing/WaferRecipeDataMgr.cpp b/LaipuDrawing/WaferRecipeDataMgr.cpp new file mode 100644 index 0000000..5204618 --- /dev/null +++ b/LaipuDrawing/WaferRecipeDataMgr.cpp @@ -0,0 +1,527 @@ +#include "StdAfx.h" +#include "WaferRecipeDataMgr.h" +#include "GlobalFunction.h" +#include "LogMgr.h" +#include "WorkTime.h" +#include "FileMgr.h" +#include "WorkFileMgr.h" +#include "Layer.h" +#include "ObjFillMgr.h" +#include "Laser.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "MsgBox.h" +#include "CStringFuc.h" +#include "Layer.h" +#include "PenParMgr.h" +#include "ObjBase.h" +#include "ObjContainer.h" +#include "ExceptionMsg.h" +#include "WorkRecord.h" +#include "WorkCmdInvoker.h" +#include "WorkCmdContainer.h" +#include "WorkAreaMgr.h" +#include "PenParMgr.h" +#include "CommonFlowMgr.h" +#include "LaserPowCheckMgr.h" +#include "EncryptionMgr.h" +#include "ObjPline.h" +#include "CommomText.h" +#include "ProgramLaserTuiHuo.h" +#include "WorkAreaMgr.h" + +#define WORK_AREA_PATH _T("\\WorkMode") +#define SCAN_AREA_FILE_PATH _T("\\ScanArea") //ӹ· +#define RECIPE_FILE_PATH _T("\\RecipeFile") + + + + +CSlotRecipeDataMgr *gWaferRecipeDataMgr = new CSlotRecipeDataMgr; +CSlotRecipeDataMgr::CSlotRecipeDataMgr(void) +{ + m_bScanEnd = true;//ɨ״̬,ȷɨߵɫ + m_EndScanLineIdx = -1;//ɨʱɨߵֵ(ָжϵ) + m_TotalScanLineCnt = 0;//ɨߵ +} +CSlotRecipeDataMgr::~CSlotRecipeDataMgr(void) +{ +} +void CSlotRecipeDataMgr::OnAppInitialize() +{ + //Ĭʾѡidx + gLayer.SetbShowObjIdx(true); + + //recipe ļ· + CString RecordPath; + CFileMgr FileMgr; + FileMgr.GetFullFilePath(RecordPath,RECIPE_FILE_PATH); + if(!FileMgr.IsFileExist(RecordPath))//ڣĿ¼ + { + FileMgr.CreatDir(RecordPath); + } + CString OffsetTabPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(OFFSET_TAB_FILE_PATH); + if(!FileMgr.IsFileExist(OffsetTabPath))//ڣĿ¼ + { + FileMgr.CreatDir(OffsetTabPath); + } +} +//ɨݵİȫ +bool CSlotRecipeDataMgr::CheckScanPathSecurity() +{ + gLogMgr->WriteDebugLog("Func---->CheckScanPathSecurity"); + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + bool Ret = true; + vector> &m_ObjVec = ObjContainer.GetObjVec(); + int size = m_ObjVec.size(); + for(int k=0;k&PtContainer = m_ObjVec[k]->GetPtContainer(); + int size1 = PtContainer.size(); + for(int i=0;iIsPtInWorkArea(PtContainer[i].GetPt())) + { + Ret = false; + break; + } + } + } + if(!Ret) + { + CMsgBox MsgBox; + MsgBox.Show("ɨݲڰȫķΧ!"); + } + return Ret; +} +#if 1 +//ɨ·,SelObjVec ѡobj +void CSlotRecipeDataMgr::CreatScanPath(vector SelObjVec) +{ + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + ObjContainer.DelAllFillObj();//ɾobj + ObjContainer.SelObjByIdxVec(SelObjVec);//obj ѡ״̬ + gPenParMgr->SetParSelectState(SelObjVec);//öӦʺŵѡ״̬ + m_CurSelStateVec = SelObjVec;//¼ǰѡ״̬ + //ѡobj + gObjFillMgr.FillAllSelObj(); + //ɺȡѡ״̬ + //ObjContainer.NotSelAllObj(); + //õһѡıΪ + gPenParMgr->SetFirstSelPenAsWorkPen(); + + //¼ǰɨߵ + CScanState &ScanState = gWorkRecordMgr->GetCurScanState(); + ScanState.m_TotalScanLineCnt = ObjContainer.GetScanLineCnt(); + +} +//ͨƶarea ıɨ· +void CSlotRecipeDataMgr::CreatScanPath(int AreaIdx) +{ + vector SelObjVec; + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + int AreaCnt = ObjContainer.GetScanAreaCnt(); + for(int k=0;k=0 && idxɨٶ +double CSlotRecipeDataMgr::CalScanSpeedByOverlapRatio(double OverlapRatio,double Fre) +{ + if(Fre<=0 || (OverlapRatio<=0 || OverlapRatio>99.9)) + { + return -1; + } + //ǰߵijߴ + DbSize MainSpotSize = gLaser->GetSpotSize(_LaserDeviceType_MainLaser1); + double SpotSize; + if(gLaser->IsbScanByDirX()) + SpotSize = MainSpotSize.w; + else + SpotSize = MainSpotSize.h; + double SpotGap = SpotSize*(OverlapRatio/100); + double ScanSpeed = (SpotSize - SpotGap)*Fre; + + //ƵFre = 500 + //XSpotSize = 0.686 + //ص OverlapRatio = 10% + //X ɨٶScanSpeed = 308.7 + //ScanSpeed = (664.9 - (664.9-623.79))*500; = 311.895 + return ScanSpeed; +} +//[ܶ/Ƶ/߳ߴ]--->[˥תǶ] +/*ǶȶӦEdi +double TestAng = Edi; +double TestEdi = cos(_360ToAngle(2*(TestAng))); +TestEdi *= TestEdi; +TestEdi *= Pow;//pow +TestEdi /= (Fre*LaserSpotX*LaserSpotY); +CString log; +log.Format("Test Edi = %lf",TestEdi); +gLogMgr->WriteDebugLog(log); +*/ +//㹫ʽ: Edi = (P(cos2)^2)/(F*H*L) +double CSlotRecipeDataMgr::CalRotatoDimmerAng(double LaserSpotX,double LaserSpotY,double Edi,double Fre,double Pow) +{ + double Ang = 0; + LaserSpotX *= 0.1;//mm-->cm + LaserSpotY *= 0.1; + double Ret = (LaserSpotX*LaserSpotY); + Ret *= (Edi*Fre); + Ret /= Pow; + Ret = sqrt(Ret);// + Ret = acos(Ret);//cosķǺ(Ƿн) + Ret /=2; + Ang = Ret/2; + Ang = AngleTo360(Ret);//нתΪ360 + Ang *= -1; + return Ang; +} +//ͨٶȺƵʼص +double CSlotRecipeDataMgr::CalOverlapRatioByScanSpeed(double ScanSpeed,double Fre) +{ + if(Fre<=0 || ScanSpeed<=0) + { + return -1; + } + //ǰߵijߴ + DbSize MainSpotSize = gLaser->GetSpotSize(_LaserDeviceType_MainLaser1); + double SpotSize; + if(gLaser->IsbScanByDirX()) + SpotSize = MainSpotSize.w; + else + SpotSize = MainSpotSize.h; + + double SpotGap = SpotSize - ScanSpeed/Fre; + double OverlapRatio = (SpotGap/SpotSize)*100; + if(OverlapRatio<0 || OverlapRatio>99) + return -1; + return OverlapRatio; +} +#endif +#if 1 +//ʼѡɨ +void CSlotRecipeDataMgr::InitScanAreaComb(CComboBox &ComboBox) +{ + ComboBox.ResetContent();// + //ȡӹļ + vector Vec; + GetScanAreaName(Vec); + int size = Vec.size(); + + for(int i=0;i Vec; + GetScanAreaName(Vec); + int size = Vec.size(); + for(int i=0;i &Vec) +{ + Vec.clear(); + + CFileMgr FileMgr; + CString filepath; + //FileMgr.GetFullFilePath(filepath,SCAN_AREA_FILE_PATH);//ȡ· + filepath = gProgramLaserTuiHuo->GetScanAreaFilePath(); + FileMgr.GetChildFileOrDirName(false,filepath,Vec,".obj"); + m_ScanAreaPathVec = Vec;//¼ ļ· + int size = Vec.size(); + for(int i=0;i &ScanAreaPathVec = m_ScanAreaPathVec; + int size = ScanAreaPathVec.size(); + for(int i=0;iReadObjTemplateFile(Path); + //¼ǰʹõɨ + CFileMgr FileMgr; + FileMgr.GetFileNameFromPath(Path,true); + AreaName = FileMgr.GetFileNameFromPath(Path,true); + break; + } + } + return AreaName; +} +#endif +#if 1 +void CSlotRecipeDataMgr::IniRecipeParList(CListCtrl &list) +{ + //÷ + list.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + int idx = 0; + list.InsertColumn(idx,"Idx",LVCFMT_LEFT,50,-1); + idx++; + list.InsertColumn(idx,"",LVCFMT_LEFT,155,-1); + idx++; + list.InsertColumn(idx,"ֵ",LVCFMT_LEFT,130,-1); + idx++; + + vector &RecipeParVec = gPenParMgr->GetRecipeParVec(); + int size = RecipeParVec.size(); + for(int k=0;k &ParVec = gPenParMgr->GetParVec(); + int PenParCnt = ParVec.size(); + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + int ObjCnt = ObjContainer.GetScanAreaCnt(); + for(int k=0;(k=PenParCnt);k++) + { + CPenPar &PenPar =ParVec[k]; + if(PenPar.m_bSelected) + return k; + } + return -1; +} +#endif +#if 1 +void CSlotRecipeDataMgr::InitOffsetTableList(CListCtrl &List) +{ + //÷ + List.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + int idx = 0; + List.InsertColumn(idx,"Idx",LVCFMT_CENTER,35,-1); + idx++; + List.InsertColumn(idx,"ParName",LVCFMT_LEFT,140,-1); + idx++; + List.InsertColumn(idx,"Unit",LVCFMT_CENTER,80,-1); + idx++; + List.InsertColumn(idx,"Value",LVCFMT_LEFT,100,-1); + idx++; +} +void CSlotRecipeDataMgr::UpdateOffsetTableList(CListCtrl &List,CString FilePath) +{ + //ļжȡOffsetTable + m_CurEditOffsetTable.ReadOffsetTableFile(FilePath); + //ʾб + vector &OffsetTableParVec = m_CurEditOffsetTable.m_OffsetTableParVec; + { + List.DeleteAllItems(); + int size = OffsetTableParVec.size(); + for(int k=0;k &OffsetTableParVec = m_CurEditOffsetTable.m_OffsetTableParVec; + int size = OffsetTableParVec.size(); + for(int k=0;kWriteDebugLog(ParValStr); + } + m_CurEditOffsetTable.SaveOffsetTableFile(FilePath); + + //¼ + CString Name = FileMgr.GetFileNameFromPath(FilePath,true); + SaveOffsetTableHistory(OffsetTableParVec,"Change",Name); + + CString s = FilePath; + s += "\nSave Succes"; + MsgBox.Show(s); +} +//һµOffsetTable +void CSlotRecipeDataMgr::CreateNewOffsetTable(CString Name) +{ + CMsgBox MsgBox; + CString s; + CString Path = gProgramLaserTuiHuo->GetLaipuLaserDataDir(OFFSET_TAB_FILE_PATH); + Path += Name; + Path += "."; + Path += OFFSET_TAB_FILE_SUFFIX; + CFileMgr FileMgr; + if(FileMgr.IsFileExist(Path)) + { + s = Name + "Ѵ"; + MsgBox.Show(s); + return; + } + + COffsetTable OffsetTable; + //дļ + OffsetTable.SaveOffsetTableFile(Path); + //¼ + SaveOffsetTableHistory(OffsetTable.m_OffsetTableParVec,"Create",Name); +} +//ɾOffsetTable +void CSlotRecipeDataMgr::DelOffsetTable(CString FilePath) +{ + CMsgBox MsgBox; + CString s; + CFileMgr FileMgr; + if(!FileMgr.IsFileExist(FilePath)) + { + s = FilePath + "\nNot Exist"; + MsgBox.Show(s); + return; + } + + s = "Delete: \n" + FilePath; + + if(MsgBox.ConfirmOkCancel(s)) + { + //¼ + CString Name = FileMgr.GetFileNameFromPath(FilePath,true); + SaveOffsetTableHistory(m_CurEditOffsetTable.m_OffsetTableParVec,"Delete",Name); + + CFileMgr FileMgr; + FileMgr.DeleteFolder(FilePath); + } +} +//¼ +void CSlotRecipeDataMgr::SaveOffsetTableHistory(vector&OffsetTableParVec,CString OperateType,CString TableName) +{ + CWorkTime WorkTime; + CCsvData CsvData; + CsvData.AddData("User Name",false); + CsvData.AddData(gAuthorityMgr->GetCurUserName(),true); + CsvData.AddData("Operate Time",false); + CsvData.AddData(WorkTime.GetDateTime("/",":"),true); + CsvData.AddData("OperateType",false); + CsvData.AddData(OperateType,true); + CsvData.AddData("Offset Table Name",false); + CsvData.AddData(TableName,true); + int size = OffsetTableParVec.size(); + for(int k=0;kGetLaipuLaserDataDir(OFFSET_TAB_HISTORY_PATH)); + CFileMgr FileMgr; + FileMgr.WriteDataToExcel(DataPath,FileName,CsvData,false); +} + +//ʼѡOffset Table +void CSlotRecipeDataMgr::InitOffsetTableComb(CComboBox &ComboBox) +{ + ComboBox.ResetContent();// + //ȡӹļ + vector Vec; + GetOffsetTableName(Vec); + ComboBox.InsertString(0,RECIPE_OFFSET_TBL_NULL);//һΪ,ʾѡOffsetTable + int size = Vec.size(); + for(int i=0;i &Vec) +{ + Vec.clear(); + + CFileMgr FileMgr; + CString filepath; + filepath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(OFFSET_TAB_FILE_PATH); + FileMgr.GetChildFileOrDirName(false,filepath,Vec,".tbl"); + m_OffsetTablePathVec = Vec;//¼ ļ· + int size = Vec.size(); + for(int i=0;i &OffsetTablePathVec = m_OffsetTablePathVec; + int size = OffsetTablePathVec.size(); + for(int i=0;i SelObjVec); + void CreatScanPath(int AreaIdx); + void InitScanAreaComb(CComboBox &ComboBox); + void InitOffsetTableComb(CComboBox &ComboBox); + CString SelScanArea(int idx); + CString SelOffsetTable(int idx); + void IniRecipeParList(CListCtrl &list); + CString GetSelRecipePath(int idx); + + double CalScanSpeedByOverlapRatio(double OverlapRatio,double Fre); + double CalOverlapRatioByScanSpeed(double ScanSpeed,double Fre); + double CalRotatoDimmerAng(double LaserSpotX,double LaserSpotY,double Edi,double Fre,double Pow); + void SetbScanEnd(bool b){m_bScanEnd = b;}; + bool IsbScanEnd(){return m_bScanEnd;}; + + void GetScanAreaName(vector &Vec); + void GetOffsetTableName(vector &Vec); + bool SelScanAreaByName(CString SelScanAreaName); + bool CheckScanPathSecurity(); + void InitOffsetTableList(CListCtrl &List); + void UpdateOffsetTableList(CListCtrl &List,CString FilePath); + void SaveRcpOffsetTable(CListCtrl &List,CString FilePath); + void CreateNewOffsetTable(CString Name); + void DelOffsetTable(CString FilePath); +private: + int GetFristSelOutLineObjIdx(); + void SaveOffsetTableHistory(vector&OffsetTableParVec,CString OperateType,CString TableName); +private: + vector m_CurSelStateVec;//ǰѡ״̬ + vector m_RecipeFilePathVec; + vector m_ScanAreaPathVec;//¼ ɨļ· + vector m_OffsetTablePathVec;//¼ OffsetTableļ· + + bool m_bScanEnd;//ɨ״̬,ȷɨߵɫ + int m_EndScanLineIdx;//ɨʱɨߵֵ + int m_TotalScanLineCnt;//ɨߵ + + COffsetTable m_CurEditOffsetTable;//ǰ༭IJ +}; + + +extern CSlotRecipeDataMgr *gWaferRecipeDataMgr; \ No newline at end of file diff --git a/LaipuDrawing/WarningMgr.cpp b/LaipuDrawing/WarningMgr.cpp new file mode 100644 index 0000000..df4f588 --- /dev/null +++ b/LaipuDrawing/WarningMgr.cpp @@ -0,0 +1,767 @@ +#include "StdAfx.h" +#include "WarningMgr.h" +#include "LogMgr.h" +#include "FileMgr.h" +#include "WorkTime.h" +#include "CStringFuc.h" +#include "MsgBox.h" +#include "ModuleDeviceMgr.h" +#include "ExceptionMsg.h" + +#include "EncryptionMgr.h" +#include "ProgramLaserTuiHuo.h" +#include "CriticalSection.h" + + +#define RECORD_FILE_PATH _T("\\WarningRecord") +#define TAB_STR " " + +#define SECS_FIRST_ALARM_ID 15001 //secs ͨŵĵһalarm id + +CWarningMgr *gWarningMgr = new CWarningMgr; +CWarningMgr::CWarningMgr(void) +{ + m_bClearAllWarningState = false;//Ƿձ +} +CWarningMgr::~CWarningMgr(void) +{ +} +#if 1 +void CWarningMgr::OnAppInitialize() +{ + //¼ļ + CreatRecordPath(); + //ʼ״̬ + InitWarningStateVec(); +} +//ͬȡļ¼״̬Ϣ +void CWarningMgr::SyncWarningRecordVec(vector &RecordInfoVec) +{ + int size = RecordInfoVec.size(); + for(int k =0;kIsbRunAtNoteBook()) + //return; + + gCriticalSection_WarningMsg.Lock(); + + if(AddInfo == "") + AddInfo = "nothing"; + int size = m_WarningStateVec.size(); + for(int k =0;k RecordInfoVec; + //ȶȡļ¼ + CString RecordFileName = GetCurRecordFileName(); + CString RecordFilePath = GetRecordFilePath(RecordFileName); + ReadRecordInfoFile(RecordInfoVec,RecordFilePath); + //ǰϢӵ + RecordInfoVec.push_back(WarningState); + //д뵽ļ + WriteRecordInfoToFile(RecordInfoVec,RecordFilePath); + gLogMgr->WriteDebugLog("func---->AddWarningRecord"); +} +//ȡ¼ļ +void CWarningMgr::ReadRecordInfoFile(vector &RecordInfoVec,CString Path) +{ + CFile file; + if(file.Open(Path,CFile::modeRead)) + { + CArchive ar(&file,CArchive::load); + int WarningRecordCnt = 0; + ar>>WarningRecordCnt;//¼ + for(int k=0;k>tmp;// + WarningRecordInfo.m_WarningCode = (EWarningCode)tmp; + ar>>WarningRecordInfo.m_DateTime;//ʱ + ar>>WarningRecordInfo.m_AddInfo;//Ϣ + RecordInfoVec.push_back(WarningRecordInfo); + } + } +} +void CWarningMgr::WriteRecordInfoToFile(vector &RecordInfoVec,CString Path) +{ + if(RecordInfoVec.empty()) + return; + + int size = RecordInfoVec.size(); + CFile file(Path,CFile::modeReadWrite|CFile::modeCreate); + CArchive ar(&file,CArchive::store); + ar< &RecordInfoVec) +{ + //Ѽµм¼ļ + vector RecordFileNameVec; + GetOneMonthRecordFileName(Date,RecordFileNameVec); + int size = RecordFileNameVec.size(); + for(int k=0;k2016_11 +CString CWarningMgr::GetMonthStr(CString Date) +{ + return Date.Left(7); +} +//ȡһµrecord ļ +void CWarningMgr::GetOneMonthRecordFileName(CString Date,vector &RecordFileNameVec) +{ + //Ѽм¼ļ-------------------------------- + vector NameVec; + CFileMgr FileMgr; + CString RecordPath; + FileMgr.GetFullFilePath(RecordPath,RECORD_FILE_PATH); + FileMgr.GetChildFileOrDirName(false,RecordPath,NameVec,"rcd"); + //ֻµ----------------------------------- + CString MonthStr = GetMonthStr(Date); + int size = NameVec.size(); + for(int k=0;k &WarningStateVec,bool bOnlyWarning) +{ + List.DeleteAllItems(); + int size = WarningStateVec.size(); + int LineIdx = 0; + for(int k =0;k &RecordInfoVec,CString Path); + void WriteRecordInfoToFile(vector &RecordInfoVec,CString RecordFilePath); + CString GetMonthStr(CString Date); + void GetOneMonthRecordFileName(CString Date,vector &RecordFileNameVec); + void GetOneMonthRecord(CString Date,vector &RecordInfoVec); + void InsertRecordListExt(CListCtrl &List,vector &WarningStateVec,bool bOnlyWarning); + CString GetWarningCode(CWarningState &WarningState); + void CreatRecordPath(); + void InitWarningStateVec(); + void SendWarningMsgExt(CWarningState &WarningState); + void SyncWarningRecordVec(vector &RecordInfoVec); +private: + vector m_WarningStateVec;//ǰб״̬(жϱ״̬Ƿ仯) + vector m_RecordInfoVec;//ǰʾıϢб + bool m_bClearAllWarningState;//Ƿձ +}; + +extern CWarningMgr *gWarningMgr; \ No newline at end of file diff --git a/LaipuDrawing/WorkAreaMgr.cpp b/LaipuDrawing/WorkAreaMgr.cpp new file mode 100644 index 0000000..5ebbd7c --- /dev/null +++ b/LaipuDrawing/WorkAreaMgr.cpp @@ -0,0 +1,294 @@ +#include "StdAfx.h" +#include "WorkAreaMgr.h" +#include "GlobalFunction.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "DrawSimpleShape.h" +#include "AuthorityMgr.h" +#include "MsgBox.h" +#include "LogMgr.h" +#include "GlobalDrawMgr.h" + + +CWorkAreaMgr *gWorkAreaMgr = new CWorkAreaMgr; +CWorkAreaMgr::CWorkAreaMgr(void) +{ + m_bDrawWorkArea = true;//Ƿƹ + m_bCircle = false;//ǷΪԲ + m_bFrame = false;//Ƿֻʾ߿ + m_WorkRectColor = RGB_RED; //򷽿ɫ + m_WorkRectSize.w = 100;//򷽿ߴ(mm) + m_WorkRectSize.h = 100;//򷽿ߴ(mm) + RefrashWorkArea(); +} +CWorkAreaMgr::~CWorkAreaMgr(void) +{ +} +#if 1 +CMFCPropertyGridProperty *CWorkAreaMgr::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = _T("WorkArea");//洢· + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T("Χ"); + GroupName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Engineer)) + { + { + //Աӳ + Name = _T("m_bDrawWorkArea");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bDrawWorkArea); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ʾΧ"); + Description = _T("ǷʾΧ,ҪڹΧ֮"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bDrawWorkArea, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bCircle");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bCircle); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("Բ"); + Description = _T("ǷʾΪԲ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCircle, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + { + //Աӳ + Name = _T("m_bFrame");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bFrame); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("߿"); + Description = _T("Ƿֻʾı߿"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bFrame, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + Name = _T("m_WorkRectColor");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WorkRectColor); + pPropertie->SetType(_PROP_TYPE_COLOR); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Χɫ"); + Description = _T("Χɫ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridColorProperty* p1 = new CMFCPropertyGridColorProperty(PropertyName,m_WorkRectColor, NULL, Description); + p1->EnableOtherButton(_T("...")); + p1->EnableAutomaticButton(_T("Ĭ"),RGB_BLACK); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + Name = _T("m_WorkRectSize_w");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WorkRectSize.w); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T(""); + Description = _T("ΧĿ(λ:mm)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_WorkRectSize.w, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + Name = _T("m_WorkRectSize_h");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_WorkRectSize.h); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("߶"); + Description = _T("Χĸ߶(λ:mm)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_WorkRectSize.h, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + Name = _T("m_CenterPt_x");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_CenterPt.x); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ĵx"); + Description = _T("Χĵx(λ:mm)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_CenterPt.x, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + //-------------------------------------------------------------------------------// + { + //Աӳ + Name = _T("m_CenterPt_y");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_CenterPt.y); + pPropertie->SetType(_PROP_TYPE_DOUBLE); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("ĵy"); + Description = _T("Χĵx(λ:mm)"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName,(_variant_t)m_CenterPt.y, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + } +//-------------------------------------------------------------------------------// + return pGroup; +} +void CWorkAreaMgr::OnAppInitialize() +{ + RefrashWorkArea(); +} +void CWorkAreaMgr::OnPropertyChanged() +{ + RefrashWorkArea(); + //ȡǰָ + CLaiPuLaserView *pView = GetCurViewPtr(); + if(pView) + { + pView->RefreshView(); + } +} +void CWorkAreaMgr::Draw(CDC* pDC) +{ + if(!m_bDrawWorkArea) + return; + //һɫ󷽿 + if(gDraw->IsbDlgLayerViewShow()) + { + DrawSolidRect(pDC,RGB_BLACK,DbRect(m_CenterPt,DbSize(1000,1000))); + } + if(!m_bFrame) + { + if(m_bCircle) + { + DrawSolidCircle(pDC,m_WorkRectColor,m_CenterPt,m_WorkRectSize.w/2); + } + else + { + DrawSolidRect(pDC,m_WorkRectColor,DbRect(m_CenterPt,m_WorkRectSize)); + } + } + else + { + CPen pen; + pen.CreatePen(PS_INSIDEFRAME,1,m_WorkRectColor); + if(m_bCircle) + { + DrawCircle(pDC,pen,m_CenterPt,m_WorkRectSize.w/2,100); + } + else + { + DrawRect(pDC,pen,DbRect(m_CenterPt,m_WorkRectSize),false); + } + } + Dbxy pt; + pt.x = m_WorkRectSize.w/2 + 2; + gDraw->DrawTxt(pDC,"Noth",pt); +} +#endif +#if 1// +//ȡRect +DbRect CWorkAreaMgr::GetWorkArea() +{ + return m_DbWorkRect; +} +//ˢWorkRect +void CWorkAreaMgr::RefrashWorkArea() +{ + m_DbWorkRect.L = m_CenterPt.x - m_WorkRectSize.w/2; + m_DbWorkRect.R = m_CenterPt.x + m_WorkRectSize.w/2; + m_DbWorkRect.T = m_CenterPt.y + m_WorkRectSize.h/2; + m_DbWorkRect.B = m_CenterPt.y - m_WorkRectSize.h/2; +} +void CWorkAreaMgr::DrawWorkArea(CDC* pDC) +{ + if(!m_bDrawWorkArea) + return; + CPen Pen; + Pen.CreatePen(PS_INSIDEFRAME,1,m_WorkRectColor); + DrawRect(pDC,Pen,m_DbWorkRect,false); + Pen.DeleteObject(); +} +//ݵǷھԲΧ֮ +bool CWorkAreaMgr::IsPtInWorkArea(Dbxy pt) +{ + double Dia = m_DbWorkRect.Width(); + double R = Dia/2; + if(CalDistance(pt,Dbxy(0,0))>R) + return false; + return true; +} +#endif + diff --git a/LaipuDrawing/WorkAreaMgr.h b/LaipuDrawing/WorkAreaMgr.h new file mode 100644 index 0000000..02f859f --- /dev/null +++ b/LaipuDrawing/WorkAreaMgr.h @@ -0,0 +1,36 @@ +#pragma once +#include "module.h" +#include "EnumPropertieType.h" + +//ĹΧ +class CWorkAreaMgr :public CModule +{ +public: + CWorkAreaMgr(void); + ~CWorkAreaMgr(void); + virtual MODULE GetModuleType(){return _WORK_AREA_PROP;}; + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual void OnAppInitialize(); + + //ӦԵĸı + virtual void OnPropertyChanged(); + virtual void Draw(CDC* pDC); + + DbRect GetWorkArea(); + void SetbDrawWorkArea(bool b){m_bDrawWorkArea = b;}; + bool IsPtInWorkArea(Dbxy pt); +private: + void RefrashWorkArea(); + void DrawWorkArea(CDC* pDC); +private: + bool m_bDrawWorkArea;//Ƿƹ + bool m_bCircle;//ǷΪԲ + bool m_bFrame;//Ƿֻʾ߿ + COLORREF m_WorkRectColor; //򷽿ɫ + + Dbxy m_CenterPt;//Χĵ + DbSize m_WorkRectSize;//򷽿ߴ + DbRect m_DbWorkRect;//豸İȫӹΧ,obj ݲܳΧ +}; + +extern CWorkAreaMgr *gWorkAreaMgr; \ No newline at end of file diff --git a/LaipuDrawing/WorkCmd.cpp b/LaipuDrawing/WorkCmd.cpp new file mode 100644 index 0000000..a345f3a --- /dev/null +++ b/LaipuDrawing/WorkCmd.cpp @@ -0,0 +1,55 @@ +#include "StdAfx.h" +#include "WorkCmd.h" +#include "GlobalFunction.h" +#include "TimingProgressMgr.h" + + +CWorkCmd::CWorkCmd(void) +{ + m_FrontDelay = 0;//ִָ֮ǰʱ(λ: ) + m_AfterDelay = 0;//ִָ֮ʱ(λ: ) + m_bCancel = true; + m_bShowLog = true;//Ƿ־ + m_bUseSleepDelay = false;//ʹsleep ʱ + m_bExcuted = false;//ǷѾִ + m_bExcuting = false;//ڱִ +} +CWorkCmd::~CWorkCmd(void) +{ +} +//Ƿֹ +bool CWorkCmd::Work(bool Cancel) +{ + if(Cancel && m_bCancel)//ָȡ + { + return true; + } + if(m_bExcuted) + return false;//Ѿִй + //ִǰʱ + if(m_FrontDelay>0) + { + if(m_bUseSleepDelay) + Sleep(m_FrontDelay); + else + ExactDelay(Ms2Us(m_FrontDelay)); + } + //д־ + if(m_bShowLog) + WirteLog(); + + //ִ + bool Ret = !Excute(); + //ִкʱ + if(m_AfterDelay>0) + { + if(m_bUseSleepDelay) + Sleep(m_AfterDelay); + else + ExactDelay(Ms2Us(m_AfterDelay)); + } + if(Cancel)//Cancel ״̬ + return true; + m_bExcuted = true; + return Ret; +} \ No newline at end of file diff --git a/LaipuDrawing/WorkCmd.h b/LaipuDrawing/WorkCmd.h new file mode 100644 index 0000000..972c525 --- /dev/null +++ b/LaipuDrawing/WorkCmd.h @@ -0,0 +1,37 @@ +#pragma once +#include "GlobalDefine.h" +#include "LogMgr.h" + + +//ÿƽ̨ƶĵ,洢ʵʵĹ +//command ģʽ +class CWorkCmd +{ +public: + CWorkCmd(void); + virtual ~CWorkCmd(void);//BUG 2015-12-21 + virtual bool Excute()=0; + virtual void WirteLog(){}; + virtual CString GetWorkCmdInfoStr(){return "";}; +public: + void CanNotCancel(){m_bCancel = false;};//ܱȡ + bool Work(bool Cancel); + void SetFrontDelay(int t){m_FrontDelay = t;}; + void SetAfterDelay(int t){m_AfterDelay = t;}; + bool IsbShowLog(){return m_bShowLog;}; + void NotShowLog(){m_bShowLog = false;}; + void UseSleepDelay(){m_bUseSleepDelay = true;}; + bool IsbExcuted(){return m_bExcuted;}; + void SetbExcuting(bool b){m_bExcuting = b;}; + bool IsbExcuting(){return m_bExcuting;}; +protected: + int m_FrontDelay;//ִָ֮ǰʱ(λ: ) + int m_AfterDelay;//ִָ֮ʱ(λ: ) + bool m_bCancel;//ָǷȡ(;ִָֹͣкеָҪִ) + bool m_bShowLog;//Ƿ־ + bool m_bUseSleepDelay;//ʹsleep ʱ + + bool m_bExcuted;//ǷѾִ + bool m_bExcuting;//ڱִ +}; + diff --git a/LaipuDrawing/WorkCmdContainer.cpp b/LaipuDrawing/WorkCmdContainer.cpp new file mode 100644 index 0000000..f3d245a --- /dev/null +++ b/LaipuDrawing/WorkCmdContainer.cpp @@ -0,0 +1,16 @@ +#include "StdAfx.h" +#include "WorkCmdContainer.h" + +CWorkCmdContainer CWorkCmdContainer::m_Instance; +CWorkCmdContainer::CWorkCmdContainer(void) +{ +} +CWorkCmdContainer::~CWorkCmdContainer(void) +{ +} +void CWorkCmdContainer::AddCmd(CWorkCmd *p) +{ + //浽ָ + Sptr sPtr(p); + m_WorkCmdVec.push_back(sPtr); +} diff --git a/LaipuDrawing/WorkCmdContainer.h b/LaipuDrawing/WorkCmdContainer.h new file mode 100644 index 0000000..d6400d0 --- /dev/null +++ b/LaipuDrawing/WorkCmdContainer.h @@ -0,0 +1,20 @@ +#pragma once +#include "SmartPtr.h" +#include "WorkCmd.h" + +//浱ǰҪִеָ(ȫ) +class CWorkCmdContainer +{ +public: + CWorkCmdContainer(void); + ~CWorkCmdContainer(void); + static CWorkCmdContainer &GetInstance(){return m_Instance;}; + void AddCmd(CWorkCmd *p); + int GetCmdCnt(){return m_WorkCmdVec.size();};//ָ + vector> &GetContainer(){return m_WorkCmdVec;}; + void Clear(){m_WorkCmdVec.clear();}; +private: + static CWorkCmdContainer m_Instance; + vector> m_WorkCmdVec;//ָ +}; + diff --git a/LaipuDrawing/WorkCmdInvoker.cpp b/LaipuDrawing/WorkCmdInvoker.cpp new file mode 100644 index 0000000..6489011 --- /dev/null +++ b/LaipuDrawing/WorkCmdInvoker.cpp @@ -0,0 +1,316 @@ +#include "StdAfx.h" +#include "WorkCmdInvoker.h" +#include "GlobalFunction.h" +#include "MsgBox.h" +#include "FileMgr.h" +#include "WorkCmdContainer.h" +#include "ExceptionMsg.h" +#include "ProgressMgr.h" +#include "CommonFlowMgr.h" +#include "ProgramLaserTuiHuo.h" +#include "Laser.h" +#include "WarningMgr.h" +#include "WorkRecord.h" +#include "CStringFuc.h" +#include "CriticalSection.h" + + + +bool gStopAllWrokCmd = false;//ȫֿ + +CWorkCmdInvoker gCmdInvoker_WaferTransfer;//wafer cmd Invoker + +CWorkCmdInvoker gCmdInvoker_WaferAneal;//wafer ˻cmd Invoker +CWorkCmdInvoker gCmdInvoker_ManualOperation;//ֶ cmd Invoker +CWorkCmdInvoker gCmdInvoker_JobQueueCtrl;//job ƵInvoker +CWorkCmdInvoker gCmdInvoker_FoupLoadPort1;//FoupLoadPort1 ƵInvoker +CWorkCmdInvoker gCmdInvoker_FoupLoadPort2;//FoupLoadPort2 ƵInvoker +CWorkCmdInvoker gCmdInvoker_TrheeLightCtrl;//TrheeLightCtrl ƵInvoker +CWorkCmdInvoker gCmdInvoker_ClearWarning;//Invoker + + +bool gAllCmdInvokerStopFlg = false;//ֹͣCmdInvoker ıʶ + +CWorkCmdInvoker::CWorkCmdInvoker(void) +{ + m_bExcutingStop = false;//Ƿֹͣcmd ִ + m_bExcuting = false;//Ƿִ + m_bNeedUpdateCmdList = false;//ǷҪˢcmd б + m_bExcutingPause = false;//ִͣ +} +CWorkCmdInvoker::~CWorkCmdInvoker(void) +{ +} +//ִָ߳к +UINT ExcuteAllCmdThread(LPVOID pParam) +{ + CWorkCmdInvoker *p = (CWorkCmdInvoker *)pParam; + p->ExcuteAllCmdExt(); + return 0; +} +UINT ExcuteCmdThread(LPVOID pParam) +{ + CWorkCmdInvoker *p = (CWorkCmdInvoker *)pParam; + p->ExcuteCmdExt(); + return 0; +} + +#if 1 +//ֱִָ +void CWorkCmdInvoker::Excute() +{ + //ִָ + ExcuteAllCmd(); +} + +//ִָеָ------------------------------------------------- +void CWorkCmdInvoker::ExcuteAllCmd(bool bNewThread,bool WaitForThread) +{ + if(bNewThread)//µִ߳ + { + CWinThread* pThread = AfxBeginThread(ExcuteAllCmdThread,this); + if(WaitForThread)//ȴ߳̽ + WaitForThreadExit(pThread); + } + else + { + ExcuteAllCmdExt(); + } +} +void CWorkCmdInvoker::ExcuteAllCmdExt() +{ + CWorkCmdContainer &CmdContainer = CWorkCmdContainer::GetInstance(); + vector> &WorkCmdVec = CmdContainer.GetContainer(); + //ִеʱֹͣ״̬ + gStopAllWrokCmd = false; + m_bCancel = false;//ָǷֹ + int size = WorkCmdVec.size();// + + CString ErrMsg; + int CmdCnt = WorkCmdVec.size();//ָ + vector>::iterator iter = WorkCmdVec.begin(); + vector>::iterator iter_end = WorkCmdVec.end(); + for(double k = 1;iter!=iter_end;iter++,k += 1) + { + if(!m_bCancel && (gStopAllWrokCmd)) + { + if(gCommonFlowMgr->IsbStopWorkMsg())//ʾֹͣʾ + { + CMsgBox MsgBox; + if(MsgBox.ConfirmOkCancel(_T("ִֹͣ?"))) + { + gLogMgr->WriteDebugLog(_T("func : ExcuteAllCmd---->Stop")); + m_bCancel = true;//ֹͣ + } + else//ִ + { + gStopAllWrokCmd = false; + } + } + else + { + m_bCancel = true;//ֹͣ + } + } + + try + { + m_bCancel = (*iter)->Work(m_bCancel);//ִָʧ,ǿֹ + // + gProgressMgr.SetCurProgress(static_cast(k),size); + } + catch(CExceptionMsg &Msg) + { + ErrMsg = Msg.GetMsgStr(); + //ôʾϢ + gCommonFlowMgr->SetErrMsg(ErrMsg); + gLogMgr->WriteDebugLog(ErrMsg); + m_bCancel = true; + //ǿƽ + gProgressMgr.SetCurProgress(100,100); + } + } + gWorkRecordMgr->EndRecordTime();//ֹͣʱ + + if(ErrMsg != "" && gCommonFlowMgr->IsbShowErrMsg()) + { + CMsgBox MsgBox; + MsgBox.Show(ErrMsg); + } +} +#endif +#if 1 +//ָ +void CWorkCmdInvoker::AddCmd(CWorkCmd *p) +{ + gCriticalSection_WorkCmdInvoker.Lock(); + //浽ָ + Sptr sPtr(p); + m_WorkCmdVec.push_back(sPtr); + m_bNeedUpdateCmdList = true;//ǷҪˢcmd б + gCriticalSection_WorkCmdInvoker.Unlock(); +} +void CWorkCmdInvoker::ClearCmd() +{ + gCriticalSection_WorkCmdInvoker.Lock(); + m_WorkCmdVec.clear(); + m_bNeedUpdateCmdList = true;//ǷҪˢcmd б + gCriticalSection_WorkCmdInvoker.Unlock(); +}; + +void CWorkCmdInvoker::ExcuteCmd(bool bNewThread,bool WaitForThread) +{ + if(bNewThread)//µִ߳ + { + CWinThread* pThread = AfxBeginThread(ExcuteCmdThread,this); + if(WaitForThread)//ȴ߳̽ + WaitForThreadExit(pThread); + } + else + { + ExcuteCmdExt(); + } +} +void CWorkCmdInvoker::ExcuteCmdExt() +{ + m_bExcuting = true;//ִ + m_InvokerWorkTime.StartRecordTime();//ʼʱ + CString Log; + Log = m_CmdInvokerName + "Start"; + gLogMgr->WriteDebugLog(Log); + //ִеʱֹͣ״̬ + gStopAllWrokCmd = false; + m_bCancel = false;//ָǷֹ + int size = m_WorkCmdVec.size();// + + CString ErrMsg; + vector>::iterator iter = m_WorkCmdVec.begin(); + vector>::iterator iter_end = m_WorkCmdVec.end(); + for(double k = 1;iter!=iter_end;iter++,k += 1) + { + if(!m_bCancel && (gStopAllWrokCmd || m_bExcutingStop)) + { + m_bCancel = true;//ֹͣ + } + (*iter)->SetbExcuting(true); + while(m_bExcutingPause)//ͣ˾һֱȴ + { + Sleep(500); + } + try + { + if(!m_bCancel) + { + CString s; + s = Int2Str_LeftZero(k) + " "; + s += (*iter)->GetWorkCmdInfoStr(); + m_CurExcuteCmdInfo = s; + } + m_bCancel = (*iter)->Work(m_bCancel);//ִָʧ,ǿֹ + } + catch(CExceptionMsg &Msg) + { + ErrMsg = Msg.GetMsgStr(); + //ôʾϢ + gCommonFlowMgr->SetErrMsg(ErrMsg); + gLogMgr->WriteDebugLog(ErrMsg); + m_bCancel = true; + } + (*iter)->SetbExcuting(false); + } + //ָ״̬ + m_bExcutingStop = false; + m_bExcutingPause = false; + m_bCancel = false; + m_InvokerWorkTime.StopRecordTime();//ʱ + Log = m_CmdInvokerName + "End"; + gLogMgr->WriteDebugLog(Log); + + if(ErrMsg != "" && gCommonFlowMgr->IsbShowErrMsg()) + { + CMsgBox MsgBox; + MsgBox.Show(ErrMsg); + } + m_bExcuting = false; +} +//Ƿеcmd ִ +bool CWorkCmdInvoker::IsAllCmdExcuted() +{ + bool Ret = true; + vector>::iterator iter = m_WorkCmdVec.begin(); + vector>::iterator iter_end = m_WorkCmdVec.end(); + for(;iter!=iter_end;iter++) + { + if(!(*iter)->IsbExcuted()) + { + Ret = false; + break; + } + } + return Ret; +} +void CWorkCmdInvoker::InitCmdList(CListCtrl &List) +{ + //÷ + List.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + // + int idx = 0; + List.InsertColumn(idx,"Idx",LVCFMT_CENTER,50); + idx++; + List.InsertColumn(idx,"Step Info",LVCFMT_LEFT,400,-1); + idx++; +} +void CWorkCmdInvoker::UpdateCmdList(CListCtrl &List) +{ + gCriticalSection_WorkCmdInvoker.Lock(); + int size = m_WorkCmdVec.size(); + if(m_bNeedUpdateCmdList) + { + List.DeleteAllItems(); + } + else//ֹһ + { + if(size != List.GetItemCount()) + return; + } + int ExcuteIdx = 0;//ǰִеcmd + for(int k=0;kGetWorkCmdInfoStr(); + if(m_bNeedUpdateCmdList) + List.InsertItem(k," "); + List.SetItemText(k,0,Int2Str_LeftZero(k+1)); + List.SetItemText(k,1,CmdInfoStr); + if(m_WorkCmdVec[k]->IsbExcuted()) + ExcuteIdx = k; + } + m_bNeedUpdateCmdList = false; + gCriticalSection_WorkCmdInvoker.Unlock(); +} +COLORREF CWorkCmdInvoker::GetCmdListColor(int Idx) +{ + COLORREF c = RGB_WHITE; + int size = m_WorkCmdVec.size(); + if(Idx>=0&&IdxIsbExcuted()) + c = RGB_BLUE1; + if(m_WorkCmdVec[Idx]->IsbExcuting()) + c = RGB_YELLOW; + } + return c; +} +//ͣ +void CWorkCmdInvoker::SetbExcutingPause(bool b) +{ + m_bExcutingPause = b; + if(b) + { + CString log("Flow--->"); + log += m_CmdInvokerName; + log += " ExcutingPause"; + gLogMgr->WriteDebugLog(log); + } +} + +#endif diff --git a/LaipuDrawing/WorkCmdInvoker.h b/LaipuDrawing/WorkCmdInvoker.h new file mode 100644 index 0000000..1265b3a --- /dev/null +++ b/LaipuDrawing/WorkCmdInvoker.h @@ -0,0 +1,74 @@ +#pragma once +#include "SmartPtr.h" +#include "WorkCmd.h" +#include "WorkCmdContainer.h" +#include "WorkTime.h" + + +class CWorkCmdInvoker +{ +public: + CWorkCmdInvoker(); + virtual ~CWorkCmdInvoker(void); + + void ExcuteAllCmd(bool bNewThread = true,bool WaitForThread = true); + void ExcuteAllCmdExt(); + void Excute(); + void UpdateInfo(); + bool IsCancel(){return m_bCancel;}; + + void AddCmd(CWorkCmd *p); + void ClearCmd(); + + void ExcuteCmd(bool bNewThread,bool WaitForThread); + void ExcuteCmdExt(); + bool IsAllCmdExcuted(); + void SetCmdInvokerName(CString s){m_CmdInvokerName = s;}; + bool IsbExcuting(){return m_bExcuting;}; + void InitCmdList(CListCtrl &List); + void UpdateCmdList(CListCtrl &List); + COLORREF GetCmdListColor(int Idx); + CString GetCurExcuteCmdInfo(){return m_CurExcuteCmdInfo;}; + void SetbDlgWorkCmdListOpened(bool b){m_bDlgWorkCmdListOpened = b;}; + bool IsbDlgWorkCmdListOpened(){return m_bDlgWorkCmdListOpened;}; + void SetbExcutingPause(bool b); + void SetbExcutingStop(){m_bExcutingStop = true;}; + bool IsbExcutingPause(){return m_bExcutingPause;}; + CString GetInvokerWorkTime(){return m_InvokerWorkTime.GetTimeSpanStr();};//ȡǰִʱַ +private: + +private: + bool m_bCancel;//ִָǷж + bool m_bExcuting;//Ƿִ + CString m_CmdInvokerName;//Invoker + CString m_CurExcuteCmdInfo;//ǰִеcmd Ϣ + vector> m_WorkCmdVec;//ָ + bool m_bNeedUpdateCmdList;//ǷҪˢcmd б + + bool m_bDlgWorkCmdListOpened;//list ԻǷ + + bool m_bExcutingStop;//ֹͣcmd ִ + bool m_bExcutingPause;//ִcmd ͣ(Իָ) + + + CWorkTime m_InvokerWorkTime;//ÿInvoker Լļʱ +}; + +extern bool gStopAllWrokCmd; + + +extern bool gAllCmdInvokerStopFlg; +extern CWorkCmdInvoker gCmdInvoker_WaferTransfer;//ֶwafer Invoker + +extern CWorkCmdInvoker gCmdInvoker_WaferAneal;//wafer ˻Invoker +extern CWorkCmdInvoker gCmdInvoker_ManualOperation;//ֶ cmd Invoker +extern CWorkCmdInvoker gCmdInvoker_JobQueueCtrl;//job ƵInvoker +extern CWorkCmdInvoker gCmdInvoker_FoupLoadPort1;//FoupLoadPort1 ƵInvoker +extern CWorkCmdInvoker gCmdInvoker_FoupLoadPort2;//FoupLoadPort2 ƵInvoker +extern CWorkCmdInvoker gCmdInvoker_TrheeLightCtrl;//TrheeLightCtrl ƵInvoker +extern CWorkCmdInvoker gCmdInvoker_ClearWarning;//Invoker + + + + + diff --git a/LaipuDrawing/WorkCmdTimingProgress.cpp b/LaipuDrawing/WorkCmdTimingProgress.cpp new file mode 100644 index 0000000..ad2e208 --- /dev/null +++ b/LaipuDrawing/WorkCmdTimingProgress.cpp @@ -0,0 +1,41 @@ +#include "StdAfx.h" +#include "WorkCmdTimingProgress.h" +#include "LogMgr.h" +#include "WorkCmdInvoker.h" +#include "TimingProgressMgr.h" + + +CWorkCmdTimingProgress::CWorkCmdTimingProgress() +{ + m_ProgressTime = -1;//ʱ +} +CWorkCmdTimingProgress::~CWorkCmdTimingProgress(void) +{ +} +bool CWorkCmdTimingProgress::Excute() +{ + //ýʾ + if(m_ProgressShowInfo != "") + gTimingProgressMgr.SetShowInfo(m_ProgressShowInfo); + //ֹͣ + if(m_ProgressTime==0) + { + gTimingProgressMgr.StopExecute(); + } + // + if(m_ProgressTime>0) + { + gTimingProgressMgr.SetTimingProgressTime(m_ProgressTime); + gTimingProgressMgr.StartTimingProgress(); + } + return true; +} +void CWorkCmdTimingProgress::WirteLog() +{ + +} +CString CWorkCmdTimingProgress::GetWorkCmdInfoStr() +{ + CString InfoStr("TimingProgress"); + return InfoStr; +} \ No newline at end of file diff --git a/LaipuDrawing/WorkCmdTimingProgress.h b/LaipuDrawing/WorkCmdTimingProgress.h new file mode 100644 index 0000000..eb508fa --- /dev/null +++ b/LaipuDrawing/WorkCmdTimingProgress.h @@ -0,0 +1,20 @@ +#pragma once +#include "workcmd.h" + + +//cmd +class CWorkCmdTimingProgress :public CWorkCmd +{ +public: + CWorkCmdTimingProgress(); + ~CWorkCmdTimingProgress(void); + virtual bool Excute(); + virtual void WirteLog(); + CString GetWorkCmdInfoStr(); + void SetTimingProgressTime(int ProgressTime){m_ProgressTime = ProgressTime;}; + void SetTimingProgressShowInfo(CString s){m_ProgressShowInfo = s;}; +private: + CString m_ProgressShowInfo;//ʾ + int m_ProgressTime;//ʱms +}; + diff --git a/LaipuDrawing/WorkData.cpp b/LaipuDrawing/WorkData.cpp new file mode 100644 index 0000000..5a755c4 --- /dev/null +++ b/LaipuDrawing/WorkData.cpp @@ -0,0 +1,28 @@ +#include "StdAfx.h" +#include "WorkData.h" + + +CWorkData::CWorkData(void) +{ +} +CWorkData::~CWorkData(void) +{ +} +//BasePt Ϊĵת +void CWorkData::ConvertData(Dbxy Offset) +{ + vector>::iterator iter = m_vec.begin(); + vector>::iterator iter_end = m_vec.end(); + for(;iter!=iter_end;iter++) + { + vector::iterator iter1 = (*iter).begin(); + vector::iterator iter1_end = (*iter).end(); + for(;iter1!=iter1_end;iter1++) + { + (*iter1).x += Offset.x; + (*iter1).y += Offset.y; + (*iter1).Cx += Offset.x; + (*iter1).Cy += Offset.y; + } + } +} \ No newline at end of file diff --git a/LaipuDrawing/WorkData.h b/LaipuDrawing/WorkData.h new file mode 100644 index 0000000..7ff80a5 --- /dev/null +++ b/LaipuDrawing/WorkData.h @@ -0,0 +1,18 @@ +#pragma once +#include "GlobalDefine.h" + + +//ʹõĹ +class CWorkData +{ +public: + CWorkData(void); + ~CWorkData(void); + vector> &GetDataVec(){return m_vec;}; + void Clear(){m_vec.clear();}; + bool Empty(){return m_vec.empty();}; + void ConvertData(Dbxy BasePt); +private: + vector> m_vec;//߶εķʽ(ÿvector һ߶) +}; + diff --git a/LaipuDrawing/WorkDataMgr.cpp b/LaipuDrawing/WorkDataMgr.cpp new file mode 100644 index 0000000..599ae22 --- /dev/null +++ b/LaipuDrawing/WorkDataMgr.cpp @@ -0,0 +1,59 @@ +#include "StdAfx.h" +#include "WorkDataMgr.h" +#include "GlobalFunction.h" +#include "MsgBox.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "PenParMgr.h" + + + +CWorkDataMgr *gWorkDataMgr = new CWorkDataMgr; +CWorkDataMgr::CWorkDataMgr(void) +{ + m_bTempMode = false;//ģģʽ,ģʽԲΪԲ,ͨʲģ +} +CWorkDataMgr::~CWorkDataMgr(void) +{ +} +CMFCPropertyGridProperty *CWorkDataMgr::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = _T("WorkDataMgr");//洢· + CString Name; +//-------------------------------------------------------------------------------// + PropertyName = _T("ӹ"); + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + { + //Աӳ + Name = _T("m_bTempMode");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bTempMode); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + + //ʾ + PropertyName = _T("ģģʽ"); + Description = _T("ģģʽ,ģʽԲΪԲ,ͨʲģ"); + CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bTempMode, Description); + pGroup->AddSubItem(p); + + gDevicePropertieMgr.Insert(p, pPropertie); + } + } +//-------------------------------------------------------------------------------// + return pGroup; +} +//ͨʺȡԪģ +void CWorkDataMgr::GetTempDataByPenNum(vector> &DataVec,int PenNum) +{ + +} \ No newline at end of file diff --git a/LaipuDrawing/WorkDataMgr.h b/LaipuDrawing/WorkDataMgr.h new file mode 100644 index 0000000..1de1c0b --- /dev/null +++ b/LaipuDrawing/WorkDataMgr.h @@ -0,0 +1,18 @@ +#pragma once +#include "GlobalDefine.h" +#include "Module.h" + +//ݹ() +class CWorkDataMgr:public CModule +{ +public: + CWorkDataMgr(void); + ~CWorkDataMgr(void); + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual MODULE GetModuleType(){return _WORK_DATA_PROP;}; + bool IsbTempMode(){return m_bTempMode;}; + void GetTempDataByPenNum(vector> &DataVec,int PenNum); +private: + bool m_bTempMode;//ģģʽ,ģʽԲΪԲ,ͨʲģ +}; +extern CWorkDataMgr *gWorkDataMgr; \ No newline at end of file diff --git a/LaipuDrawing/WorkFileLable.h b/LaipuDrawing/WorkFileLable.h new file mode 100644 index 0000000..1c09693 --- /dev/null +++ b/LaipuDrawing/WorkFileLable.h @@ -0,0 +1,194 @@ +#pragma once + +//дļıǩĿдmak ļʱɾҲӰ֮ǰmak ļ + + +//¼ͱں棬ǰĵܶȡ +enum LAB_TYPE +{ + LAB_NULL = 0,//ҲԲָκαǩģԼ + LAB_MODULE_START,//ģ鿪ʼ,ģֵ + LAB_MODULE_END,//ģ + LAB_MODULE_TYPE,//ģ + //ģݵıǩ----------------------------------- + LAB_TEMPLATE_START,//ģ忪ʼ + LAB_TEMPLATE_END,//ģ + LAB_OBJ_START,//ʼ + LAB_OBJ_END,// + LAB_OBJ_TYPE,//obj + LAB_PEN_NUM,//obj ıʺ + LAB_POINT_START,//obj ݵ㿪ʼ + LAB_POINT_END,//obj ݵ + LAB_POINT_X,//ݵX + LAB_POINT_Y,//ݵY + LAB_POINT_IS_NODE,//ݵǷΪڵ + LAB_SIZE_W,//ߴ + LAB_SIZE_H,//ߴ߶ + LAB_MARK_PAR_START,//񾵲 + LAB_MARK_PAR_END,//񾵲 + LAB_MARK_AREA_START,// + LAB_MARK_AREA_END,// + LAB_PRODUCT_START,//Ʒ + LAB_PRODUCT_END,//Ʒ + LAB_OBJ_IS_CIRCLE,//ԭǷΪԲ + LAB_CIRCLE_R,//Բ뾶 + LAB_CIRCLE_D,//Բֱ + LAB_CIRCLE_EDGE_CNT,//Բ + //ʿ˻豸----------------------------------------------- + LAB_TH_START,//˻ + LAB_TH_END,//˻ + LAB_TH_SCAN_OVERLAP,//ɨص + LAB_TH_SCAN_LINE_START,//ɨSTART + LAB_TH_SCAN_LINE_END,//ɨEND + LAB_TH_SCAN_LINE_SPT_X,//ʼX + LAB_TH_SCAN_LINE_SPT_Y,//ʼY + LAB_TH_SCAN_LINE_EPT_X,//X + LAB_TH_SCAN_LINE_EPT_Y,//Y + LAB_TH_SCAN_LINE_SPOT_DIA,//ֱ + LAB_TH_SCAN_LINE_BSCAN,//Ƿɨ + LAB_TH_M_PT_START,//START + LAB_TH_M_PT_END,//END + LAB_TH_M_PT_X,//X + LAB_TH_M_PT_Y,//Y + LAB_TH_M_PT_TMP,//¶ + LAB_TH_M_PT_POWER,// + LAB_TH_M_PT_OBJ_IDX,//OBJ ֵ + LAB_TH_LOT_ID,//lot ID + LAB_TH_WAFER_ID,//ԲID + LAB_TH_LASER_808_V,//808 ĵѹ + //ɿCO2 豸-------------------------------------------------------- + LAB_UPK_PRODUCT_THICKNESS,//Ʒ + LAB_UPK_PRODUCT_DIA,//Ʒֱ + LAB_UPK_HOLE_WIDTH,//׿ + LAB_UPK_HOLE_DIA,//ֱ + LAB_UPK_LASER_POWER,//⹦ + + LAB_OBJ_IS_MARK,//obj Ƿmark + + LAB_OBJ_ARC_START_X, + LAB_OBJ_ARC_START_Y, + LAB_OBJ_ARC_END_X, + LAB_OBJ_ARC_END_Y, + LAB_OBJ_ARC_CENTER_X, + LAB_OBJ_ARC_CENTER_Y, + LAB_OBJ_ARC_EDGE_CNT, + LAB_OBJ_ARC_DIR, + + LAB_ADJUST_OFFSET_X, + LAB_ADJUST_OFFSET_Y, + LAB_ADJUST_SIZE_X, + LAB_ADJUST_SIZE_Y, + LAB_ROTATO_ADJUST, + + LAB_RCD_START, + LAB_RCD_END, + LAB_RCD_WORK_START_TIME,//ʼӹʱ + LAB_RCD_WORK_END_TIME,//ӹʱ + LAB_RCD_WORK_SPAN_TIME,//ӹʱ + LAB_RCD_WORK_SPAN_TIME_SECOND,//ӹʱ() + LAB_RCD_USER_NAME,//û + LAB_RCD_USER_TYPE,//ûȨ + LAB_RCD_WORK_PAR1,//ӹ + LAB_RCD_WORK_PAR2,//ӹ + LAB_RCD_WORK_PAR3,//ӹ + LAB_RCD_WORK_PAR4,//ӹ + LAB_RCD_WORK_PAR5,//ӹ + LAB_RCD_WORK_PAR6,//ӹ + LAB_RCD_WORK_PAR7,//ӹ + LAB_RCD_WORK_PAR8,//ӹ + LAB_RCD_WORK_PAR9,//ӹ + LAB_RCD_WORK_PAR10,//ӹ + LAB_RCD_WORK_PAR11,//ӹ + LAB_RCD_WORK_PAR12,//ӹ + LAB_RCD_WORK_PAR13,//ӹ + LAB_RCD_WORK_PAR14,//ӹ + LAB_RCD_WORK_PAR15,//ӹ + LAB_RCD_WORK_PAR16,//ӹ + LAB_RCD_WORK_PAR17,//ӹ + LAB_RCD_WORK_PAR18,//ӹ + LAB_RCD_WORK_PAR19,//ӹ + LAB_RCD_WORK_PAR20,//ӹ + LAB_RCD_PRODUCT_ID,//ƷID + + LAB_TUIHUO_FOCUS_ADJUST_VAL,// + LAB_TUIHUO_SCAN_AREA_NAME,//ɨ + + LAB_RCD_PRODUCT_IDX,//ƷƬ + LAB_RCD_SCAN_AREA_NAME,//ɨ + LAB_RCD_PEN_SEL_STATE,//ʺŵѡ״̬ + + LAB_RCD_WORK_DATE_TIME_NAME,//ںʱ(ҶӦIJļ) + + LAB_RCD_END_SCAN_LINE_IDX,////ɨʱɨߵֵ(ָжϵ) + LAB_RCD_TOTAL_SCAN_LINE_CNT,//ɨߵ + + LAB_TUIHUO_AUTO_POWER_MODE,//Զƥģʽ +}; + +//дɿɶtxt ļҪ +inline CString GetLabTypeStr(LAB_TYPE type) +{ + CString str; + switch(type) + { + case LAB_MODULE_START: + str = "LAB_MODULE_START"; + break; + case LAB_MODULE_END: + str = "LAB_MODULE_END"; + break; + case LAB_TEMPLATE_START: + str = "LAB_TEMPLATE_START"; + break; + case LAB_TEMPLATE_END: + str = "LAB_TEMPLATE_END"; + break; + case LAB_MARK_PAR_START: + str = "LAB_MARK_PAR_START"; + break; + case LAB_MARK_PAR_END: + str = "LAB_MARK_PAR_END"; + break; + case LAB_MARK_AREA_START: + str = "LAB_MARK_AREA_START"; + break; + case LAB_MARK_AREA_END: + str = "LAB_MARK_AREA_END"; + break; + case LAB_OBJ_START: + str = "LAB_OBJ_START"; + break; + case LAB_OBJ_END: + str = "LAB_OBJ_END"; + break; + case LAB_OBJ_TYPE: + str = "LAB_OBJ_TYPE"; + break; + case LAB_PEN_NUM: + str = "LAB_PEN_NUM"; + break; + case LAB_POINT_START: + str = "LAB_POINT_START"; + break; + case LAB_POINT_END: + str = "LAB_POINT_END"; + break; + case LAB_POINT_X: + str = "LAB_POINT_X"; + break; + case LAB_POINT_Y: + str = "LAB_POINT_Y"; + break; + case LAB_POINT_IS_NODE: + str = "LAB_POINT_IS_NODE"; + break; + default: + str = "LAB_NULL"; + break; + } + + return str; +} + + + diff --git a/LaipuDrawing/WorkFileMgr.cpp b/LaipuDrawing/WorkFileMgr.cpp new file mode 100644 index 0000000..d97aed0 --- /dev/null +++ b/LaipuDrawing/WorkFileMgr.cpp @@ -0,0 +1,427 @@ +#include "StdAfx.h" +#include "WorkFileMgr.h" +#include "GlobalDefine.h" +#include "TemplateMgr.h" +#include "WorkFileLable.h" +#include "LogMgr.h" +#include "ModuleDeviceMgr.h" +#include "ModuleDrawMgr.h" +#include "ObjComponentMgr.h" +#include "MsgBox.h" +#include "GlobalFunction.h" +#include "MarkAreaMgr.h" +#include "FileMgr.h" +#include "Laser.h" +#include "CommonFlowMgr.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "WorkTime.h" +#include "PenParMgr.h" +#include "ProgramLaserTuiHuo.h" +#include "WaferRecipeDataMgr.h" +#include "PropertieMgr.h" +#include "EncryptionMgr.h" + + + +#define SAVE_PAR_FILE_PATH _T("\\SaveDevPar\\") +#define CHECK_WAFER_PT_RADIUS 160 //ݵķΧ + +#define MAP_HISTORY_DATA_PATH _T("\\MapHistory\\") +#define RECIPE_FILE_PATH _T("\\RecipePar\\") + + +CString CWorkFileMgr::m_CurOpenFile; + +CWorkFileMgr *gWorkFileMgr = new CWorkFileMgr; +CWorkFileMgr::CWorkFileMgr(void) +{ +} +CWorkFileMgr::~CWorkFileMgr(void) +{ +} +void CWorkFileMgr:: OnAppInitialize() +{ +} +#if 1 +//Ƿļ +bool CWorkFileMgr::IsOpenFile() +{ + if(m_CurOpenFile == "") + { + CMsgBox MsgBox; + MsgBox.Show("δļ!"); + return false; + } + return true; +} +void CWorkFileMgr::OnOpenFile() +{ + TCHAR szFilters[]=("MAK ļ(*.mak)|*.mak"); + CFileDialog dlg(TRUE,("mak"),("MarkFile"),OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilters); + if(dlg.DoModal()==IDOK) + { + OnOpenFileExt(dlg.GetPathName()); + } +} +void CWorkFileMgr::OnOpenFileExt(CString Path) +{ + ReadWorkFile(Path); + //¼ǰ򿪵ļ------------------------------------------ + SaveFileName(Path); + CLayer &layer = gLayer; + layer.NotSelAllObj();//ȫѡ + //бʵѡ״̬ + gPenParMgr->ResetAllSelState(); + #ifdef __DLG_PANE_PEN_PAR__ + GetFrame()->m_CDlgPenPar.UpdatePar(); + #endif +} +//¼ļ֣ʾ +void CWorkFileMgr::SaveFileName(CString FileName) +{ + m_CurOpenFile = FileName; + GetCurDocPtr()->SetTitle(m_CurOpenFile); +} +//浱ǰ򿪵ĵ +void CWorkFileMgr::OnSaveFile() +{ + int len = m_CurOpenFile.GetLength(); + CString FileSuffix;//ļ׺ + + if(len>4) + FileSuffix = m_CurOpenFile.Right(3); + + if(m_CurOpenFile == "" || (FileSuffix != "" && (FileSuffix != "mak")))//µļ + { + //Ϊ + OnSaveFileAs(); + } + else//浱ǰ򿪵ļ + { + SaveFile(m_CurOpenFile); + CMsgBox MsgBox; + MsgBox.Show(m_CurOpenFile+" ɹ!"); + } +} +//Ϊ +void CWorkFileMgr::OnSaveFileAs() +{ + +} +void CWorkFileMgr::SaveFile(CString FileName) +{ + SaveWorkFile(FileName); + SaveFileName(FileName); +} +#endif +#if 1 + +void CWorkFileMgr::SaveWorkFile(CString FilePath) +{ + //洢бǩ + vector LabVec; + //ȡģıǩ + //gModuleDeviceMgr.SaveWorkFile(LabVec); + gPenParMgr->SaveWorkFile(LabVec); + gWaferRecipeDataMgr->SaveWorkFile(LabVec); + //ǩд뵽ļ + SaveWorkFileExt(FilePath,LabVec); +} + +//бǩдļ +void CWorkFileMgr::SaveWorkFileExt(CString FilePath,vector &LabVec) +{ + CFile file(FilePath,CFile::modeReadWrite|CFile::modeCreate); + CArchive ar(&file,CArchive::store); + + size_t LabCnt = LabVec.size(); + ar<::iterator iter = LabVec.begin(); + vector::iterator iter_end = LabVec.end(); + for(;iter!=iter_end;iter++) + { + (*iter).Serialize(ar); + } +} +#endif +#if 1 +void CWorkFileMgr::ReadWorkFile(CString FilePath) +{ + //ȡ---------------------------------------------------------- + vector LabVec; + ReadWorkFileExt(FilePath,LabVec); + if(LabVec.empty()) + return; + //ÿģ------------------------------------------------------------ + CLabVecRang LabVecRang(LabVec,0,LabVec.size()-1); + vector LabVecRangVec; + + SeparateStrVec(LabVecRang,LabVecRangVec,LAB_MODULE_START,LAB_MODULE_END); + + //δÿģ--------------------------------------------------- + vector::iterator iter = LabVecRangVec.begin(); + vector::iterator iter_end = LabVecRangVec.end(); + for(;iter!=iter_end;iter++) + { + if(gModuleDrawMgr.ReadWorkFile(*iter)) + continue;//ظȡ + gModuleDeviceMgr.ReadWorkFile(*iter); + } +} +void CWorkFileMgr::ReadWorkFileExt(CString FilePath,vector &LabVec) +{ + CFile file; + if(file.Open(FilePath,CFile::modeRead)) + { + CArchive ar(&file,CArchive::load); + size_t LabCnt; + ar>>LabCnt;//ȶȡǩĸ + for(size_t i=0;iWriteDebugLog("File Read Error", _LOG_ERROR); + } +} +//LabVecRang иStrLabStart StrLabEnd ǩȡstr 浽LabVecRangVec +void CWorkFileMgr::SeparateStrVec(CLabVecRang &LabVecRang,vector &LabVecRangVec,LAB_TYPE StrLabStart,LAB_TYPE StrLabEnd) +{ + size_t StartCnt = 0;//Ƕ׵ + size_t StartIdx = 0; + size_t EndIdx = 0; + + size_t Start = LabVecRang.GetStart(); + size_t End = LabVecRang.GetEnd()+1; + for(size_t i=Start;iStartIdx)//ҪѼյķΧ + { + CLabVecRang Rang(LabVecRang.GetVec(),StartIdx,EndIdx); + LabVecRangVec.push_back(Rang); + } + } + StartCnt--; + } + } +} +void CWorkFileMgr::SeparateLabVecRangVec(vector &LabVec,vector&LabVecRangVec,CString Path,LAB_TYPE StrLabStart,LAB_TYPE StrLabEnd) +{ + CFileMgr FileMgr; + if(!FileMgr.IsFileExist(Path)) + return; + + ReadWorkFileExt(Path,LabVec); + if(LabVec.empty()) + return; + //ÿ¼------------------------------------------------------------ + CLabVecRang LabVecRang(LabVec,0,LabVec.size()-1); + SeparateStrVec(LabVecRang,LabVecRangVec,StrLabStart,StrLabEnd); +} + +//StrVec ҺͱǩLabStr ƥַȡǩֵ,ûֵ"" +CLab CWorkFileMgr::FindLab(CLabVecRang &LabVecRang,LAB_TYPE LabStr) +{ + CLab ret; + size_t Start = LabVecRang.GetStart(); + size_t End = LabVecRang.GetEnd()+1; + for(size_t i=Start;iGetScanAreaFilePath(); + dlg.m_ofn.lpstrInitialDir = Path; + if(dlg.DoModal()==IDOK) + { + ReadObjTemplateFile(dlg.GetPathName()); + m_pView->RefreshView(); + } +} +//obj ļ +void CWorkFileMgr::SaveObjFile() +{ + CObjContainer &LayerObjContainer = gLayer.GetObjContainer(); + if(!LayerObjContainer.CheckPtRadius(CHECK_WAFER_PT_RADIUS)&&!gEncryptionMgr->IsbRunAtNoteBook()) + { + CString s; + s.Format("ݵ㲻ЧΧ֮ڣֱ= %d",(CHECK_WAFER_PT_RADIUS*2)); + CMsgBox MsgBox; + MsgBox.Show(s); + return; + } + + TCHAR szFilters[]=("OBJ ļ(*.obj)|*.obj"); + CFileDialog dlg(FALSE,("obj"),("ObjFile"),OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilters); + //Ĭ· + dlg.m_ofn.lpstrInitialDir = gProgramLaserTuiHuo->GetScanAreaFilePath(); + if(dlg.DoModal()==IDOK) + { + SaveObjTemplateFile(dlg.GetPathName()); + } +} +//ǰMap ¼· +CString CWorkFileMgr::CreatMapHistoryPath() +{ + CString MonitoringDataPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(MAP_HISTORY_DATA_PATH); + CString Path = MonitoringDataPath; + CFileMgr FileMgr; + CWorkTime WorkTime; + Path += WorkTime.GetCurYear(); + Path += "\\"+WorkTime.GetCurMonth(); + Path += "\\"+WorkTime.GetCurDay(); + Path += "\\"; + if(!FileMgr.IsDirectoryExists(Path)) + { + FileMgr.CreatDir(Path); + } + return Path; +} + +#endif +#if 1 +//Txt ļеobj +void CWorkFileMgr::OpenObjTxtFile() +{ + TCHAR szFilters[]=("TXT ļ(*.txt)|*.txt"); + CFileDialog dlg(TRUE,("txt"),("TxtFile"),OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilters); + //Ĭ· + CString Path = gProgramLaserTuiHuo->GetObjTxtFilePath(); + dlg.m_ofn.lpstrInitialDir = Path; + if(dlg.DoModal()==IDOK) + { + gLayer.DelAllObj(); + CObjContainer &LayerObjContainer = gLayer.GetObjContainer(); + LayerObjContainer.ReadObjFromTxt(dlg.GetPathName()); + m_pView->RefreshView(); + } +} +//obj txt ļ +void CWorkFileMgr::SaveObjTxtFile() +{ + TCHAR szFilters[]=("TXT ļ(*.txt)|*.txt"); + CFileDialog dlg(FALSE,("txt"),("TxtFile"),OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilters); + //Ĭ· + dlg.m_ofn.lpstrInitialDir = gProgramLaserTuiHuo->GetObjTxtFilePath(); + if(dlg.DoModal()==IDOK) + { + CObjContainer &LayerObjContainer = gLayer.GetObjContainer(); + LayerObjContainer.SaveObjToTxt(dlg.GetPathName()); + } +} + +#endif +#if 1 +void CWorkFileMgr::ExtParToTxtFile() +{ + TCHAR szFilters[]=("TXT ļ(*.txt)|*.txt"); + CString FileName;//Ĭļ + FileName += gWorkTime.GetDateTime("_","_"); + FileName = "DevicePar_"+FileName; + CFileDialog dlg(FALSE,("txt"),FileName,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilters); + //Ĭ· + if(dlg.DoModal()==IDOK) + { + gDevicePropertieMgr.SaveAllPropertieToTxtFile(dlg.GetPathName()); + } +} +//򿪵ʱ򵼳ļ +void CWorkFileMgr::ExtParToTxtFileOnAppOpen() +{ + CString DirPath = gProgramLaserTuiHuo->GetLaipuLaserDataDir(SAVE_PAR_FILE_PATH); + CFileMgr FileMgr; + if(!FileMgr.IsDirectoryExists(DirPath)) + FileMgr.CreatDir(DirPath); + + CString FileName;//Ĭļ + FileName += gWorkTime.GetDateTime("_","_"); + FileName = "DevicePar_"+FileName; + FileName += ".bin"; + CString FilePath = DirPath + FileName; + gDevicePropertieMgr.SaveAllPropertieToTxtFile(FilePath); + + CString Log; + Log = "ExtPar-->"; + Log += FileName; + gLogMgr->WriteDebugLog(Log); +} +//ͨļobj ļ(·) +void CWorkFileMgr::ReadObjFileByName(CString FileName) +{ + CFileMgr FileMgr; + CString FilePath;//· + FileMgr.GetFullFilePath(FilePath,FileName); + ReadObjTemplateFile(FilePath); +} +//ͨļobj ļ(·) +void CWorkFileMgr::ReadObjTemplateFile(CString FilePath) +{ + ReadWorkFile(FilePath); +} +//ֻobj ģ +void CWorkFileMgr::SaveObjTemplateFile(CString FilePath) +{ + CString MapHistoryPath = CreatMapHistoryPath(); + CFileMgr FileMgr; + bool bFileExist = FileMgr.IsFileExist(FilePath); + CString FileName = FileMgr.GetFileNameFromPath(FilePath,true); + CString s = "["; + CWorkTime WorkTime; + s += WorkTime.GetCurTime("_"); + s += "_"; + s += gAuthorityMgr->GetCurUserName(); + s += "]"; + FileName = s +FileName; + FileName += ".obj"; + MapHistoryPath += FileName; + if(bFileExist)//obj ļʹ,Ƶhistory + { + FileMgr.CopyFolder(FilePath,MapHistoryPath); + } + vector LabVec;//洢бǩ + //Ѽбǩ + gTemplateMgr->SaveWorkFile(LabVec); + //бǩдļ + SaveWorkFileExt(FilePath,LabVec); + + if(!bFileExist)//obj ļ,Ƶhistory (ʾ½obj) + { + FileMgr.CopyFolder(FilePath,MapHistoryPath); + } +} + +#endif + diff --git a/LaipuDrawing/WorkFileMgr.h b/LaipuDrawing/WorkFileMgr.h new file mode 100644 index 0000000..1d78854 --- /dev/null +++ b/LaipuDrawing/WorkFileMgr.h @@ -0,0 +1,48 @@ +#pragma once +#include "GlobalDefine.h" +#include "LabVecRang.h" +#include "Module.h" + + + +//ļıͶȡ +class CWorkFileMgr:public CModule +{ +public: + CWorkFileMgr(void); + ~CWorkFileMgr(void); + virtual MODULE GetModuleType(){return _WORK_FILE_PROP;}; + virtual void OnAppInitialize(); + + void SaveWorkFile(CString FilePath); + void ReadWorkFile(CString FilePath); + void SeparateStrVec(CLabVecRang &LabVecRang,vector &LabVecRangVec,LAB_TYPE StrLabStart,LAB_TYPE StrLabEnd); + void SeparateLabVecRangVec(vector &LabVec,vector&LabVecRangVec,CString Path,LAB_TYPE StrLabStart,LAB_TYPE StrLabEnd); + CLab FindLab(CLabVecRang &LabVecRang,LAB_TYPE LabStr); + void OnOpenFile(); + void OnSaveFile(); + void OnSaveFileAs(); + void OpenObjFile(); + void SaveObjFile(); + static CString GetCurOpenFilePath(){return m_CurOpenFile;}; + bool IsOpenFile(); + void ReadObjFileByName(CString FileName); + void SaveObjTemplateFile(CString FilePath); + void ReadObjTemplateFile(CString FileName); + void SaveWorkFileExt(CString FilePath,vector &LabVec); + void WriteDbxyVecToFile(vector &vec,CString Path); + void SaveFileName(CString FileName); + void OnOpenFileExt(CString Path); + void ExtParToTxtFile(); + void ExtParToTxtFileOnAppOpen(); + void OpenObjTxtFile(); + void SaveObjTxtFile(); +private: + void ReadWorkFileExt(CString FilePath,vector &LabVec); + void SaveFile(CString FileName); + CString CreatMapHistoryPath(); +private: + static CString m_CurOpenFile;//ǰ򿪵ļ +}; + +extern CWorkFileMgr *gWorkFileMgr; \ No newline at end of file diff --git a/LaipuDrawing/WorkRecord.cpp b/LaipuDrawing/WorkRecord.cpp new file mode 100644 index 0000000..0c0493c --- /dev/null +++ b/LaipuDrawing/WorkRecord.cpp @@ -0,0 +1,660 @@ +#include "StdAfx.h" +#include "WorkRecord.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" +#include "WorkTime.h" +#include "FileMgr.h" +#include "LogMgr.h" +#include "GlobalFunction.h" +#include "WorkFileMgr.h" +#include "CStringFuc.h" +#include "ProgramLaserTuiHuo.h" +#include "AllThreadMgr.h" +#include "WaferRecipeDataMgr.h" +#include "RecipeMgr.h" +#include "Layer.h" +#include "Laser.h" +#include "MsgBox.h" +#include "MyDlgView.h" +#include "TimingProgressMgr.h" +#include "ObjFillMgr.h" + + +#define RECORD_FILE_PATH _T("\\WorkRecord") + +#define RECOR_JOB_ID "Job ID" +#define RECOR_LOT_ID "Lot ID" +#define RECOR_RECIPE "Recipe" +#define RECOR_LAYER_IDX "" +#define RECOR_START_TIME "ʼʱ" +#define RECOR_SPAN_TIME "ӹʱ" +#define RECOR_SPAN_TIME_S "ӹʱ()" +#define RECOR_SPAN_USER_NAME "û" +#define RECOR_SPAN_USER_TYPE "û" +#define RECOR_SPAN_START_SCAN_IDX "ʼֵ" +#define RECOR_SPAN_END_SCAN_IDX "ֵ" +#define RECOR_SPAN_TOTAL_SCAN_IDX "ɨ" +#define RECOR_FOCUS_Z_COORD "⽹λ" //˻ʱZ ֵ(ÿƬwafer ܻе㲻һ) +#define RECOR_DISMETER_OFFSET "ƫֵ"//¼˵ǰ +#define RECOR_LASER_SPOT_W "߿" +#define RECOR_LASER_SPOT_H "߸߶" +#define RECOR_SET_LASER1_CURR "趨1 " +#define RECOR_SET_LASER2_CURR "趨2 " + + +//ʱ߳(֪ͨ۲ʱ䷢仯) +UINT RecordTimeThread(LPVOID pParam) +{ + CWorkRecordMgr *p = (CWorkRecordMgr *)pParam; + p->UpdateCurRecordTime(); + return 0; +} + +CWorkRecordMgr *gWorkRecordMgr = new CWorkRecordMgr; +CWorkRecordMgr::CWorkRecordMgr(void) +{ + m_CurProcessingTime = "00:00:00"; + m_CurTotalWorkTime = "00:00:00";//ǰܵļӹʱ + m_bSelWorkInfoRecord = false;//Ƿѡеļ¼ +} +CWorkRecordMgr::~CWorkRecordMgr(void) +{ +} +void CWorkRecordMgr::OnAppInitialize() +{ + //¼ӹʱ߳ + CWinThread* pThread; + pThread = AfxBeginThread(RecordTimeThread,this); + gAllThreadMgr.BindingThreadAdr(_EThreadType_RecordTimeThread,pThread); + + //¼Ŀ¼ǷҪ + #if 0 + CString RecordPath; + CFileMgr FileMgr; + FileMgr.GetFullFilePath(RecordPath,RECORD_FILE_PATH); + if(!FileMgr.IsFileExist(RecordPath)) + { + FileMgr.CreatDir(RecordPath); + } + #endif +} +//ˢµǰʱ +void CWorkRecordMgr::UpdateCurRecordTime() +{ + while(1) + { + if(gAllThreadMgr.IsbStopAllThread()) + break; + gAllThreadMgr.SetThreadInfoState(_EThreadType_RecordTimeThread,true); + + CString SpanStr = m_WorkTime.GetTimeSpanStr(); + if(SpanStr !="") + { + m_CurProcessingTime = SpanStr;//ǰӹʱ + } + Sleep(500); + } + gAllThreadMgr.SetThreadInfoState(_EThreadType_RecordTimeThread,false); +} +#if 1 +//ʼ¼ +void CWorkRecordMgr::StartRecord() +{ + gLogMgr->WriteDebugLog("Func---->RecordMgr Start Record"); + //¼ӹʼʱ + m_WorkStartTime = m_WorkTime.GetCurTime(":"); + m_WorkTime.StartRecordTime(); + + //¼ʼֵ + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + if(_ScanStateType_AllScanned == GetCurScanStateType()) + { + //ɨ״̬ + ResetScanState(); + gLayer.ResetAllObjScaned(); + } + //¼ǰɨߵ + m_CurScanState.m_TotalScanLineCnt = ObjContainer.GetScanLineCnt(); + //¼ɨ迪ʼidx + m_CurScanState.m_StartScanLineIdx = m_CurScanState.m_EndScanLineIdx; + m_CurScanState.m_ScanedLineCnt = 0; + + GetCurScanStateType(); +} +//¼ +void CWorkRecordMgr::EndRecord() +{ + m_CurScanState.m_EndScanLineIdx = m_CurScanState.m_StartScanLineIdx + m_CurScanState.m_ScanedLineCnt; + GetCurScanStateType(); + //obj ɨ״̬ + CObjContainer &ObjContainer = gLayer.GetObjContainer(); + ObjContainer.SetObjScanState(m_CurScanState.m_EndScanLineIdx); + + //Ҫɨһ߶βż¼ + if(m_CurScanState.m_ScanedLineCnt>1) + { + //浱ǰļӹ¼ + SaveCurWorkRecord(); + } +} +//ֹͣ¼ʱ +void CWorkRecordMgr::EndRecordTime() +{ + m_WorkTime.StopRecordTime(); + double SpanSecond = m_WorkTime.GetTimeSpanSecond();//,OEE + m_CurRecordTimeSecond = Db2CString(SpanSecond); +} +#endif +#if 1 +//ȡǰɨ״̬ +EScanStateType CWorkRecordMgr::GetCurScanStateType() +{ + CString str; + EScanStateType ScanState; + int EndScanLineIdx = m_CurScanState.m_EndScanLineIdx; + int TotalScanLineCnt = m_CurScanState.m_TotalScanLineCnt; + str.Format("Par---->StartIdx[%ld]Scaned[%ld]EndIdx[%ld]Total[%ld]",m_CurScanState.m_StartScanLineIdx,m_CurScanState.m_ScanedLineCnt,EndScanLineIdx,TotalScanLineCnt); + gLogMgr->WriteDebugLog(str); + if(EndScanLineIdx==0) + { + ScanState = _ScanStateType_NotScanned; + str = ("CurScanState: _NotScanned"); + } + else if(EndScanLineIdx>0 && (EndScanLineIdx < (TotalScanLineCnt))) + { + ScanState = _ScanStateType_PartiallyScanned; + str = ("CurScanState: _PartiallyScanned"); + + } + else if(EndScanLineIdx >= (TotalScanLineCnt)) + { + ScanState = _ScanStateType_AllScanned; + str = ("CurScanState: _AllScanned"); + } + else + { + ScanState = _ScanStateType_Null; + str = ("CurScanState: _Type_Null"); + } + gLogMgr->WriteDebugLog(str); + return ScanState; +} +//ɨ״̬ +void CWorkRecordMgr::ResetScanState() +{ + gLogMgr->WriteDebugLog("Func---->ResetScanState"); + m_CurScanState.m_EndScanLineIdx = 0; + m_CurScanState.m_ScanedLineCnt = 0; +} +#endif +#if 1 +//ȡΪFileName ļ¼· +CString CWorkRecordMgr::GetRecordFilePath(CString FileName) +{ + CString FullFilePath; + CString WorkRecordFilePath = gProgramLaserTuiHuo->GetWorkRecordFilePath(); + if(WorkRecordFilePath=="") + { + CString FilePath = RECORD_FILE_PATH; + FilePath += "\\" + FileName + ".rcd"; + CFileMgr FileMgr; + FileMgr.GetFullFilePath(FullFilePath,FilePath); + } + else + { + FullFilePath = WorkRecordFilePath+"\\" + FileName + ".rcd"; + } + return FullFilePath; +} +//ȡǰ¼ļ(0㵽24һ) +CString CWorkRecordMgr::GetCurRecordFileName() +{ + return m_WorkTime.GetCurDate("_"); +} +#endif +#if 1 +//浱ǰļӹ¼ +void CWorkRecordMgr::SaveCurWorkRecord() +{ + gLogMgr->WriteDebugLog("Func---->SaveCurWorkRecord"); + CWorkRecord WorkRecord; + //ǰļӹ¼ + CreatCurWorkRecord(WorkRecord); + //ӹ¼д뵽ļ + WriteWorkRecordToFile(WorkRecord); + //ۼCyclicWafer + gProgramLaserTuiHuo->CyclicWaferInc(); + +} +//ǰļӹ¼ +void CWorkRecordMgr::CreatCurWorkRecord(CWorkRecord &WorkRecord) +{ + //Ϣ + CreatBaseInfoRecord(WorkRecord); + //ɨϢ + CreatScanDataRecord(WorkRecord); + //ǰRecipe Ϣ + CreatRecipeRecord(WorkRecord); +} +//ϢRecord +void CWorkRecordMgr::CreatBaseInfoRecord(CWorkRecord &WorkRecord) +{ + +} +//ɨϢRecord (ʾϸб) +void CWorkRecordMgr::CreatScanDataRecord(CWorkRecord &WorkRecord) +{ + +} +//ǰRecipe ϢRecord +void CWorkRecordMgr::CreatRecipeRecord(CWorkRecord &WorkRecord) +{ + CRecipe Recipe = gRecipeMgr->GetCurWorkRecipe(); + vector &RecipeParVec = Recipe.GetRecipeParVec(); + int size = RecipeParVec.size(); + for(int i=0;i>RecordCnt; + } + } + RecordCnt++;//Ӽ¼ + //׷ӵķʽдļ + { + CFile file(RecordFilePath,CFile::modeWrite|CFile::modeNoTruncate|CFile::modeCreate); + file.SeekToEnd(); + CArchive ar(&file,CArchive::store); + if(!bFileExist)//һд + ar<&RecordParVec = WorkRecord.m_RecordParVec; + int ParCnt = RecordParVec.size(); + ar<>RecordCnt; + for(int k=0;k>ParCnt;// + for(int i=0;i>RecordPar.m_ParName;// + ar>>RecordPar.m_ParVal;//ֵ + Record.AddRecordPar(RecordPar); + } + //ͬReadWorkRecord WorkRecord (洢IJڲһ) + SynchWorkRecord(WorkRecord,Record); + m_ShowRecordVec.push_back(WorkRecord); + m_WorkRecordVec.push_back(Record); + } + } +} +//ͬReadWorkRecord WorkRecord +void CWorkRecordMgr::SynchWorkRecord(CWorkRecord &Record,CWorkRecord &ReadRecord) +{ + vector&RecordParVec = Record.m_RecordParVec; + vector&ReadRecordParVec = ReadRecord.m_RecordParVec; + int ParCnt = RecordParVec.size(); + for(int k=0;k &DateVec,CString StartDate,CString EndDate) +{ + vector AllDateVec; + CString FullFilePath; + CFileMgr FileMgr; + CString WorkRecordFilePath = gProgramLaserTuiHuo->GetWorkRecordFilePath(); + if(WorkRecordFilePath=="") + { + CString FilePath = RECORD_FILE_PATH; + FilePath += "\\"; + FileMgr.GetFullFilePath(FullFilePath,FilePath); + } + else + { + FullFilePath = WorkRecordFilePath+"\\"; + } + FileMgr.GetChildFileOrDirName(false,FullFilePath,AllDateVec,".rcd"); + + + int size = AllDateVec.size(); + for(int k=0;k=StartDate && DateStr<=EndDate) + DateVec.push_back(DateStr); + } +} +#endif +#if 1 +//ʼ¼list +void CWorkRecordMgr::InitWorkRecordList(CListCtrl &List) +{ + //÷ + List.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES); + CWorkRecord WorkRecord; + //бʾWorkRecord + CreatListShowWorkRecord(WorkRecord); + + int idx = 0; + List.InsertColumn(idx++,"",LVCFMT_CENTER,50,-1); + vector&RecordParVec = WorkRecord.m_RecordParVec; + int ParCnt = RecordParVec.size(); + for(int k=0;kWriteDebugLog(log); + + vector DateVec; + GetAllRecordNameVec(DateVec,StartDate,EndDate); + + int size = DateVec.size(); + int MaxWorkRecodCnt = gLogMgr->GetMaxWorkRecodCnt(); + if(size>MaxWorkRecodCnt) + { + CString s; + s.Format("ѯ¼%ld %ld",size,MaxWorkRecodCnt); + CMsgBox MsgBox; + MsgBox.Show(s); + return; + } + List.DeleteAllItems(); + m_ShowRecordVec.clear(); + m_WorkRecordVec.clear(); + for(int k=0;k &WorkRecordVec) +{ + int size = WorkRecordVec.size(); + for(int i=0;i &RecordParVec = WorkRecordVec[i].m_RecordParVec; + int ParCnt = RecordParVec.size(); + for(int k=0;k= RecordCnt) + return; + SetbSelWorkInfoRecord(true); + + CWorkRecord &WorkRecord = m_WorkInfoRecord; + //бʾWorkRecord + CreatListWorkInfoRecord(WorkRecord);//ֻǴһյWorkRecord + CWorkRecord &SelRecord = m_WorkRecordVec[Idx]; + //¼SelRecord ֵͬWorkRecord + //ΪWorkRecord ܻ + SynchWorkRecord(WorkRecord,SelRecord); + + vector &RecordParVec = WorkRecord.m_RecordParVec; + int size = RecordParVec.size(); + for(int i=0;iWriteDebugLog("Func---->OnBnClickedRecoverFormRcd"); + CMsgBox MsgBox; + if(gProgramLaserTuiHuo->IsbAutoWorking()) + { + gLogMgr->WriteDebugLog("ӹв!"); + return; + } + if(!gAuthorityMgr->CheckAuthority(_Authority_Engineer,true)) + return; + + if(!m_bSelWorkInfoRecord) + { + MsgBox.Show("ѡҪָļ¼!"); + return; + } + + if(!MsgBox.ConfirmOkCancel("ѡм¼ָrecipe ?")) + return; + int EndScanIdx = 0;//ɨʱ + int TotalScanIdx = 0;//ɨ + + CRecipe RecordRecipe; + //record recipe + vector &RecordParVec = m_WorkInfoRecord.m_RecordParVec; + int size = RecordParVec.size(); + for(int k=0;k&RecipeParVec = RecordRecipe.GetRecipeParVec(); + int size1 = RecipeParVec.size(); + for(int i=0;iGetRecoverScanIdxAdjust(); + } + } + gObjFillMgr.SetStartFillIdx(StartFillIdx); + CString log; + log.Format("EndScanIdx = %d,TotalScanIdx = %d,StartFillIdx = %d",EndScanIdx,TotalScanIdx,StartFillIdx); + gLogMgr->WriteDebugLog(log); + //ɨ״̬ + gWorkRecordMgr->ResetScanState(); + //õǰõrecipe + gRecipeMgr->SetCurWorkRecipe(RecordRecipe); + + gObjFillMgr.SetStartFillIdx(0); +} +//ѡеļӹ¼txt ļ +void CWorkRecordMgr::SelWrokRecordToFile() +{ + gLogMgr->WriteDebugLog("Func---->SelWrokRecordToFile"); + CMsgBox MsgBox; + if(!gAuthorityMgr->CheckAuthority(_Authority_Engineer,true)) + return; + int RcdCnt = m_WorkRecordVec.size(); + if(RcdCnt<=0) + { + CMsgBox MsgBox; + MsgBox.Show("ûҪļ¼!"); + return; + } + TCHAR szFilters[]=("TXT ļ(*.txt)|*.txt"); + CString FileName("WrokRecord_"); + FileName += gWorkTime.GetDateTime("_","_"); + CFileDialog dlg(FALSE,("txt"),FileName,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilters); + CString Path = "E:\\";//Ĭ· + dlg.m_ofn.lpstrInitialDir = Path; + if(dlg.DoModal()==IDOK) + { + ofstream FileStream; + FileStream.open(dlg.GetPathName()); + + for(int k=0;k &RecordParVec = WorkRecord.m_RecordParVec; + int size = RecordParVec.size(); + for(int i=0;i m_RecordParVec;// +}; + +//¼ +class CWorkRecordMgr :public CModule,public CSubject +{ +public: + CWorkRecordMgr(void); + ~CWorkRecordMgr(void); + virtual MODULE GetModuleType(){return _WORK_RECORD_PROP;}; + virtual void OnAppInitialize(); + void StartRecord(); + void EndRecord(); + void EndRecordTime(); + CString GetCurRecordTime(){return m_CurProcessingTime;}; + CString GetTotalWorkTime(){return m_CurTotalWorkTime;}; + void UpdateCurRecordTime(); + void InsertRecordList(CListCtrl &List,CString StartDate,CString EndDate); + void SaveCurWorkRecord(); + void ReadWorkRecord(CString RecordFilePath); + void GetAllRecordNameVec(vector &DateVec,CString StartDate,CString EndDate); + void InitWorkRecordList(CListCtrl &List); + void ResetScanState(); + CScanState &GetCurScanState(){return m_CurScanState;}; + EScanStateType GetCurScanStateType(); + void InitWorkRecordInfoList(CListCtrl &List); + void InsertRecordInfoList(CListCtrl &List,int Idx); + void IncScanedLineCnt(){m_CurScanState.m_ScanedLineCnt++;};//Ѿɨߵ + void RecoverRecipeByRecord(); + void SetbSelWorkInfoRecord(bool b){m_bSelWorkInfoRecord = b;}; + void SelWrokRecordToFile(); +private: + CString GetCurRecordFileName(); + CString GetRecordFilePath(CString FileName); + void InsertRecordListExt(CListCtrl &List,vector &WorkRecordVec); + void CreatCurWorkRecord(CWorkRecord &WorkRecord); + void WriteWorkRecordToFile(CWorkRecord &WorkRecord); + void CreatBaseInfoRecord(CWorkRecord &WorkRecord); + void CreatScanDataRecord(CWorkRecord &WorkRecord); + void CreatRecipeRecord(CWorkRecord &WorkRecord); + void CreatListShowWorkRecord(CWorkRecord &WorkRecord); + void CreatListWorkInfoRecord(CWorkRecord &WorkRecord); + void SynchWorkRecord(CWorkRecord &WorkRecord,CWorkRecord &ReadWorkRecord); + void SetRecipeRecordReport(CString ParName,CString ParVal); +private: + CWorkTime m_WorkTime;//ӹʱ¼ + CString m_WorkStartTime;//ӹʼʱ + CString m_CurProcessingTime;//ǰԲĹʱ + CString m_CurTotalWorkTime;//ǰܵļӹʱ + + CString m_CurRecordTimeSecond;//ǰӹʱ() + CScanState m_CurScanState;//ǰɨ״̬ + vector m_ShowRecordVec;//ǰʾļ¼ + vector m_WorkRecordVec;//ǰʾļ¼ + + bool m_bSelWorkInfoRecord;//Ƿѡеļ¼ + CWorkRecord m_WorkInfoRecord;//ϸϢrecord +}; + +extern CWorkRecordMgr *gWorkRecordMgr; diff --git a/LaipuDrawing/WorkTime.cpp b/LaipuDrawing/WorkTime.cpp new file mode 100644 index 0000000..d50f35c --- /dev/null +++ b/LaipuDrawing/WorkTime.cpp @@ -0,0 +1,224 @@ +#include "StdAfx.h" +#include "WorkTime.h" + +CWorkTime gWorkTime; +CWorkTime::CWorkTime(void) +{ + m_bRecordTime = false;//Ƿڼʱ + m_BackTime1Seconds = 0;//ʱ + m_BackTime2Seconds = 0;//ʱ + m_bBackTime1End = false;//ʱ1 ǷжϹ +} +CWorkTime::~CWorkTime(void) +{ +} +CString CWorkTime::Int2Str_LeftZero(int n) +{ + CString s; + if(n<10) + s.Format("0%ld",n);//߲0 + else + s.Format("%ld",n); + return s; +} +#if 1//Լʱ +//ʼʱ +void CWorkTime::StartRecordTime() +{ + m_bRecordTime = true; + m_StartTime=CTime::GetCurrentTime(); +} +void CWorkTime::StopRecordTime() +{ + m_bRecordTime = false; +} +CString CWorkTime::GetTimeSpanStr() +{ + if(!m_bRecordTime) + { + return ""; + } + //ȡǰϵͳʱ + CTime CurTime; + CTimeSpan TimeSpan;//ʱ + CurTime=CTime::GetCurrentTime(); + TimeSpan = CurTime - m_StartTime; + return GetTimeSpanStr(TimeSpan); +} +//ǰ˶ +double CWorkTime::GetTimeSpanSecond() +{ + CTimeSpan TimeSpan = GetTimeSpan(); + int s = 0; + s += TimeSpan.GetHours() * 60 * 60; + s += TimeSpan.GetMinutes() * 60; + s += TimeSpan.GetSeconds(); + return s; +} +CTimeSpan CWorkTime::GetTimeSpan() +{ + //ȡǰϵͳʱ + CTime CurTime; + CTimeSpan TimeSpan;//ʱ + CurTime=CTime::GetCurrentTime(); + TimeSpan = CurTime - m_StartTime; + return TimeSpan; +} +//ȡǰʱ +CString CWorkTime::GetTimeSpanStr(CTimeSpan &TimeSpan) +{ + return Int2Str_LeftZero(TimeSpan.GetHours())+":"+Int2Str_LeftZero(TimeSpan.GetMinutes())+":"+Int2Str_LeftZero(TimeSpan.GetSeconds()); +} + +//ȡַ"12:02:25" +CString CWorkTime::GetCurDate(CString Separator) +{ + CString str; + CTime CurTime; + CurTime=CTime::GetCurrentTime(); + + str += Int2Str_LeftZero(CurTime.GetYear())+Separator; + str += Int2Str_LeftZero(CurTime.GetMonth())+Separator; + str += Int2Str_LeftZero(CurTime.GetDay()); + return str; +} +//ȡǰ +CString CWorkTime::GetCurYear() +{ + CString str; + CTime CurTime; + CurTime=CTime::GetCurrentTime(); + str += Int2Str_LeftZero(CurTime.GetYear()); + return str; +} +//ȡǰ +CString CWorkTime::GetCurMonth() +{ + CString str; + CTime CurTime; + CurTime=CTime::GetCurrentTime(); + str += Int2Str_LeftZero(CurTime.GetMonth()); + return str; +} +CString CWorkTime::GetCurDay() +{ + CString str; + CTime CurTime; + CurTime=CTime::GetCurrentTime(); + str += Int2Str_LeftZero(CurTime.GetDay()); + return str; +} +//ȡǰʱSeparator Ϊָ +CString CWorkTime::GetCurTime(CString Separator) +{ + CString str; + CTime CurTime; + CurTime=CTime::GetCurrentTime(); + + str += Int2Str_LeftZero(CurTime.GetHour())+Separator; + str += Int2Str_LeftZero(CurTime.GetMinute())+Separator; + str += Int2Str_LeftZero(CurTime.GetSecond()); + + return str; +} +CString CWorkTime::GetDateTime(CString SeparatorDate,CString SeparatorTime) +{ + CString CurDate = GetCurDate(SeparatorDate); + CString CurTime = GetCurTime(SeparatorTime); + CString DateTime = CurDate + SeparatorDate + CurTime; + return DateTime; +} +CString CWorkTime::GetDateStr(CTime Time,CString Separator) +{ + CString str; + str += Int2Str_LeftZero(Time.GetYear())+Separator; + str += Int2Str_LeftZero(Time.GetMonth())+Separator; + str += Int2Str_LeftZero(Time.GetDay()); + return str; +} +//ǰ˶ٷ +int CWorkTime::GetTimeSpanMin(CTimeSpan &TimeSpan) +{ + int m = 0; + m += TimeSpan.GetHours()*60; + m += TimeSpan.GetMinutes(); + return m; +} +#endif +#if 1//ȷʱ +//ʼȷʱ +void CWorkTime::StartExactTime() +{ + QueryPerformanceCounter(&m_ExactStart); +} + +#endif +#if 1//ʱ +//ʼʱ(Time2 ֮Žʱ) +void CWorkTime::StartBackTime(double Time1,double Time2) +{ + m_BackTime1Seconds = Time1; + m_BackTime2Seconds = Time2; + m_bBackTime1End = false;//ʱ1 ǷжϹ + StartRecordTime(); +} +//ȡʣʱ +CString CWorkTime::GetLeftTimes() +{ + double CurSeconds = GetTimeSpanSecond();//ǰ + int LeftSeconds = (int)(m_BackTime2Seconds-CurSeconds); + CString str = "00:00:00"; + if(LeftSeconds>0) + { + int Seconds = LeftSeconds % 60; + LeftSeconds -= Seconds; + int Minutes = (LeftSeconds%3600)/60; + LeftSeconds -= Minutes*60; + int Hours = LeftSeconds/3600; + str = Int2Str_LeftZero(Hours)+":"+Int2Str_LeftZero(Minutes)+":"+Int2Str_LeftZero(Seconds); + } + return str; +} +//ʱǷ(idx == 1 idx == 2) +bool CWorkTime::IsBackTimeEnd(int idx) +{ + if(!m_bRecordTime)//Ѿ + return true; + if(idx==1 && m_bBackTime1End)//֤ʱ1 ֻһ + return false; + double CurSeconds = GetTimeSpanSecond();//ǰ + double BackTimeSeconds = (idx==1)?m_BackTime1Seconds:m_BackTime2Seconds; + if(CurSeconds > BackTimeSeconds) + { + if(idx==2) + { + m_bRecordTime = false;//ʱ + } + else + { + m_bBackTime1End = true; + } + return true; + } + return false; +} +#endif +//΢뼶ʱusΪ΢ +void CWorkTime::DelayTime(unsigned int us) +{ + if(us>0) + { + LARGE_INTEGER ClockFre; + QueryPerformanceFrequency(&ClockFre); + + LARGE_INTEGER start, end; + LONGLONG count = (us*ClockFre.QuadPart)/(1000*1000); + QueryPerformanceCounter(&start); + count = count + start.QuadPart ; + do + { + QueryPerformanceCounter(&end); + }while(end.QuadPart +//camera +bool grab(unsigned char *buf, int &w, int &h, int &Cross1x,int &Cross1y,int &Cross2x,int &Cross2y,int &byte_width); +bool initialize(); +void destruct(); +void showCrossBar(bool show); +int findFeatures(unsigned char *buf, int w, int h, int byte_width, + int gray2bw_thresh, + int findCircles, double *cx, double *cy, double *r, int nCircle, + int findCorners, double *lx, double *ly, int nCorners); +#ifdef __cplusplus +} +#endif + +#endif /* __circle_core_shape_h__ */ diff --git a/LaipuDrawing/excel.cpp b/LaipuDrawing/excel.cpp new file mode 100644 index 0000000..1e6ce02 --- /dev/null +++ b/LaipuDrawing/excel.cpp @@ -0,0 +1,57144 @@ +// Machine generated IDispatch wrapper class(es) created with ClassWizard + +#include "stdafx.h" +#include "excel.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + + +///////////////////////////////////////////////////////////////////////////// +// Adjustments properties + +///////////////////////////////////////////////////////////////////////////// +// Adjustments operations + +LPDISPATCH Adjustments::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Adjustments::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Adjustments::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Adjustments::GetCount() +{ + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float Adjustments::GetItem(long Index) +{ + float result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, parms, + Index); + return result; +} + +void Adjustments::SetItem(long Index, float newValue) +{ + static BYTE parms[] = + VTS_I4 VTS_R4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + Index, newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// CalloutFormat properties + +///////////////////////////////////////////////////////////////////////////// +// CalloutFormat operations + +LPDISPATCH CalloutFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CalloutFormat::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalloutFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void CalloutFormat::AutomaticLength() +{ + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void CalloutFormat::CustomDrop(float Drop) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Drop); +} + +void CalloutFormat::CustomLength(float Length) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Length); +} + +void CalloutFormat::PresetDrop(long DropType) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + DropType); +} + +long CalloutFormat::GetAccent() +{ + long result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CalloutFormat::SetAccent(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long CalloutFormat::GetAngle() +{ + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CalloutFormat::SetAngle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long CalloutFormat::GetAutoAttach() +{ + long result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CalloutFormat::SetAutoAttach(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long CalloutFormat::GetAutoLength() +{ + long result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long CalloutFormat::GetBorder() +{ + long result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CalloutFormat::SetBorder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float CalloutFormat::GetDrop() +{ + float result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +long CalloutFormat::GetDropType() +{ + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float CalloutFormat::GetGap() +{ + float result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void CalloutFormat::SetGap(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float CalloutFormat::GetLength() +{ + float result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +long CalloutFormat::GetType() +{ + long result; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CalloutFormat::SetType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ColorFormat properties + +///////////////////////////////////////////////////////////////////////////// +// ColorFormat operations + +LPDISPATCH ColorFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ColorFormat::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ColorFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ColorFormat::GetRgb() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ColorFormat::SetRgb(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ColorFormat::GetSchemeColor() +{ + long result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ColorFormat::SetSchemeColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ColorFormat::GetType() +{ + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float ColorFormat::GetTintAndShade() +{ + float result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ColorFormat::SetTintAndShade(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// LineFormat properties + +///////////////////////////////////////////////////////////////////////////// +// LineFormat operations + +LPDISPATCH LineFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long LineFormat::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH LineFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH LineFormat::GetBackColor() +{ + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void LineFormat::SetBackColor(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long LineFormat::GetBeginArrowheadLength() +{ + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetBeginArrowheadLength(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LineFormat::GetBeginArrowheadStyle() +{ + long result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetBeginArrowheadStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LineFormat::GetBeginArrowheadWidth() +{ + long result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetBeginArrowheadWidth(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LineFormat::GetDashStyle() +{ + long result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetDashStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LineFormat::GetEndArrowheadLength() +{ + long result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetEndArrowheadLength(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LineFormat::GetEndArrowheadStyle() +{ + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetEndArrowheadStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LineFormat::GetEndArrowheadWidth() +{ + long result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetEndArrowheadWidth(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH LineFormat::GetForeColor() +{ + LPDISPATCH result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void LineFormat::SetForeColor(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long LineFormat::GetPattern() +{ + long result; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetPattern(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LineFormat::GetStyle() +{ + long result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float LineFormat::GetTransparency() +{ + float result; + InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetTransparency(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long LineFormat::GetVisible() +{ + long result; + InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float LineFormat::GetWeight() +{ + float result; + InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void LineFormat::SetWeight(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ShapeNode properties + +///////////////////////////////////////////////////////////////////////////// +// ShapeNode operations + +LPDISPATCH ShapeNode::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeNode::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeNode::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeNode::GetEditingType() +{ + long result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT ShapeNode::GetPoints() +{ + VARIANT result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long ShapeNode::GetSegmentType() +{ + long result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ShapeNodes properties + +///////////////////////////////////////////////////////////////////////////// +// ShapeNodes operations + +LPDISPATCH ShapeNodes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeNodes::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeNodes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeNodes::GetCount() +{ + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeNodes::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ShapeNodes::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void ShapeNodes::Delete(long Index) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Index); +} + +void ShapeNodes::Insert(long Index, long SegmentType, long EditingType, float X1, float Y1, float X2, float Y2, float X3, float Y3) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Index, SegmentType, EditingType, X1, Y1, X2, Y2, X3, Y3); +} + +void ShapeNodes::SetEditingType(long Index, long EditingType) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Index, EditingType); +} + +void ShapeNodes::SetPosition(long Index, float X1, float Y1) +{ + static BYTE parms[] = + VTS_I4 VTS_R4 VTS_R4; + InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Index, X1, Y1); +} + +void ShapeNodes::SetSegmentType(long Index, long SegmentType) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Index, SegmentType); +} + + +///////////////////////////////////////////////////////////////////////////// +// PictureFormat properties + +///////////////////////////////////////////////////////////////////////////// +// PictureFormat operations + +LPDISPATCH PictureFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PictureFormat::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PictureFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void PictureFormat::IncrementBrightness(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void PictureFormat::IncrementContrast(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +float PictureFormat::GetBrightness() +{ + float result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetBrightness(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long PictureFormat::GetColorType() +{ + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetColorType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float PictureFormat::GetContrast() +{ + float result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetContrast(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float PictureFormat::GetCropBottom() +{ + float result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetCropBottom(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float PictureFormat::GetCropLeft() +{ + float result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetCropLeft(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float PictureFormat::GetCropRight() +{ + float result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetCropRight(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float PictureFormat::GetCropTop() +{ + float result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetCropTop(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long PictureFormat::GetTransparencyColor() +{ + long result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetTransparencyColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long PictureFormat::GetTransparentBackground() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PictureFormat::SetTransparentBackground(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ShadowFormat properties + +///////////////////////////////////////////////////////////////////////////// +// ShadowFormat operations + +LPDISPATCH ShadowFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShadowFormat::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShadowFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ShadowFormat::IncrementOffsetX(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void ShadowFormat::IncrementOffsetY(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +LPDISPATCH ShadowFormat::GetForeColor() +{ + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ShadowFormat::SetForeColor(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ShadowFormat::GetObscured() +{ + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ShadowFormat::SetObscured(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float ShadowFormat::GetOffsetX() +{ + float result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ShadowFormat::SetOffsetX(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float ShadowFormat::GetOffsetY() +{ + float result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ShadowFormat::SetOffsetY(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float ShadowFormat::GetTransparency() +{ + float result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ShadowFormat::SetTransparency(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ShadowFormat::GetType() +{ + long result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ShadowFormat::SetType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ShadowFormat::GetVisible() +{ + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ShadowFormat::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// TextEffectFormat properties + +///////////////////////////////////////////////////////////////////////////// +// TextEffectFormat operations + +LPDISPATCH TextEffectFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long TextEffectFormat::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextEffectFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::ToggleVerticalText() +{ + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long TextEffectFormat::GetAlignment() +{ + long result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetAlignment(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long TextEffectFormat::GetFontBold() +{ + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetFontBold(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long TextEffectFormat::GetFontItalic() +{ + long result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetFontItalic(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString TextEffectFormat::GetFontName() +{ + CString result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetFontName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +float TextEffectFormat::GetFontSize() +{ + float result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetFontSize(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long TextEffectFormat::GetKernedPairs() +{ + long result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetKernedPairs(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long TextEffectFormat::GetNormalizedHeight() +{ + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetNormalizedHeight(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long TextEffectFormat::GetPresetShape() +{ + long result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetPresetShape(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long TextEffectFormat::GetPresetTextEffect() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetPresetTextEffect(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long TextEffectFormat::GetRotatedChars() +{ + long result; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetRotatedChars(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString TextEffectFormat::GetText() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +float TextEffectFormat::GetTracking() +{ + float result; + InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void TextEffectFormat::SetTracking(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ThreeDFormat properties + +///////////////////////////////////////////////////////////////////////////// +// ThreeDFormat operations + +LPDISPATCH ThreeDFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ThreeDFormat::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ThreeDFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::IncrementRotationX(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void ThreeDFormat::IncrementRotationY(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void ThreeDFormat::ResetRotation() +{ + InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ThreeDFormat::SetThreeDFormat(long PresetThreeDFormat) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + PresetThreeDFormat); +} + +void ThreeDFormat::SetExtrusionDirection(long PresetExtrusionDirection) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + PresetExtrusionDirection); +} + +float ThreeDFormat::GetDepth() +{ + float result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetDepth(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH ThreeDFormat::GetExtrusionColor() +{ + LPDISPATCH result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ThreeDFormat::GetExtrusionColorType() +{ + long result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetExtrusionColorType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ThreeDFormat::GetPerspective() +{ + long result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetPerspective(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ThreeDFormat::GetPresetExtrusionDirection() +{ + long result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ThreeDFormat::GetPresetLightingDirection() +{ + long result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetPresetLightingDirection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ThreeDFormat::GetPresetLightingSoftness() +{ + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetPresetLightingSoftness(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ThreeDFormat::GetPresetMaterial() +{ + long result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetPresetMaterial(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ThreeDFormat::GetPresetThreeDFormat() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float ThreeDFormat::GetRotationX() +{ + float result; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetRotationX(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float ThreeDFormat::GetRotationY() +{ + float result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetRotationY(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ThreeDFormat::GetVisible() +{ + long result; + InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ThreeDFormat::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// FillFormat properties + +///////////////////////////////////////////////////////////////////////////// +// FillFormat operations + +LPDISPATCH FillFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long FillFormat::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH FillFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void FillFormat::OneColorGradient(long Style, long Variant, float Degree) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_R4; + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Style, Variant, Degree); +} + +void FillFormat::Patterned(long Pattern) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Pattern); +} + +void FillFormat::PresetGradient(long Style, long Variant, long PresetGradientType) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Style, Variant, PresetGradientType); +} + +void FillFormat::PresetTextured(long PresetTexture) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + PresetTexture); +} + +void FillFormat::Solid() +{ + InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void FillFormat::TwoColorGradient(long Style, long Variant) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Style, Variant); +} + +void FillFormat::UserPicture(LPCTSTR PictureFile) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + PictureFile); +} + +void FillFormat::UserTextured(LPCTSTR TextureFile) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + TextureFile); +} + +LPDISPATCH FillFormat::GetBackColor() +{ + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void FillFormat::SetBackColor(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH FillFormat::GetForeColor() +{ + LPDISPATCH result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void FillFormat::SetForeColor(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long FillFormat::GetGradientColorType() +{ + long result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float FillFormat::GetGradientDegree() +{ + float result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +long FillFormat::GetGradientStyle() +{ + long result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long FillFormat::GetGradientVariant() +{ + long result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long FillFormat::GetPattern() +{ + long result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long FillFormat::GetPresetGradientType() +{ + long result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long FillFormat::GetPresetTexture() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString FillFormat::GetTextureName() +{ + CString result; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long FillFormat::GetTextureType() +{ + long result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float FillFormat::GetTransparency() +{ + float result; + InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void FillFormat::SetTransparency(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long FillFormat::GetType() +{ + long result; + InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long FillFormat::GetVisible() +{ + long result; + InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void FillFormat::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// DiagramNodes properties + +///////////////////////////////////////////////////////////////////////////// +// DiagramNodes operations + +LPDISPATCH DiagramNodes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DiagramNodes::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPUNKNOWN DiagramNodes::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNodes::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void DiagramNodes::SelectAll() +{ + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH DiagramNodes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DiagramNodes::GetCount() +{ + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DiagramNodeChildren properties + +///////////////////////////////////////////////////////////////////////////// +// DiagramNodeChildren operations + +LPDISPATCH DiagramNodeChildren::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DiagramNodeChildren::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPUNKNOWN DiagramNodeChildren::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNodeChildren::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH DiagramNodeChildren::AddNode(const VARIANT& Index, long nodeType) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_I4; + InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index, nodeType); + return result; +} + +void DiagramNodeChildren::SelectAll() +{ + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH DiagramNodeChildren::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DiagramNodeChildren::GetCount() +{ + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNodeChildren::GetFirstChild() +{ + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNodeChildren::GetLastChild() +{ + LPDISPATCH result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DiagramNode properties + +///////////////////////////////////////////////////////////////////////////// +// DiagramNode operations + +LPDISPATCH DiagramNode::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x60020000, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DiagramNode::GetCreator() +{ + long result; + InvokeHelper(0x60020001, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNode::AddNode(long pos, long nodeType) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + pos, nodeType); + return result; +} + +void DiagramNode::Delete() +{ + InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void DiagramNode::MoveNode(LPDISPATCH pTargetNode, long pos) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + pTargetNode, pos); +} + +void DiagramNode::ReplaceNode(LPDISPATCH pTargetNode) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + pTargetNode); +} + +void DiagramNode::SwapNode(LPDISPATCH pTargetNode, BOOL swapChildren) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_BOOL; + InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + pTargetNode, swapChildren); +} + +LPDISPATCH DiagramNode::CloneNode(BOOL copyChildren, LPDISPATCH pTargetNode, long pos) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BOOL VTS_DISPATCH VTS_I4; + InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + copyChildren, pTargetNode, pos); + return result; +} + +void DiagramNode::TransferChildren(LPDISPATCH pReceivingNode) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + pReceivingNode); +} + +LPDISPATCH DiagramNode::NextNode() +{ + LPDISPATCH result; + InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNode::PrevNode() +{ + LPDISPATCH result; + InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNode::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNode::GetChildren() +{ + LPDISPATCH result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNode::GetShape() +{ + LPDISPATCH result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNode::GetRoot() +{ + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DiagramNode::GetDiagram() +{ + LPDISPATCH result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DiagramNode::GetLayout() +{ + long result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DiagramNode::SetLayout(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH DiagramNode::GetTextShape() +{ + LPDISPATCH result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// IRTDUpdateEvent properties + +///////////////////////////////////////////////////////////////////////////// +// IRTDUpdateEvent operations + +void IRTDUpdateEvent::UpdateNotify() +{ + InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long IRTDUpdateEvent::GetHeartbeatInterval() +{ + long result; + InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void IRTDUpdateEvent::SetHeartbeatInterval(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void IRTDUpdateEvent::Disconnect() +{ + InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// IRtdServer properties + +///////////////////////////////////////////////////////////////////////////// +// IRtdServer operations + +long IRtdServer::ServerStart(LPDISPATCH CallbackObject) +{ + long result; + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0xa, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + CallbackObject); + return result; +} + +void IRtdServer::DisconnectData(long TopicID) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + TopicID); +} + +long IRtdServer::Heartbeat() +{ + long result; + InvokeHelper(0xe, DISPATCH_METHOD, VT_I4, (void*)&result, NULL); + return result; +} + +void IRtdServer::ServerTerminate() +{ + InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// _Application properties + +///////////////////////////////////////////////////////////////////////////// +// _Application operations + +LPDISPATCH _Application::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Application::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetActiveCell() +{ + LPDISPATCH result; + InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetActiveChart() +{ + LPDISPATCH result; + InvokeHelper(0xb7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString _Application::GetActivePrinter() +{ + CString result; + InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetActivePrinter(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH _Application::GetActiveSheet() +{ + LPDISPATCH result; + InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetActiveWindow() +{ + LPDISPATCH result; + InvokeHelper(0x2f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetActiveWorkbook() +{ + LPDISPATCH result; + InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetAddIns() +{ + LPDISPATCH result; + InvokeHelper(0x225, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetAssistant() +{ + LPDISPATCH result; + InvokeHelper(0x59e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Application::Calculate() +{ + InvokeHelper(0x117, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Application::GetCells() +{ + LPDISPATCH result; + InvokeHelper(0xee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetCharts() +{ + LPDISPATCH result; + InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetColumns() +{ + LPDISPATCH result; + InvokeHelper(0xf1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetCommandBars() +{ + LPDISPATCH result; + InvokeHelper(0x59f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Application::GetDDEAppReturnCode() +{ + long result; + InvokeHelper(0x14c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::DDEExecute(long Channel, LPCTSTR String) +{ + static BYTE parms[] = + VTS_I4 VTS_BSTR; + InvokeHelper(0x14d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Channel, String); +} + +long _Application::DDEInitiate(LPCTSTR App, LPCTSTR Topic) +{ + long result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR; + InvokeHelper(0x14e, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + App, Topic); + return result; +} + +void _Application::DDEPoke(long Channel, const VARIANT& Item, const VARIANT& Data) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x14f, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Channel, &Item, &Data); +} + +VARIANT _Application::DDERequest(long Channel, LPCTSTR Item) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_BSTR; + InvokeHelper(0x150, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Channel, Item); + return result; +} + +void _Application::DDETerminate(long Channel) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x151, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Channel); +} + +VARIANT _Application::Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +VARIANT _Application::_Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +VARIANT _Application::ExecuteExcel4Macro(LPCTSTR String) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x15e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + String); + return result; +} + +LPDISPATCH _Application::Intersect(LPDISPATCH Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2fe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Arg1, Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH _Application::GetNames() +{ + LPDISPATCH result; + InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetRange(const VARIANT& Cell1, const VARIANT& Cell2) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Cell1, &Cell2); + return result; +} + +LPDISPATCH _Application::GetRows() +{ + LPDISPATCH result; + InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT _Application::Run(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, + const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, + const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, + const VARIANT& Arg30) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x103, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Macro, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +VARIANT _Application::_Run2(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, + const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, + const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, + const VARIANT& Arg30) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x326, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Macro, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH _Application::GetSelection() +{ + LPDISPATCH result; + InvokeHelper(0x93, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Application::SendKeys(const VARIANT& Keys, const VARIANT& Wait) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x17f, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Keys, &Wait); +} + +LPDISPATCH _Application::GetSheets() +{ + LPDISPATCH result; + InvokeHelper(0x1e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetThisWorkbook() +{ + LPDISPATCH result; + InvokeHelper(0x30a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::Union(LPDISPATCH Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x30b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Arg1, Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH _Application::GetWindows() +{ + LPDISPATCH result; + InvokeHelper(0x1ae, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetWorkbooks() +{ + LPDISPATCH result; + InvokeHelper(0x23c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetWorksheetFunction() +{ + LPDISPATCH result; + InvokeHelper(0x5a0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetWorksheets() +{ + LPDISPATCH result; + InvokeHelper(0x1ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetExcel4IntlMacroSheets() +{ + LPDISPATCH result; + InvokeHelper(0x245, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetExcel4MacroSheets() +{ + LPDISPATCH result; + InvokeHelper(0x243, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Application::ActivateMicrosoftApp(long Index) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x447, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Index); +} + +void _Application::AddChartAutoFormat(const VARIANT& Chart, LPCTSTR Name, const VARIANT& Description) +{ + static BYTE parms[] = + VTS_VARIANT VTS_BSTR VTS_VARIANT; + InvokeHelper(0xd8, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Chart, Name, &Description); +} + +void _Application::AddCustomList(const VARIANT& ListArray, const VARIANT& ByRow) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x30c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &ListArray, &ByRow); +} + +BOOL _Application::GetAlertBeforeOverwriting() +{ + BOOL result; + InvokeHelper(0x3a2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetAlertBeforeOverwriting(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString _Application::GetAltStartupPath() +{ + CString result; + InvokeHelper(0x139, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetAltStartupPath(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x139, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL _Application::GetAskToUpdateLinks() +{ + BOOL result; + InvokeHelper(0x3e0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetAskToUpdateLinks(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3e0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetEnableAnimations() +{ + BOOL result; + InvokeHelper(0x49c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetEnableAnimations(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x49c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Application::GetAutoCorrect() +{ + LPDISPATCH result; + InvokeHelper(0x479, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Application::GetBuild() +{ + long result; + InvokeHelper(0x13a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetCalculateBeforeSave() +{ + BOOL result; + InvokeHelper(0x13b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetCalculateBeforeSave(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x13b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetCalculation() +{ + long result; + InvokeHelper(0x13c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetCalculation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x13c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT _Application::GetCaller(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x13d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +BOOL _Application::GetCanPlaySounds() +{ + BOOL result; + InvokeHelper(0x13e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetCanRecordSounds() +{ + BOOL result; + InvokeHelper(0x13f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +CString _Application::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL _Application::GetCellDragAndDrop() +{ + BOOL result; + InvokeHelper(0x140, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetCellDragAndDrop(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x140, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double _Application::CentimetersToPoints(double Centimeters) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x43e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Centimeters); + return result; +} + +BOOL _Application::CheckSpelling(LPCTSTR Word, const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase) +{ + BOOL result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + Word, &CustomDictionary, &IgnoreUppercase); + return result; +} + +VARIANT _Application::GetClipboardFormats(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x141, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +BOOL _Application::GetDisplayClipboardWindow() +{ + BOOL result; + InvokeHelper(0x142, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayClipboardWindow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x142, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetCommandUnderlines() +{ + long result; + InvokeHelper(0x143, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetCommandUnderlines(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x143, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Application::GetConstrainNumeric() +{ + BOOL result; + InvokeHelper(0x144, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetConstrainNumeric(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x144, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _Application::ConvertFormula(const VARIANT& Formula, long FromReferenceStyle, const VARIANT& ToReferenceStyle, const VARIANT& ToAbsolute, const VARIANT& RelativeTo) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x145, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Formula, FromReferenceStyle, &ToReferenceStyle, &ToAbsolute, &RelativeTo); + return result; +} + +BOOL _Application::GetCopyObjectsWithCells() +{ + BOOL result; + InvokeHelper(0x3df, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetCopyObjectsWithCells(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3df, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetCursor() +{ + long result; + InvokeHelper(0x489, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetCursor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x489, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _Application::GetCustomListCount() +{ + long result; + InvokeHelper(0x313, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long _Application::GetCutCopyMode() +{ + long result; + InvokeHelper(0x14a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetCutCopyMode(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x14a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _Application::GetDataEntryMode() +{ + long result; + InvokeHelper(0x14b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetDataEntryMode(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x14b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString _Application::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Application::GetDefaultFilePath() +{ + CString result; + InvokeHelper(0x40e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetDefaultFilePath(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x40e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void _Application::DeleteChartAutoFormat(LPCTSTR Name) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xd9, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Name); +} + +void _Application::DeleteCustomList(long ListNum) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x30f, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ListNum); +} + +LPDISPATCH _Application::GetDialogs() +{ + LPDISPATCH result; + InvokeHelper(0x2f9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetDisplayAlerts() +{ + BOOL result; + InvokeHelper(0x157, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayAlerts(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x157, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetDisplayFormulaBar() +{ + BOOL result; + InvokeHelper(0x158, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayFormulaBar(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x158, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetDisplayFullScreen() +{ + BOOL result; + InvokeHelper(0x425, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayFullScreen(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x425, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetDisplayNoteIndicator() +{ + BOOL result; + InvokeHelper(0x159, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayNoteIndicator(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x159, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetDisplayCommentIndicator() +{ + long result; + InvokeHelper(0x4ac, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayCommentIndicator(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4ac, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Application::GetDisplayExcel4Menus() +{ + BOOL result; + InvokeHelper(0x39f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayExcel4Menus(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x39f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetDisplayRecentFiles() +{ + BOOL result; + InvokeHelper(0x39e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayRecentFiles(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x39e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetDisplayScrollBars() +{ + BOOL result; + InvokeHelper(0x15a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayScrollBars(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x15a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetDisplayStatusBar() +{ + BOOL result; + InvokeHelper(0x15b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayStatusBar(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x15b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Application::DoubleClick() +{ + InvokeHelper(0x15d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL _Application::GetEditDirectlyInCell() +{ + BOOL result; + InvokeHelper(0x3a1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetEditDirectlyInCell(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3a1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetEnableAutoComplete() +{ + BOOL result; + InvokeHelper(0x49b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetEnableAutoComplete(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x49b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetEnableCancelKey() +{ + long result; + InvokeHelper(0x448, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetEnableCancelKey(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x448, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Application::GetEnableSound() +{ + BOOL result; + InvokeHelper(0x4ad, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetEnableSound(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4ad, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _Application::GetFileConverters(const VARIANT& Index1, const VARIANT& Index2) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3a3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index1, &Index2); + return result; +} + +LPDISPATCH _Application::GetFileSearch() +{ + LPDISPATCH result; + InvokeHelper(0x4b0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetFileFind() +{ + LPDISPATCH result; + InvokeHelper(0x4b1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetFixedDecimal() +{ + BOOL result; + InvokeHelper(0x15f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetFixedDecimal(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x15f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetFixedDecimalPlaces() +{ + long result; + InvokeHelper(0x160, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetFixedDecimalPlaces(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x160, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT _Application::GetCustomListContents(long ListNum) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x312, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + ListNum); + return result; +} + +long _Application::GetCustomListNum(const VARIANT& ListArray) +{ + long result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x311, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + &ListArray); + return result; +} + +VARIANT _Application::GetOpenFilename(const VARIANT& FileFilter, const VARIANT& FilterIndex, const VARIANT& Title, const VARIANT& ButtonText, const VARIANT& MultiSelect) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x433, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &FileFilter, &FilterIndex, &Title, &ButtonText, &MultiSelect); + return result; +} + +VARIANT _Application::GetSaveAsFilename(const VARIANT& InitialFilename, const VARIANT& FileFilter, const VARIANT& FilterIndex, const VARIANT& Title, const VARIANT& ButtonText) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x434, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &InitialFilename, &FileFilter, &FilterIndex, &Title, &ButtonText); + return result; +} + +void _Application::Goto(const VARIANT& Reference, const VARIANT& Scroll) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1db, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Reference, &Scroll); +} + +double _Application::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _Application::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +void _Application::Help(const VARIANT& HelpFile, const VARIANT& HelpContextID) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x162, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &HelpFile, &HelpContextID); +} + +BOOL _Application::GetIgnoreRemoteRequests() +{ + BOOL result; + InvokeHelper(0x164, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetIgnoreRemoteRequests(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x164, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double _Application::InchesToPoints(double Inches) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x43f, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Inches); + return result; +} + +VARIANT _Application::InputBox(LPCTSTR Prompt, const VARIANT& Title, const VARIANT& Default, const VARIANT& Left, const VARIANT& Top, const VARIANT& HelpFile, const VARIANT& HelpContextID, const VARIANT& Type) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x165, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Prompt, &Title, &Default, &Left, &Top, &HelpFile, &HelpContextID, &Type); + return result; +} + +BOOL _Application::GetInteractive() +{ + BOOL result; + InvokeHelper(0x169, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetInteractive(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x169, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _Application::GetInternational(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x16a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +BOOL _Application::GetIteration() +{ + BOOL result; + InvokeHelper(0x16b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetIteration(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x16b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double _Application::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _Application::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +CString _Application::GetLibraryPath() +{ + CString result; + InvokeHelper(0x16e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::MacroOptions(const VARIANT& Macro, const VARIANT& Description, const VARIANT& HasMenu, const VARIANT& MenuText, const VARIANT& HasShortcutKey, const VARIANT& ShortcutKey, const VARIANT& Category, const VARIANT& StatusBar, + const VARIANT& HelpContextID, const VARIANT& HelpFile) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x46f, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Macro, &Description, &HasMenu, &MenuText, &HasShortcutKey, &ShortcutKey, &Category, &StatusBar, &HelpContextID, &HelpFile); +} + +void _Application::MailLogoff() +{ + InvokeHelper(0x3b1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Application::MailLogon(const VARIANT& Name, const VARIANT& Password, const VARIANT& DownloadNewMail) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3af, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Name, &Password, &DownloadNewMail); +} + +VARIANT _Application::GetMailSession() +{ + VARIANT result; + InvokeHelper(0x3ae, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long _Application::GetMailSystem() +{ + long result; + InvokeHelper(0x3cb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetMathCoprocessorAvailable() +{ + BOOL result; + InvokeHelper(0x16f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +double _Application::GetMaxChange() +{ + double result; + InvokeHelper(0x170, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _Application::SetMaxChange(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x170, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long _Application::GetMaxIterations() +{ + long result; + InvokeHelper(0x171, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetMaxIterations(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x171, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Application::GetMouseAvailable() +{ + BOOL result; + InvokeHelper(0x175, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetMoveAfterReturn() +{ + BOOL result; + InvokeHelper(0x176, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetMoveAfterReturn(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x176, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetMoveAfterReturnDirection() +{ + long result; + InvokeHelper(0x478, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetMoveAfterReturnDirection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x478, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Application::GetRecentFiles() +{ + LPDISPATCH result; + InvokeHelper(0x4b2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString _Application::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::NextLetter() +{ + LPDISPATCH result; + InvokeHelper(0x3cc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString _Application::GetNetworkTemplatesPath() +{ + CString result; + InvokeHelper(0x184, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetODBCErrors() +{ + LPDISPATCH result; + InvokeHelper(0x4b3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Application::GetODBCTimeout() +{ + long result; + InvokeHelper(0x4b4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetODBCTimeout(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4b4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void _Application::OnKey(LPCTSTR Key, const VARIANT& Procedure) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x272, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Key, &Procedure); +} + +void _Application::OnRepeat(LPCTSTR Text, LPCTSTR Procedure) +{ + static BYTE parms[] = + VTS_BSTR VTS_BSTR; + InvokeHelper(0x301, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Text, Procedure); +} + +void _Application::OnTime(const VARIANT& EarliestTime, LPCTSTR Procedure, const VARIANT& LatestTime, const VARIANT& Schedule) +{ + static BYTE parms[] = + VTS_VARIANT VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x270, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EarliestTime, Procedure, &LatestTime, &Schedule); +} + +void _Application::OnUndo(LPCTSTR Text, LPCTSTR Procedure) +{ + static BYTE parms[] = + VTS_BSTR VTS_BSTR; + InvokeHelper(0x302, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Text, Procedure); +} + +CString _Application::GetOnWindow() +{ + CString result; + InvokeHelper(0x26f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetOnWindow(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x26f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _Application::GetOperatingSystem() +{ + CString result; + InvokeHelper(0x177, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Application::GetOrganizationName() +{ + CString result; + InvokeHelper(0x178, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Application::GetPath() +{ + CString result; + InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Application::GetPathSeparator() +{ + CString result; + InvokeHelper(0x179, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT _Application::GetPreviousSelections(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x17a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +BOOL _Application::GetPivotTableSelection() +{ + BOOL result; + InvokeHelper(0x4b5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetPivotTableSelection(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4b5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetPromptForSummaryInfo() +{ + BOOL result; + InvokeHelper(0x426, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetPromptForSummaryInfo(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x426, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Application::Quit() +{ + InvokeHelper(0x12e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Application::RecordMacro(const VARIANT& BasicCode, const VARIANT& XlmCode) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x305, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &BasicCode, &XlmCode); +} + +BOOL _Application::GetRecordRelative() +{ + BOOL result; + InvokeHelper(0x17b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long _Application::GetReferenceStyle() +{ + long result; + InvokeHelper(0x17c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetReferenceStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x17c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT _Application::GetRegisteredFunctions(const VARIANT& Index1, const VARIANT& Index2) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x307, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index1, &Index2); + return result; +} + +BOOL _Application::RegisterXLL(LPCTSTR Filename) +{ + BOOL result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x1e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + Filename); + return result; +} + +void _Application::Repeat() +{ + InvokeHelper(0x12d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL _Application::GetRollZoom() +{ + BOOL result; + InvokeHelper(0x4b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetRollZoom(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Application::SaveWorkspace(const VARIANT& Filename) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd4, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Filename); +} + +BOOL _Application::GetScreenUpdating() +{ + BOOL result; + InvokeHelper(0x17e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetScreenUpdating(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x17e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Application::SetDefaultChart(const VARIANT& FormatName, const VARIANT& Gallery) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xdb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &FormatName, &Gallery); +} + +long _Application::GetSheetsInNewWorkbook() +{ + long result; + InvokeHelper(0x3e1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetSheetsInNewWorkbook(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3e1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Application::GetShowChartTipNames() +{ + BOOL result; + InvokeHelper(0x4b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetShowChartTipNames(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4b7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetShowChartTipValues() +{ + BOOL result; + InvokeHelper(0x4b8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetShowChartTipValues(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4b8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString _Application::GetStandardFont() +{ + CString result; + InvokeHelper(0x39c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetStandardFont(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x39c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +double _Application::GetStandardFontSize() +{ + double result; + InvokeHelper(0x39d, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _Application::SetStandardFontSize(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x39d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +CString _Application::GetStartupPath() +{ + CString result; + InvokeHelper(0x181, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT _Application::GetStatusBar() +{ + VARIANT result; + InvokeHelper(0x182, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _Application::SetStatusBar(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x182, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString _Application::GetTemplatesPath() +{ + CString result; + InvokeHelper(0x17d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetShowToolTips() +{ + BOOL result; + InvokeHelper(0x183, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetShowToolTips(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x183, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double _Application::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _Application::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long _Application::GetDefaultSaveFormat() +{ + long result; + InvokeHelper(0x4b9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetDefaultSaveFormat(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4b9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString _Application::GetTransitionMenuKey() +{ + CString result; + InvokeHelper(0x136, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetTransitionMenuKey(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x136, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long _Application::GetTransitionMenuKeyAction() +{ + long result; + InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetTransitionMenuKeyAction(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x137, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Application::GetTransitionNavigKeys() +{ + BOOL result; + InvokeHelper(0x138, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetTransitionNavigKeys(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x138, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Application::Undo() +{ + InvokeHelper(0x12f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +double _Application::GetUsableHeight() +{ + double result; + InvokeHelper(0x185, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double _Application::GetUsableWidth() +{ + double result; + InvokeHelper(0x186, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetUserControl() +{ + BOOL result; + InvokeHelper(0x4ba, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetUserControl(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4ba, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString _Application::GetUserName_() +{ + CString result; + InvokeHelper(0x187, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetUserName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x187, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _Application::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetVbe() +{ + LPDISPATCH result; + InvokeHelper(0x4bb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString _Application::GetVersion() +{ + CString result; + InvokeHelper(0x188, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Application::Volatile(const VARIANT& Volatile) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x314, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Volatile); +} + +double _Application::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _Application::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL _Application::GetWindowsForPens() +{ + BOOL result; + InvokeHelper(0x18b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long _Application::GetWindowState() +{ + long result; + InvokeHelper(0x18c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetWindowState(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x18c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _Application::GetDefaultSheetDirection() +{ + long result; + InvokeHelper(0xe5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetDefaultSheetDirection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xe5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _Application::GetCursorMovement() +{ + long result; + InvokeHelper(0xe8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetCursorMovement(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xe8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Application::GetControlCharacters() +{ + BOOL result; + InvokeHelper(0xe9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetControlCharacters(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xe9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetEnableEvents() +{ + BOOL result; + InvokeHelper(0x4bc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetEnableEvents(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4bc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::Wait(const VARIANT& Time) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6ea, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Time); + return result; +} + +BOOL _Application::GetExtendList() +{ + BOOL result; + InvokeHelper(0x701, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetExtendList(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x701, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Application::GetOLEDBErrors() +{ + LPDISPATCH result; + InvokeHelper(0x702, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString _Application::GetPhonetic(const VARIANT& Text) +{ + CString result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x703, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + &Text); + return result; +} + +LPDISPATCH _Application::GetCOMAddIns() +{ + LPDISPATCH result; + InvokeHelper(0x704, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetDefaultWebOptions() +{ + LPDISPATCH result; + InvokeHelper(0x705, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString _Application::GetProductCode() +{ + CString result; + InvokeHelper(0x706, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Application::GetUserLibraryPath() +{ + CString result; + InvokeHelper(0x707, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetAutoPercentEntry() +{ + BOOL result; + InvokeHelper(0x708, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetAutoPercentEntry(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x708, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Application::GetLanguageSettings() +{ + LPDISPATCH result; + InvokeHelper(0x709, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetAnswerWizard() +{ + LPDISPATCH result; + InvokeHelper(0x70c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Application::CalculateFull() +{ + InvokeHelper(0x70d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL _Application::FindFile() +{ + BOOL result; + InvokeHelper(0x6eb, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL); + return result; +} + +long _Application::GetCalculationVersion() +{ + long result; + InvokeHelper(0x70e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetShowWindowsInTaskbar() +{ + BOOL result; + InvokeHelper(0x70f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetShowWindowsInTaskbar(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x70f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetFeatureInstall() +{ + long result; + InvokeHelper(0x710, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetFeatureInstall(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x710, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Application::GetReady() +{ + BOOL result; + InvokeHelper(0x78c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetFindFormat() +{ + LPDISPATCH result; + InvokeHelper(0x78e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Application::SetRefFindFormat(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x78e, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH _Application::GetReplaceFormat() +{ + LPDISPATCH result; + InvokeHelper(0x78f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Application::SetRefReplaceFormat(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x78f, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH _Application::GetUsedObjects() +{ + LPDISPATCH result; + InvokeHelper(0x790, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Application::GetCalculationState() +{ + long result; + InvokeHelper(0x791, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long _Application::GetCalculationInterruptKey() +{ + long result; + InvokeHelper(0x792, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetCalculationInterruptKey(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x792, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Application::GetWatches() +{ + LPDISPATCH result; + InvokeHelper(0x793, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetDisplayFunctionToolTips() +{ + BOOL result; + InvokeHelper(0x794, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayFunctionToolTips(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x794, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Application::GetAutomationSecurity() +{ + long result; + InvokeHelper(0x795, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::SetAutomationSecurity(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x795, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Application::GetFileDialog(long fileDialogType) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x796, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + fileDialogType); + return result; +} + +void _Application::CalculateFullRebuild() +{ + InvokeHelper(0x799, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL _Application::GetDisplayPasteOptions() +{ + BOOL result; + InvokeHelper(0x79a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayPasteOptions(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x79a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetDisplayInsertOptions() +{ + BOOL result; + InvokeHelper(0x79b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayInsertOptions(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x79b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetGenerateGetPivotData() +{ + BOOL result; + InvokeHelper(0x79c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetGenerateGetPivotData(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x79c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Application::GetAutoRecover() +{ + LPDISPATCH result; + InvokeHelper(0x79d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Application::GetHwnd() +{ + long result; + InvokeHelper(0x79e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long _Application::GetHinstance() +{ + long result; + InvokeHelper(0x79f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Application::CheckAbort(const VARIANT& KeepAbort) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x7a0, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &KeepAbort); +} + +LPDISPATCH _Application::GetErrorCheckingOptions() +{ + LPDISPATCH result; + InvokeHelper(0x7a2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetAutoFormatAsYouTypeReplaceHyperlinks() +{ + BOOL result; + InvokeHelper(0x7a3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetAutoFormatAsYouTypeReplaceHyperlinks(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7a3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Application::GetSmartTagRecognizers() +{ + LPDISPATCH result; + InvokeHelper(0x7a4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetNewWorkbook() +{ + LPDISPATCH result; + InvokeHelper(0x61d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetSpellingOptions() +{ + LPDISPATCH result; + InvokeHelper(0x7a5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetSpeech() +{ + LPDISPATCH result; + InvokeHelper(0x7a6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetMapPaperSize() +{ + BOOL result; + InvokeHelper(0x7a7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetMapPaperSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7a7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Application::GetShowStartupDialog() +{ + BOOL result; + InvokeHelper(0x7a8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetShowStartupDialog(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7a8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString _Application::GetDecimalSeparator() +{ + CString result; + InvokeHelper(0x711, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetDecimalSeparator(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x711, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _Application::GetThousandsSeparator() +{ + CString result; + InvokeHelper(0x712, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Application::SetThousandsSeparator(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x712, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL _Application::GetUseSystemSeparators() +{ + BOOL result; + InvokeHelper(0x7a9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetUseSystemSeparators(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7a9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Application::GetThisCell() +{ + LPDISPATCH result; + InvokeHelper(0x7aa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Application::GetRtd() +{ + LPDISPATCH result; + InvokeHelper(0x7ab, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Application::GetDisplayDocumentActionTaskPane() +{ + BOOL result; + InvokeHelper(0x8cb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Application::SetDisplayDocumentActionTaskPane(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8cb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Application::DisplayXMLSourcePane(const VARIANT& XmlMap) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x8cc, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &XmlMap); +} + +BOOL _Application::GetArbitraryXMLSupportAvailable() +{ + BOOL result; + InvokeHelper(0x8ce, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// _Chart properties + +///////////////////////////////////////////////////////////////////////////// +// _Chart operations + +LPDISPATCH _Chart::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Chart::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Chart::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Chart::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +void _Chart::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString _Chart::GetCodeName() +{ + CString result; + InvokeHelper(0x55d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Chart::Get_CodeName() +{ + CString result; + InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Chart::Set_CodeName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long _Chart::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +CString _Chart::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Chart::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH _Chart::GetNext() +{ + LPDISPATCH result; + InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::GetPageSetup() +{ + LPDISPATCH result; + InvokeHelper(0x3e6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::GetPrevious() +{ + LPDISPATCH result; + InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Chart::PrintPreview(const VARIANT& EnableChanges) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EnableChanges); +} + +BOOL _Chart::GetProtectContents() +{ + BOOL result; + InvokeHelper(0x124, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Chart::GetProtectDrawingObjects() +{ + BOOL result; + InvokeHelper(0x125, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Chart::GetProtectionMode() +{ + BOOL result; + InvokeHelper(0x487, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +void _Chart::Unprotect(const VARIANT& Password) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password); +} + +long _Chart::GetVisible() +{ + long result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Chart::GetShapes() +{ + LPDISPATCH result; + InvokeHelper(0x561, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::GetArea3DGroup() +{ + LPDISPATCH result; + InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::AreaGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +BOOL _Chart::GetAutoScaling() +{ + BOOL result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetAutoScaling(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Chart::Axes(const VARIANT& Type, long AxisGroup) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_I4; + InvokeHelper(0x17, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Type, AxisGroup); + return result; +} + +void _Chart::SetBackgroundPicture(LPCTSTR Filename) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x4a4, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename); +} + +LPDISPATCH _Chart::GetBar3DGroup() +{ + LPDISPATCH result; + InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::BarGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH _Chart::GetChartArea() +{ + LPDISPATCH result; + InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::ChartGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH _Chart::ChartObjects(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x424, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH _Chart::GetChartTitle() +{ + LPDISPATCH result; + InvokeHelper(0x51, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Chart::ChartWizard(const VARIANT& Source, const VARIANT& Gallery, const VARIANT& Format, const VARIANT& PlotBy, const VARIANT& CategoryLabels, const VARIANT& SeriesLabels, const VARIANT& HasLegend, const VARIANT& Title, + const VARIANT& CategoryTitle, const VARIANT& ValueTitle, const VARIANT& ExtraTitle) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc4, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Source, &Gallery, &Format, &PlotBy, &CategoryLabels, &SeriesLabels, &HasLegend, &Title, &CategoryTitle, &ValueTitle, &ExtraTitle); +} + +void _Chart::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); +} + +LPDISPATCH _Chart::GetColumn3DGroup() +{ + LPDISPATCH result; + InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::ColumnGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void _Chart::CopyPicture(long Appearance, long Format, long Size) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Appearance, Format, Size); +} + +LPDISPATCH _Chart::GetCorners() +{ + LPDISPATCH result; + InvokeHelper(0x4f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Chart::CreatePublisher(const VARIANT& Edition, long Appearance, long Size, const VARIANT& ContainsPICT, const VARIANT& ContainsBIFF, const VARIANT& ContainsRTF, const VARIANT& ContainsVALU) +{ + static BYTE parms[] = + VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1ca, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Edition, Appearance, Size, &ContainsPICT, &ContainsBIFF, &ContainsRTF, &ContainsVALU); +} + +LPDISPATCH _Chart::GetDataTable() +{ + LPDISPATCH result; + InvokeHelper(0x573, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Chart::GetDepthPercent() +{ + long result; + InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetDepthPercent(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x30, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void _Chart::Deselect() +{ + InvokeHelper(0x460, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long _Chart::GetDisplayBlanksAs() +{ + long result; + InvokeHelper(0x5d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetDisplayBlanksAs(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x5d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Chart::DoughnutGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long _Chart::GetElevation() +{ + long result; + InvokeHelper(0x31, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetElevation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x31, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT _Chart::Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +VARIANT _Chart::_Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +LPDISPATCH _Chart::GetFloor() +{ + LPDISPATCH result; + InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Chart::GetGapDepth() +{ + long result; + InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetGapDepth(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x32, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT _Chart::GetHasAxis(const VARIANT& Index1, const VARIANT& Index2) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index1, &Index2); + return result; +} + +void _Chart::SetHasAxis(const VARIANT& Index1, const VARIANT& Index2, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x34, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index1, &Index2, &newValue); +} + +BOOL _Chart::GetHasDataTable() +{ + BOOL result; + InvokeHelper(0x574, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetHasDataTable(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x574, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Chart::GetHasLegend() +{ + BOOL result; + InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetHasLegend(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Chart::GetHasTitle() +{ + BOOL result; + InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetHasTitle(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x36, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Chart::GetHeightPercent() +{ + long result; + InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetHeightPercent(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x37, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Chart::GetHyperlinks() +{ + LPDISPATCH result; + InvokeHelper(0x571, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::GetLegend() +{ + LPDISPATCH result; + InvokeHelper(0x54, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::GetLine3DGroup() +{ + LPDISPATCH result; + InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::LineGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH _Chart::Location(long Where, const VARIANT& Name) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x575, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Where, &Name); + return result; +} + +LPDISPATCH _Chart::OLEObjects(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x31f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void _Chart::Paste(const VARIANT& Type) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd3, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Type); +} + +long _Chart::GetPerspective() +{ + long result; + InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetPerspective(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x39, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Chart::GetPie3DGroup() +{ + LPDISPATCH result; + InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::PieGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH _Chart::GetPlotArea() +{ + LPDISPATCH result; + InvokeHelper(0x55, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Chart::GetPlotVisibleOnly() +{ + BOOL result; + InvokeHelper(0x5c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetPlotVisibleOnly(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Chart::RadarGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +VARIANT _Chart::GetRightAngleAxes() +{ + VARIANT result; + InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _Chart::SetRightAngleAxes(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT _Chart::GetRotation() +{ + VARIANT result; + InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _Chart::SetRotation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH _Chart::SeriesCollection(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x44, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +BOOL _Chart::GetSizeWithWindow() +{ + BOOL result; + InvokeHelper(0x5e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetSizeWithWindow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Chart::GetShowWindow() +{ + BOOL result; + InvokeHelper(0x577, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetShowWindow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x577, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Chart::GetSurfaceGroup() +{ + LPDISPATCH result; + InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Chart::GetChartType() +{ + long result; + InvokeHelper(0x578, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetChartType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x578, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void _Chart::ApplyCustomType(long ChartType, const VARIANT& TypeName) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x579, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ChartType, &TypeName); +} + +LPDISPATCH _Chart::GetWalls() +{ + LPDISPATCH result; + InvokeHelper(0x56, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Chart::GetWallsAndGridlines2D() +{ + BOOL result; + InvokeHelper(0xd2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetWallsAndGridlines2D(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xd2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Chart::XYGroups(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long _Chart::GetBarShape() +{ + long result; + InvokeHelper(0x57b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetBarShape(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x57b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _Chart::GetPlotBy() +{ + long result; + InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Chart::SetPlotBy(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Chart::GetProtectFormatting() +{ + BOOL result; + InvokeHelper(0x57d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetProtectFormatting(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x57d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Chart::GetProtectData() +{ + BOOL result; + InvokeHelper(0x57e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetProtectData(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x57e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Chart::GetProtectGoalSeek() +{ + BOOL result; + InvokeHelper(0x57f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetProtectGoalSeek(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x57f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Chart::GetProtectSelection() +{ + BOOL result; + InvokeHelper(0x580, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetProtectSelection(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x580, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Chart::GetChartElement(long x, long y, long* ElementID, long* Arg1, long* Arg2) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_PI4 VTS_PI4 VTS_PI4; + InvokeHelper(0x581, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + x, y, ElementID, Arg1, Arg2); +} + +void _Chart::SetSourceData(LPDISPATCH Source, const VARIANT& PlotBy) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT; + InvokeHelper(0x585, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Source, &PlotBy); +} + +BOOL _Chart::Export(LPCTSTR Filename, const VARIANT& FilterName, const VARIANT& Interactive) +{ + BOOL result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x586, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + Filename, &FilterName, &Interactive); + return result; +} + +void _Chart::Refresh() +{ + InvokeHelper(0x589, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Chart::GetPivotLayout() +{ + LPDISPATCH result; + InvokeHelper(0x716, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Chart::GetHasPivotFields() +{ + BOOL result; + InvokeHelper(0x717, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Chart::SetHasPivotFields(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x717, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Chart::GetScripts() +{ + LPDISPATCH result; + InvokeHelper(0x718, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Chart::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + +LPDISPATCH _Chart::GetTab() +{ + LPDISPATCH result; + InvokeHelper(0x411, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Chart::GetMailEnvelope() +{ + LPDISPATCH result; + InvokeHelper(0x7e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Chart::ApplyDataLabels(long Type, const VARIANT& LegendKey, const VARIANT& AutoText, const VARIANT& HasLeaderLines, const VARIANT& ShowSeriesName, const VARIANT& ShowCategoryName, const VARIANT& ShowValue, const VARIANT& ShowPercentage, + const VARIANT& ShowBubbleSize, const VARIANT& Separator) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x782, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Type, &LegendKey, &AutoText, &HasLeaderLines, &ShowSeriesName, &ShowCategoryName, &ShowValue, &ShowPercentage, &ShowBubbleSize, &Separator); +} + +void _Chart::SaveAs(LPCTSTR Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AddToMru, const VARIANT& TextCodepage, + const VARIANT& TextVisualLayout, const VARIANT& Local) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x785, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &AddToMru, &TextCodepage, &TextVisualLayout, &Local); +} + +void _Chart::Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7ed, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password, &DrawingObjects, &Contents, &Scenarios, &UserInterfaceOnly); +} + + +///////////////////////////////////////////////////////////////////////////// +// Sheets properties + +///////////////////////////////////////////////////////////////////////////// +// Sheets operations + +LPDISPATCH Sheets::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Sheets::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Sheets::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Sheets::Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count, const VARIANT& Type) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Before, &After, &Count, &Type); + return result; +} + +void Sheets::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +long Sheets::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Sheets::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Sheets::FillAcrossSheets(LPDISPATCH Range, long Type) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0x1d5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Range, Type); +} + +LPDISPATCH Sheets::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Sheets::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +LPUNKNOWN Sheets::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void Sheets::PrintPreview(const VARIANT& EnableChanges) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EnableChanges); +} + +void Sheets::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +LPDISPATCH Sheets::GetHPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Sheets::GetVPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Sheets::GetVisible() +{ + VARIANT result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Sheets::SetVisible(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Sheets::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Sheets::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + + +///////////////////////////////////////////////////////////////////////////// +// _Worksheet properties + +///////////////////////////////////////////////////////////////////////////// +// _Worksheet operations + +LPDISPATCH _Worksheet::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Worksheet::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Worksheet::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Worksheet::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +void _Worksheet::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString _Worksheet::GetCodeName() +{ + CString result; + InvokeHelper(0x55d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Worksheet::Get_CodeName() +{ + CString result; + InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Worksheet::Set_CodeName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long _Worksheet::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Worksheet::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +CString _Worksheet::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH _Worksheet::GetNext() +{ + LPDISPATCH result; + InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetPageSetup() +{ + LPDISPATCH result; + InvokeHelper(0x3e6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetPrevious() +{ + LPDISPATCH result; + InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Worksheet::PrintPreview(const VARIANT& EnableChanges) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EnableChanges); +} + +BOOL _Worksheet::GetProtectContents() +{ + BOOL result; + InvokeHelper(0x124, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Worksheet::GetProtectDrawingObjects() +{ + BOOL result; + InvokeHelper(0x125, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Worksheet::GetProtectionMode() +{ + BOOL result; + InvokeHelper(0x487, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Worksheet::GetProtectScenarios() +{ + BOOL result; + InvokeHelper(0x126, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +void _Worksheet::Unprotect(const VARIANT& Password) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password); +} + +long _Worksheet::GetVisible() +{ + long result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Worksheet::GetShapes() +{ + LPDISPATCH result; + InvokeHelper(0x561, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Worksheet::GetTransitionExpEval() +{ + BOOL result; + InvokeHelper(0x191, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetTransitionExpEval(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x191, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Worksheet::GetAutoFilterMode() +{ + BOOL result; + InvokeHelper(0x318, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetAutoFilterMode(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x318, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Worksheet::SetBackgroundPicture(LPCTSTR Filename) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x4a4, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename); +} + +void _Worksheet::Calculate() +{ + InvokeHelper(0x117, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL _Worksheet::GetEnableCalculation() +{ + BOOL result; + InvokeHelper(0x590, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetEnableCalculation(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x590, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Worksheet::GetCells() +{ + LPDISPATCH result; + InvokeHelper(0xee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::ChartObjects(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x424, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void _Worksheet::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); +} + +LPDISPATCH _Worksheet::GetCircularReference() +{ + LPDISPATCH result; + InvokeHelper(0x42d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Worksheet::ClearArrows() +{ + InvokeHelper(0x3ca, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Worksheet::GetColumns() +{ + LPDISPATCH result; + InvokeHelper(0xf1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Worksheet::GetConsolidationFunction() +{ + long result; + InvokeHelper(0x315, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT _Worksheet::GetConsolidationOptions() +{ + VARIANT result; + InvokeHelper(0x316, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT _Worksheet::GetConsolidationSources() +{ + VARIANT result; + InvokeHelper(0x317, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL _Worksheet::GetEnableAutoFilter() +{ + BOOL result; + InvokeHelper(0x484, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetEnableAutoFilter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x484, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Worksheet::GetEnableSelection() +{ + long result; + InvokeHelper(0x591, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetEnableSelection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x591, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Worksheet::GetEnableOutlining() +{ + BOOL result; + InvokeHelper(0x485, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetEnableOutlining(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x485, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Worksheet::GetEnablePivotTable() +{ + BOOL result; + InvokeHelper(0x486, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetEnablePivotTable(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x486, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _Worksheet::Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +VARIANT _Worksheet::_Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +BOOL _Worksheet::GetFilterMode() +{ + BOOL result; + InvokeHelper(0x320, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::ResetAllPageBreaks() +{ + InvokeHelper(0x592, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Worksheet::GetNames() +{ + LPDISPATCH result; + InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::OLEObjects(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x31f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH _Worksheet::GetOutline() +{ + LPDISPATCH result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Worksheet::Paste(const VARIANT& Destination, const VARIANT& Link) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xd3, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Destination, &Link); +} + +LPDISPATCH _Worksheet::PivotTables(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2b2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH _Worksheet::PivotTableWizard(const VARIANT& SourceType, const VARIANT& SourceData, const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& RowGrand, const VARIANT& ColumnGrand, const VARIANT& SaveData, + const VARIANT& HasAutoFormat, const VARIANT& AutoPage, const VARIANT& Reserved, const VARIANT& BackgroundQuery, const VARIANT& OptimizeCache, const VARIANT& PageFieldOrder, const VARIANT& PageFieldWrapCount, const VARIANT& ReadData, + const VARIANT& Connection) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2ac, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &SourceType, &SourceData, &TableDestination, &TableName, &RowGrand, &ColumnGrand, &SaveData, &HasAutoFormat, &AutoPage, &Reserved, &BackgroundQuery, &OptimizeCache, &PageFieldOrder, &PageFieldWrapCount, &ReadData, &Connection); + return result; +} + +LPDISPATCH _Worksheet::GetRange(const VARIANT& Cell1, const VARIANT& Cell2) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Cell1, &Cell2); + return result; +} + +LPDISPATCH _Worksheet::GetRows() +{ + LPDISPATCH result; + InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::Scenarios(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x38c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +CString _Worksheet::GetScrollArea() +{ + CString result; + InvokeHelper(0x599, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetScrollArea(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x599, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void _Worksheet::ShowAllData() +{ + InvokeHelper(0x31a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Worksheet::ShowDataForm() +{ + InvokeHelper(0x199, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +double _Worksheet::GetStandardHeight() +{ + double result; + InvokeHelper(0x197, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double _Worksheet::GetStandardWidth() +{ + double result; + InvokeHelper(0x198, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetStandardWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x198, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL _Worksheet::GetTransitionFormEntry() +{ + BOOL result; + InvokeHelper(0x192, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetTransitionFormEntry(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x192, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Worksheet::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetUsedRange() +{ + LPDISPATCH result; + InvokeHelper(0x19c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetHPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetVPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetQueryTables() +{ + LPDISPATCH result; + InvokeHelper(0x59a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Worksheet::GetDisplayPageBreaks() +{ + BOOL result; + InvokeHelper(0x59b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetDisplayPageBreaks(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x59b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Worksheet::GetComments() +{ + LPDISPATCH result; + InvokeHelper(0x23f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetHyperlinks() +{ + LPDISPATCH result; + InvokeHelper(0x571, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Worksheet::ClearCircles() +{ + InvokeHelper(0x59c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Worksheet::CircleInvalid() +{ + InvokeHelper(0x59d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Worksheet::GetAutoFilter() +{ + LPDISPATCH result; + InvokeHelper(0x319, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Worksheet::GetDisplayRightToLeft() +{ + BOOL result; + InvokeHelper(0x6ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Worksheet::SetDisplayRightToLeft(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x6ee, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Worksheet::GetScripts() +{ + LPDISPATCH result; + InvokeHelper(0x718, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Worksheet::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + +LPDISPATCH _Worksheet::GetTab() +{ + LPDISPATCH result; + InvokeHelper(0x411, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetMailEnvelope() +{ + LPDISPATCH result; + InvokeHelper(0x7e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Worksheet::SaveAs(LPCTSTR Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AddToMru, const VARIANT& TextCodepage, + const VARIANT& TextVisualLayout, const VARIANT& Local) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x785, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &AddToMru, &TextCodepage, &TextVisualLayout, &Local); +} + +LPDISPATCH _Worksheet::GetCustomProperties() +{ + LPDISPATCH result; + InvokeHelper(0x7ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetSmartTags() +{ + LPDISPATCH result; + InvokeHelper(0x7e0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::GetProtection() +{ + LPDISPATCH result; + InvokeHelper(0xb0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Worksheet::PasteSpecial(const VARIANT& Format, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel, const VARIANT& NoHTMLFormatting) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x788, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Format, &Link, &DisplayAsIcon, &IconFileName, &IconIndex, &IconLabel, &NoHTMLFormatting); +} + +void _Worksheet::Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly, const VARIANT& AllowFormattingCells, const VARIANT& AllowFormattingColumns, + const VARIANT& AllowFormattingRows, const VARIANT& AllowInsertingColumns, const VARIANT& AllowInsertingRows, const VARIANT& AllowInsertingHyperlinks, const VARIANT& AllowDeletingColumns, const VARIANT& AllowDeletingRows, + const VARIANT& AllowSorting, const VARIANT& AllowFiltering, const VARIANT& AllowUsingPivotTables) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7ed, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password, &DrawingObjects, &Contents, &Scenarios, &UserInterfaceOnly, &AllowFormattingCells, &AllowFormattingColumns, &AllowFormattingRows, &AllowInsertingColumns, &AllowInsertingRows, &AllowInsertingHyperlinks, &AllowDeletingColumns, + &AllowDeletingRows, &AllowSorting, &AllowFiltering, &AllowUsingPivotTables); +} + +LPDISPATCH _Worksheet::GetListObjects() +{ + LPDISPATCH result; + InvokeHelper(0x8d3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Worksheet::XmlDataQuery(LPCTSTR XPath, const VARIANT& SelectionNamespaces, const VARIANT& Map) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8d4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + XPath, &SelectionNamespaces, &Map); + return result; +} + +LPDISPATCH _Worksheet::XmlMapQuery(LPCTSTR XPath, const VARIANT& SelectionNamespaces, const VARIANT& Map) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8d7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + XPath, &SelectionNamespaces, &Map); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// _Global properties + +///////////////////////////////////////////////////////////////////////////// +// _Global operations + +LPDISPATCH _Global::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Global::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetActiveCell() +{ + LPDISPATCH result; + InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetActiveChart() +{ + LPDISPATCH result; + InvokeHelper(0xb7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString _Global::GetActivePrinter() +{ + CString result; + InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Global::SetActivePrinter(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH _Global::GetActiveSheet() +{ + LPDISPATCH result; + InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetActiveWindow() +{ + LPDISPATCH result; + InvokeHelper(0x2f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetActiveWorkbook() +{ + LPDISPATCH result; + InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetAddIns() +{ + LPDISPATCH result; + InvokeHelper(0x225, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetAssistant() +{ + LPDISPATCH result; + InvokeHelper(0x59e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Global::Calculate() +{ + InvokeHelper(0x117, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Global::GetCells() +{ + LPDISPATCH result; + InvokeHelper(0xee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetCharts() +{ + LPDISPATCH result; + InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetColumns() +{ + LPDISPATCH result; + InvokeHelper(0xf1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetCommandBars() +{ + LPDISPATCH result; + InvokeHelper(0x59f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Global::GetDDEAppReturnCode() +{ + long result; + InvokeHelper(0x14c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Global::DDEExecute(long Channel, LPCTSTR String) +{ + static BYTE parms[] = + VTS_I4 VTS_BSTR; + InvokeHelper(0x14d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Channel, String); +} + +long _Global::DDEInitiate(LPCTSTR App, LPCTSTR Topic) +{ + long result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR; + InvokeHelper(0x14e, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + App, Topic); + return result; +} + +void _Global::DDEPoke(long Channel, const VARIANT& Item, const VARIANT& Data) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x14f, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Channel, &Item, &Data); +} + +VARIANT _Global::DDERequest(long Channel, LPCTSTR Item) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_BSTR; + InvokeHelper(0x150, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Channel, Item); + return result; +} + +void _Global::DDETerminate(long Channel) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x151, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Channel); +} + +VARIANT _Global::Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +VARIANT _Global::_Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +VARIANT _Global::ExecuteExcel4Macro(LPCTSTR String) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x15e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + String); + return result; +} + +LPDISPATCH _Global::Intersect(LPDISPATCH Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2fe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Arg1, Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH _Global::GetNames() +{ + LPDISPATCH result; + InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetRange(const VARIANT& Cell1, const VARIANT& Cell2) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Cell1, &Cell2); + return result; +} + +LPDISPATCH _Global::GetRows() +{ + LPDISPATCH result; + InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT _Global::Run(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, + const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, + const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, + const VARIANT& Arg30) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x103, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Macro, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +VARIANT _Global::_Run2(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, + const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, + const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, + const VARIANT& Arg30) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x326, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Macro, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH _Global::GetSelection() +{ + LPDISPATCH result; + InvokeHelper(0x93, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Global::SendKeys(const VARIANT& Keys, const VARIANT& Wait) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x17f, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Keys, &Wait); +} + +LPDISPATCH _Global::GetSheets() +{ + LPDISPATCH result; + InvokeHelper(0x1e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetThisWorkbook() +{ + LPDISPATCH result; + InvokeHelper(0x30a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::Union(LPDISPATCH Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x30b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Arg1, Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +LPDISPATCH _Global::GetWindows() +{ + LPDISPATCH result; + InvokeHelper(0x1ae, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetWorkbooks() +{ + LPDISPATCH result; + InvokeHelper(0x23c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetWorksheetFunction() +{ + LPDISPATCH result; + InvokeHelper(0x5a0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetWorksheets() +{ + LPDISPATCH result; + InvokeHelper(0x1ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetExcel4IntlMacroSheets() +{ + LPDISPATCH result; + InvokeHelper(0x245, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Global::GetExcel4MacroSheets() +{ + LPDISPATCH result; + InvokeHelper(0x243, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// _Workbook properties + +///////////////////////////////////////////////////////////////////////////// +// _Workbook operations + +LPDISPATCH _Workbook::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Workbook::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetAcceptLabelsInFormulas() +{ + BOOL result; + InvokeHelper(0x5a1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetAcceptLabelsInFormulas(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5a1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Workbook::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Workbook::GetActiveChart() +{ + LPDISPATCH result; + InvokeHelper(0xb7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetActiveSheet() +{ + LPDISPATCH result; + InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Workbook::GetAutoUpdateFrequency() +{ + long result; + InvokeHelper(0x5a2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Workbook::SetAutoUpdateFrequency(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x5a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Workbook::GetAutoUpdateSaveChanges() +{ + BOOL result; + InvokeHelper(0x5a3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetAutoUpdateSaveChanges(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5a3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Workbook::GetChangeHistoryDuration() +{ + long result; + InvokeHelper(0x5a4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Workbook::SetChangeHistoryDuration(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x5a4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Workbook::GetBuiltinDocumentProperties() +{ + LPDISPATCH result; + InvokeHelper(0x498, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::ChangeFileAccess(long Mode, const VARIANT& WritePassword, const VARIANT& Notify) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3dd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Mode, &WritePassword, &Notify); +} + +void _Workbook::ChangeLink(LPCTSTR Name, LPCTSTR NewName, long Type) +{ + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_I4; + InvokeHelper(0x322, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Name, NewName, Type); +} + +LPDISPATCH _Workbook::GetCharts() +{ + LPDISPATCH result; + InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::Close(const VARIANT& SaveChanges, const VARIANT& Filename, const VARIANT& RouteWorkbook) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x115, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &SaveChanges, &Filename, &RouteWorkbook); +} + +CString _Workbook::GetCodeName() +{ + CString result; + InvokeHelper(0x55d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Workbook::Get_CodeName() +{ + CString result; + InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Workbook::Set_CodeName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT _Workbook::GetColors(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x11e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void _Workbook::SetColors(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x11e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +LPDISPATCH _Workbook::GetCommandBars() +{ + LPDISPATCH result; + InvokeHelper(0x59f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Workbook::GetConflictResolution() +{ + long result; + InvokeHelper(0x497, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Workbook::SetConflictResolution(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x497, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH _Workbook::GetContainer() +{ + LPDISPATCH result; + InvokeHelper(0x4a6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetCreateBackup() +{ + BOOL result; + InvokeHelper(0x11f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetCustomDocumentProperties() +{ + LPDISPATCH result; + InvokeHelper(0x499, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetDate1904() +{ + BOOL result; + InvokeHelper(0x193, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetDate1904(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x193, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Workbook::DeleteNumberFormat(LPCTSTR NumberFormat) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x18d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + NumberFormat); +} + +long _Workbook::GetDisplayDrawingObjects() +{ + long result; + InvokeHelper(0x194, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Workbook::SetDisplayDrawingObjects(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x194, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _Workbook::ExclusiveAccess() +{ + BOOL result; + InvokeHelper(0x490, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL); + return result; +} + +long _Workbook::GetFileFormat() +{ + long result; + InvokeHelper(0x120, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Workbook::ForwardMailer() +{ + InvokeHelper(0x3cd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString _Workbook::GetFullName() +{ + CString result; + InvokeHelper(0x121, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetHasPassword() +{ + BOOL result; + InvokeHelper(0x122, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetHasRoutingSlip() +{ + BOOL result; + InvokeHelper(0x3b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetHasRoutingSlip(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Workbook::GetIsAddin() +{ + BOOL result; + InvokeHelper(0x5a5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetIsAddin(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5a5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _Workbook::LinkInfo(LPCTSTR Name, long LinkInfo, const VARIANT& Type, const VARIANT& EditionRef) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x327, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Name, LinkInfo, &Type, &EditionRef); + return result; +} + +VARIANT _Workbook::LinkSources(const VARIANT& Type) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x328, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Type); + return result; +} + +LPDISPATCH _Workbook::GetMailer() +{ + LPDISPATCH result; + InvokeHelper(0x3d3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::MergeWorkbook(const VARIANT& Filename) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5a6, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Filename); +} + +BOOL _Workbook::GetMultiUserEditing() +{ + BOOL result; + InvokeHelper(0x491, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +CString _Workbook::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetNames() +{ + LPDISPATCH result; + InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::NewWindow() +{ + LPDISPATCH result; + InvokeHelper(0x118, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::OpenLinks(LPCTSTR Name, const VARIANT& ReadOnly, const VARIANT& Type) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x323, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Name, &ReadOnly, &Type); +} + +CString _Workbook::GetPath() +{ + CString result; + InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetPersonalViewListSettings() +{ + BOOL result; + InvokeHelper(0x5a7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetPersonalViewListSettings(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5a7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Workbook::GetPersonalViewPrintSettings() +{ + BOOL result; + InvokeHelper(0x5a8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetPersonalViewPrintSettings(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5a8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Workbook::PivotCaches() +{ + LPDISPATCH result; + InvokeHelper(0x5a9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::Post(const VARIANT& DestName) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x48e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &DestName); +} + +BOOL _Workbook::GetPrecisionAsDisplayed() +{ + BOOL result; + InvokeHelper(0x195, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetPrecisionAsDisplayed(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x195, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Workbook::PrintPreview(const VARIANT& EnableChanges) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EnableChanges); +} + +void _Workbook::ProtectSharing(const VARIANT& Filename, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& SharingPassword) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5aa, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Filename, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &SharingPassword); +} + +BOOL _Workbook::GetProtectStructure() +{ + BOOL result; + InvokeHelper(0x24c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetProtectWindows() +{ + BOOL result; + InvokeHelper(0x127, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetReadOnly() +{ + BOOL result; + InvokeHelper(0x128, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::RefreshAll() +{ + InvokeHelper(0x5ac, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Workbook::Reply() +{ + InvokeHelper(0x3d1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Workbook::ReplyAll() +{ + InvokeHelper(0x3d2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Workbook::RemoveUser(long Index) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x5ad, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Index); +} + +long _Workbook::GetRevisionNumber() +{ + long result; + InvokeHelper(0x494, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Workbook::Route() +{ + InvokeHelper(0x3b2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL _Workbook::GetRouted() +{ + BOOL result; + InvokeHelper(0x3b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetRoutingSlip() +{ + LPDISPATCH result; + InvokeHelper(0x3b5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::RunAutoMacros(long Which) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x27a, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Which); +} + +void _Workbook::Save() +{ + InvokeHelper(0x11b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Workbook::SaveCopyAs(const VARIANT& Filename) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaf, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Filename); +} + +BOOL _Workbook::GetSaved() +{ + BOOL result; + InvokeHelper(0x12a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetSaved(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x12a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Workbook::GetSaveLinkValues() +{ + BOOL result; + InvokeHelper(0x196, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetSaveLinkValues(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x196, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Workbook::SendMail(const VARIANT& Recipients, const VARIANT& Subject, const VARIANT& ReturnReceipt) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3b3, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Recipients, &Subject, &ReturnReceipt); +} + +void _Workbook::SendMailer(const VARIANT& FileFormat, long Priority) +{ + static BYTE parms[] = + VTS_VARIANT VTS_I4; + InvokeHelper(0x3d4, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &FileFormat, Priority); +} + +void _Workbook::SetLinkOnData(LPCTSTR Name, const VARIANT& Procedure) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x329, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Name, &Procedure); +} + +LPDISPATCH _Workbook::GetSheets() +{ + LPDISPATCH result; + InvokeHelper(0x1e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetShowConflictHistory() +{ + BOOL result; + InvokeHelper(0x493, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetShowConflictHistory(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x493, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _Workbook::GetStyles() +{ + LPDISPATCH result; + InvokeHelper(0x1ed, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::Unprotect(const VARIANT& Password) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password); +} + +void _Workbook::UnprotectSharing(const VARIANT& SharingPassword) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5af, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &SharingPassword); +} + +void _Workbook::UpdateFromFile() +{ + InvokeHelper(0x3e3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void _Workbook::UpdateLink(const VARIANT& Name, const VARIANT& Type) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x324, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Name, &Type); +} + +BOOL _Workbook::GetUpdateRemoteReferences() +{ + BOOL result; + InvokeHelper(0x19b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetUpdateRemoteReferences(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x19b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _Workbook::GetUserStatus() +{ + VARIANT result; + InvokeHelper(0x495, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetCustomViews() +{ + LPDISPATCH result; + InvokeHelper(0x5b0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetWindows() +{ + LPDISPATCH result; + InvokeHelper(0x1ae, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetWorksheets() +{ + LPDISPATCH result; + InvokeHelper(0x1ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetWriteReserved() +{ + BOOL result; + InvokeHelper(0x12b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +CString _Workbook::GetWriteReservedBy() +{ + CString result; + InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetExcel4IntlMacroSheets() +{ + LPDISPATCH result; + InvokeHelper(0x245, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetExcel4MacroSheets() +{ + LPDISPATCH result; + InvokeHelper(0x243, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetTemplateRemoveExtData() +{ + BOOL result; + InvokeHelper(0x5b1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetTemplateRemoveExtData(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5b1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Workbook::HighlightChangesOptions(const VARIANT& When, const VARIANT& Who, const VARIANT& Where) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5b2, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &When, &Who, &Where); +} + +BOOL _Workbook::GetHighlightChangesOnScreen() +{ + BOOL result; + InvokeHelper(0x5b5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetHighlightChangesOnScreen(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5b5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Workbook::GetKeepChangeHistory() +{ + BOOL result; + InvokeHelper(0x5b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetKeepChangeHistory(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Workbook::GetListChangesOnNewSheet() +{ + BOOL result; + InvokeHelper(0x5b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetListChangesOnNewSheet(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5b7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Workbook::PurgeChangeHistoryNow(long Days, const VARIANT& SharingPassword) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x5b8, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Days, &SharingPassword); +} + +void _Workbook::AcceptAllChanges(const VARIANT& When, const VARIANT& Who, const VARIANT& Where) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5ba, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &When, &Who, &Where); +} + +void _Workbook::RejectAllChanges(const VARIANT& When, const VARIANT& Who, const VARIANT& Where) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5bb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &When, &Who, &Where); +} + +void _Workbook::ResetColors() +{ + InvokeHelper(0x5bc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Workbook::GetVBProject() +{ + LPDISPATCH result; + InvokeHelper(0x5bd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::FollowHyperlink(LPCTSTR Address, const VARIANT& SubAddress, const VARIANT& NewWindow, const VARIANT& AddHistory, const VARIANT& ExtraInfo, const VARIANT& Method, const VARIANT& HeaderInfo) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x5be, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Address, &SubAddress, &NewWindow, &AddHistory, &ExtraInfo, &Method, &HeaderInfo); +} + +void _Workbook::AddToFavorites() +{ + InvokeHelper(0x5c4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL _Workbook::GetIsInplace() +{ + BOOL result; + InvokeHelper(0x6e9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + +void _Workbook::WebPagePreview() +{ + InvokeHelper(0x71a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Workbook::GetPublishObjects() +{ + LPDISPATCH result; + InvokeHelper(0x71b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetWebOptions() +{ + LPDISPATCH result; + InvokeHelper(0x71c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::ReloadAs(long Encoding) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x71d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Encoding); +} + +LPDISPATCH _Workbook::GetHTMLProject() +{ + LPDISPATCH result; + InvokeHelper(0x71f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetEnvelopeVisible() +{ + BOOL result; + InvokeHelper(0x720, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetEnvelopeVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x720, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Workbook::GetCalculationVersion() +{ + long result; + InvokeHelper(0x70e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetVBASigned() +{ + BOOL result; + InvokeHelper(0x724, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetShowPivotTableFieldList() +{ + BOOL result; + InvokeHelper(0x7fe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetShowPivotTableFieldList(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7fe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Workbook::GetUpdateLinks() +{ + long result; + InvokeHelper(0x360, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Workbook::SetUpdateLinks(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x360, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void _Workbook::BreakLink(LPCTSTR Name, long Type) +{ + static BYTE parms[] = + VTS_BSTR VTS_I4; + InvokeHelper(0x7ff, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Name, Type); +} + +void _Workbook::SaveAs(const VARIANT& Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, long AccessMode, const VARIANT& ConflictResolution, + const VARIANT& AddToMru, const VARIANT& TextCodepage, const VARIANT& TextVisualLayout, const VARIANT& Local) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x785, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, AccessMode, &ConflictResolution, &AddToMru, &TextCodepage, &TextVisualLayout, &Local); +} + +BOOL _Workbook::GetEnableAutoRecover() +{ + BOOL result; + InvokeHelper(0x801, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetEnableAutoRecover(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x801, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Workbook::GetRemovePersonalInformation() +{ + BOOL result; + InvokeHelper(0x802, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetRemovePersonalInformation(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x802, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString _Workbook::GetFullNameURLEncoded() +{ + CString result; + InvokeHelper(0x787, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Workbook::CheckIn(const VARIANT& SaveChanges, const VARIANT& Comments, const VARIANT& MakePublic) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x803, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &SaveChanges, &Comments, &MakePublic); +} + +BOOL _Workbook::CanCheckIn() +{ + BOOL result; + InvokeHelper(0x805, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SendForReview(const VARIANT& Recipients, const VARIANT& Subject, const VARIANT& ShowMessage, const VARIANT& IncludeAttachment) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x806, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Recipients, &Subject, &ShowMessage, &IncludeAttachment); +} + +void _Workbook::ReplyWithChanges(const VARIANT& ShowMessage) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x809, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &ShowMessage); +} + +void _Workbook::EndReview() +{ + InvokeHelper(0x80a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString _Workbook::GetPassword() +{ + CString result; + InvokeHelper(0x1ad, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Workbook::SetPassword(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x1ad, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _Workbook::GetWritePassword() +{ + CString result; + InvokeHelper(0x468, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _Workbook::SetWritePassword(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x468, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _Workbook::GetPasswordEncryptionProvider() +{ + CString result; + InvokeHelper(0x80b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString _Workbook::GetPasswordEncryptionAlgorithm() +{ + CString result; + InvokeHelper(0x80c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long _Workbook::GetPasswordEncryptionKeyLength() +{ + long result; + InvokeHelper(0x80d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _Workbook::SetPasswordEncryptionOptions(const VARIANT& PasswordEncryptionProvider, const VARIANT& PasswordEncryptionAlgorithm, const VARIANT& PasswordEncryptionKeyLength, const VARIANT& PasswordEncryptionFileProperties) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x80e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &PasswordEncryptionProvider, &PasswordEncryptionAlgorithm, &PasswordEncryptionKeyLength, &PasswordEncryptionFileProperties); +} + +BOOL _Workbook::GetPasswordEncryptionFileProperties() +{ + BOOL result; + InvokeHelper(0x80f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetReadOnlyRecommended() +{ + BOOL result; + InvokeHelper(0x7d5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetReadOnlyRecommended(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7d5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _Workbook::Protect(const VARIANT& Password, const VARIANT& Structure, const VARIANT& Windows) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7ed, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password, &Structure, &Windows); +} + +LPDISPATCH _Workbook::GetSmartTagOptions() +{ + LPDISPATCH result; + InvokeHelper(0x810, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::RecheckSmartTags() +{ + InvokeHelper(0x811, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH _Workbook::GetPermission() +{ + LPDISPATCH result; + InvokeHelper(0x8d8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetSharedWorkspace() +{ + LPDISPATCH result; + InvokeHelper(0x8d9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetSync() +{ + LPDISPATCH result; + InvokeHelper(0x8da, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _Workbook::SendFaxOverInternet(const VARIANT& Recipients, const VARIANT& Subject, const VARIANT& ShowMessage) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8db, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Recipients, &Subject, &ShowMessage); +} + +LPDISPATCH _Workbook::GetXmlNamespaces() +{ + LPDISPATCH result; + InvokeHelper(0x8dc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetXmlMaps() +{ + LPDISPATCH result; + InvokeHelper(0x8dd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _Workbook::XmlImport(LPCTSTR Url, LPDISPATCH* ImportMap, const VARIANT& Overwrite, const VARIANT& Destination) +{ + long result; + static BYTE parms[] = + VTS_BSTR VTS_PDISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8de, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + Url, ImportMap, &Overwrite, &Destination); + return result; +} + +LPDISPATCH _Workbook::GetSmartDocument() +{ + LPDISPATCH result; + InvokeHelper(0x8e1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _Workbook::GetDocumentLibraryVersions() +{ + LPDISPATCH result; + InvokeHelper(0x8e2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _Workbook::GetInactiveListBorderVisible() +{ + BOOL result; + InvokeHelper(0x8e3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetInactiveListBorderVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8e3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _Workbook::GetDisplayInkComments() +{ + BOOL result; + InvokeHelper(0x8e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _Workbook::SetDisplayInkComments(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8e4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _Workbook::XmlImportXml(LPCTSTR Data, LPDISPATCH* ImportMap, const VARIANT& Overwrite, const VARIANT& Destination) +{ + long result; + static BYTE parms[] = + VTS_BSTR VTS_PDISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8e5, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + Data, ImportMap, &Overwrite, &Destination); + return result; +} + +void _Workbook::SaveAsXMLData(LPCTSTR Filename, LPDISPATCH Map) +{ + static BYTE parms[] = + VTS_BSTR VTS_DISPATCH; + InvokeHelper(0x8e6, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename, Map); +} + +void _Workbook::ToggleFormsDesign() +{ + InvokeHelper(0x8e7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// Workbooks properties + +///////////////////////////////////////////////////////////////////////////// +// Workbooks operations + +LPDISPATCH Workbooks::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Workbooks::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Workbooks::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Workbooks::Add(const VARIANT& Template) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Template); + return result; +} + +void Workbooks::Close() +{ + InvokeHelper(0x115, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long Workbooks::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Workbooks::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Workbooks::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH Workbooks::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH Workbooks::Open(LPCTSTR Filename, const VARIANT& UpdateLinks, const VARIANT& ReadOnly, const VARIANT& Format, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& IgnoreReadOnlyRecommended, const VARIANT& Origin, + const VARIANT& Delimiter, const VARIANT& Editable, const VARIANT& Notify, const VARIANT& Converter, const VARIANT& AddToMru, const VARIANT& Local, const VARIANT& CorruptLoad) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x783, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Filename, &UpdateLinks, &ReadOnly, &Format, &Password, &WriteResPassword, &IgnoreReadOnlyRecommended, &Origin, &Delimiter, &Editable, &Notify, &Converter, &AddToMru, &Local, &CorruptLoad); + return result; +} + +void Workbooks::OpenText(LPCTSTR Filename, const VARIANT& Origin, const VARIANT& StartRow, const VARIANT& DataType, long TextQualifier, const VARIANT& ConsecutiveDelimiter, const VARIANT& Tab, const VARIANT& Semicolon, const VARIANT& Comma, + const VARIANT& Space, const VARIANT& Other, const VARIANT& OtherChar, const VARIANT& FieldInfo, const VARIANT& TextVisualLayout, const VARIANT& DecimalSeparator, const VARIANT& ThousandsSeparator, const VARIANT& TrailingMinusNumbers, + const VARIANT& Local) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x784, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename, &Origin, &StartRow, &DataType, TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo, &TextVisualLayout, &DecimalSeparator, &ThousandsSeparator, &TrailingMinusNumbers, &Local); +} + +LPDISPATCH Workbooks::OpenDatabase(LPCTSTR Filename, const VARIANT& CommandText, const VARIANT& CommandType, const VARIANT& BackgroundQuery, const VARIANT& ImportDataAs) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x813, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Filename, &CommandText, &CommandType, &BackgroundQuery, &ImportDataAs); + return result; +} + +void Workbooks::CheckOut(LPCTSTR Filename) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x815, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename); +} + +BOOL Workbooks::CanCheckOut(LPCTSTR Filename) +{ + BOOL result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x816, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + Filename); + return result; +} + +LPDISPATCH Workbooks::OpenXML(LPCTSTR Filename, const VARIANT& Stylesheets, const VARIANT& LoadOption) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8e8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Filename, &Stylesheets, &LoadOption); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PublishObject properties + +///////////////////////////////////////////////////////////////////////////// +// PublishObject operations + +LPDISPATCH PublishObject::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PublishObject::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PublishObject::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void PublishObject::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void PublishObject::Publish(const VARIANT& Create) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x767, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Create); +} + +CString PublishObject::GetDivID() +{ + CString result; + InvokeHelper(0x766, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString PublishObject::GetSheet() +{ + CString result; + InvokeHelper(0x2ef, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long PublishObject::GetSourceType() +{ + long result; + InvokeHelper(0x2ad, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString PublishObject::GetSource() +{ + CString result; + InvokeHelper(0xde, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long PublishObject::GetHtmlType() +{ + long result; + InvokeHelper(0x765, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PublishObject::SetHtmlType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x765, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString PublishObject::GetTitle() +{ + CString result; + InvokeHelper(0xc7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PublishObject::SetTitle(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xc7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PublishObject::GetFilename() +{ + CString result; + InvokeHelper(0x587, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PublishObject::SetFilename(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x587, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PublishObject::GetAutoRepublish() +{ + BOOL result; + InvokeHelper(0x882, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PublishObject::SetAutoRepublish(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x882, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// DefaultWebOptions properties + +///////////////////////////////////////////////////////////////////////////// +// DefaultWebOptions operations + +LPDISPATCH DefaultWebOptions::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DefaultWebOptions::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DefaultWebOptions::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DefaultWebOptions::GetRelyOnCSS() +{ + BOOL result; + InvokeHelper(0x76b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetRelyOnCSS(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x76b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetSaveHiddenData() +{ + BOOL result; + InvokeHelper(0x76c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetSaveHiddenData(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x76c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetLoadPictures() +{ + BOOL result; + InvokeHelper(0x76d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetLoadPictures(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x76d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetOrganizeInFolder() +{ + BOOL result; + InvokeHelper(0x76e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetOrganizeInFolder(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x76e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetUpdateLinksOnSave() +{ + BOOL result; + InvokeHelper(0x76f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetUpdateLinksOnSave(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x76f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetUseLongFileNames() +{ + BOOL result; + InvokeHelper(0x770, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetUseLongFileNames(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x770, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetCheckIfOfficeIsHTMLEditor() +{ + BOOL result; + InvokeHelper(0x771, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetCheckIfOfficeIsHTMLEditor(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x771, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetDownloadComponents() +{ + BOOL result; + InvokeHelper(0x772, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetDownloadComponents(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x772, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetRelyOnVML() +{ + BOOL result; + InvokeHelper(0x773, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetRelyOnVML(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x773, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DefaultWebOptions::GetAllowPNG() +{ + BOOL result; + InvokeHelper(0x774, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetAllowPNG(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x774, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long DefaultWebOptions::GetScreenSize() +{ + long result; + InvokeHelper(0x775, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetScreenSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x775, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long DefaultWebOptions::GetPixelsPerInch() +{ + long result; + InvokeHelper(0x776, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetPixelsPerInch(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x776, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DefaultWebOptions::GetLocationOfComponents() +{ + CString result; + InvokeHelper(0x777, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetLocationOfComponents(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x777, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long DefaultWebOptions::GetEncoding() +{ + long result; + InvokeHelper(0x71e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetEncoding(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x71e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL DefaultWebOptions::GetAlwaysSaveInDefaultEncoding() +{ + BOOL result; + InvokeHelper(0x778, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetAlwaysSaveInDefaultEncoding(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x778, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH DefaultWebOptions::GetFonts() +{ + LPDISPATCH result; + InvokeHelper(0x779, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DefaultWebOptions::GetFolderSuffix() +{ + CString result; + InvokeHelper(0x77a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long DefaultWebOptions::GetTargetBrowser() +{ + long result; + InvokeHelper(0x883, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetTargetBrowser(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x883, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL DefaultWebOptions::GetSaveNewWebPagesAsWebArchives() +{ + BOOL result; + InvokeHelper(0x884, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DefaultWebOptions::SetSaveNewWebPagesAsWebArchives(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x884, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// WebOptions properties + +///////////////////////////////////////////////////////////////////////////// +// WebOptions operations + +LPDISPATCH WebOptions::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long WebOptions::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH WebOptions::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL WebOptions::GetRelyOnCSS() +{ + BOOL result; + InvokeHelper(0x76b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void WebOptions::SetRelyOnCSS(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x76b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL WebOptions::GetOrganizeInFolder() +{ + BOOL result; + InvokeHelper(0x76e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void WebOptions::SetOrganizeInFolder(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x76e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL WebOptions::GetUseLongFileNames() +{ + BOOL result; + InvokeHelper(0x770, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void WebOptions::SetUseLongFileNames(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x770, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL WebOptions::GetDownloadComponents() +{ + BOOL result; + InvokeHelper(0x772, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void WebOptions::SetDownloadComponents(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x772, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL WebOptions::GetRelyOnVML() +{ + BOOL result; + InvokeHelper(0x773, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void WebOptions::SetRelyOnVML(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x773, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL WebOptions::GetAllowPNG() +{ + BOOL result; + InvokeHelper(0x774, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void WebOptions::SetAllowPNG(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x774, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long WebOptions::GetScreenSize() +{ + long result; + InvokeHelper(0x775, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void WebOptions::SetScreenSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x775, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long WebOptions::GetPixelsPerInch() +{ + long result; + InvokeHelper(0x776, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void WebOptions::SetPixelsPerInch(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x776, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString WebOptions::GetLocationOfComponents() +{ + CString result; + InvokeHelper(0x777, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void WebOptions::SetLocationOfComponents(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x777, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long WebOptions::GetEncoding() +{ + long result; + InvokeHelper(0x71e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void WebOptions::SetEncoding(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x71e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString WebOptions::GetFolderSuffix() +{ + CString result; + InvokeHelper(0x77a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void WebOptions::UseDefaultFolderSuffix() +{ + InvokeHelper(0x77b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long WebOptions::GetTargetBrowser() +{ + long result; + InvokeHelper(0x883, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void WebOptions::SetTargetBrowser(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x883, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// TreeviewControl properties + +///////////////////////////////////////////////////////////////////////////// +// TreeviewControl operations + +LPDISPATCH TreeviewControl::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long TreeviewControl::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TreeviewControl::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT TreeviewControl::GetHidden() +{ + VARIANT result; + InvokeHelper(0x10c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TreeviewControl::SetHidden(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x10c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT TreeviewControl::GetDrilled() +{ + VARIANT result; + InvokeHelper(0x77d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TreeviewControl::SetDrilled(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x77d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// CubeField properties + +///////////////////////////////////////////////////////////////////////////// +// CubeField operations + +LPDISPATCH CubeField::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CubeField::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CubeField::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CubeField::GetCubeFieldType() +{ + long result; + InvokeHelper(0x77e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString CubeField::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString CubeField::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString CubeField::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long CubeField::GetOrientation() +{ + long result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CubeField::SetOrientation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long CubeField::GetPosition() +{ + long result; + InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CubeField::SetPosition(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH CubeField::GetTreeviewControl() +{ + LPDISPATCH result; + InvokeHelper(0x77f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL CubeField::GetDragToColumn() +{ + BOOL result; + InvokeHelper(0x5e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CubeField::SetDragToColumn(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL CubeField::GetDragToHide() +{ + BOOL result; + InvokeHelper(0x5e5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CubeField::SetDragToHide(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL CubeField::GetDragToPage() +{ + BOOL result; + InvokeHelper(0x5e6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CubeField::SetDragToPage(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL CubeField::GetDragToRow() +{ + BOOL result; + InvokeHelper(0x5e7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CubeField::SetDragToRow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL CubeField::GetDragToData() +{ + BOOL result; + InvokeHelper(0x734, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CubeField::SetDragToData(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x734, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long CubeField::GetHiddenLevels() +{ + long result; + InvokeHelper(0x780, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CubeField::SetHiddenLevels(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x780, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL CubeField::GetHasMemberProperties() +{ + BOOL result; + InvokeHelper(0x885, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long CubeField::GetLayoutForm() +{ + long result; + InvokeHelper(0x738, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CubeField::SetLayoutForm(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x738, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH CubeField::GetPivotFields() +{ + LPDISPATCH result; + InvokeHelper(0x2ce, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void CubeField::AddMemberPropertyField(LPCTSTR Property_, const VARIANT& PropertyOrder) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x886, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Property_, &PropertyOrder); +} + +BOOL CubeField::GetEnableMultiplePageItems() +{ + BOOL result; + InvokeHelper(0x888, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CubeField::SetEnableMultiplePageItems(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x888, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long CubeField::GetLayoutSubtotalLocation() +{ + long result; + InvokeHelper(0x736, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CubeField::SetLayoutSubtotalLocation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x736, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL CubeField::GetShowInFieldList() +{ + BOOL result; + InvokeHelper(0x889, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CubeField::SetShowInFieldList(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x889, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void CubeField::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// CubeFields properties + +///////////////////////////////////////////////////////////////////////////// +// CubeFields operations + +LPDISPATCH CubeFields::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CubeFields::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CubeFields::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CubeFields::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CubeFields::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH CubeFields::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN CubeFields::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH CubeFields::AddSet(LPCTSTR Name, LPCTSTR Caption) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR; + InvokeHelper(0x88a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, Caption); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// MyFont properties + +///////////////////////////////////////////////////////////////////////////// +// MyFont operations + +LPDISPATCH MyFont::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long MyFont::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MyFont::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT MyFont::GetBackground() +{ + VARIANT result; + InvokeHelper(0xb4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetBackground(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetBold() +{ + VARIANT result; + InvokeHelper(0x60, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetBold(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x60, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetColor() +{ + VARIANT result; + InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetColor(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetColorIndex() +{ + VARIANT result; + InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetColorIndex(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetFontStyle() +{ + VARIANT result; + InvokeHelper(0xb1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetFontStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetItalic() +{ + VARIANT result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetItalic(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetName() +{ + VARIANT result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetName(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetOutlineFont() +{ + VARIANT result; + InvokeHelper(0xdd, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetOutlineFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xdd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetShadow() +{ + VARIANT result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetShadow(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetSize() +{ + VARIANT result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetSize(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetStrikethrough() +{ + VARIANT result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetStrikethrough(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetSubscript() +{ + VARIANT result; + InvokeHelper(0xb3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetSubscript(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetSuperscript() +{ + VARIANT result; + InvokeHelper(0xb2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetSuperscript(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT MyFont::GetUnderline() +{ + VARIANT result; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyFont::SetUnderline(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Window properties + +///////////////////////////////////////////////////////////////////////////// +// Window operations + +LPDISPATCH Window::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Window::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Window::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Window::Activate() +{ + VARIANT result; + InvokeHelper(0x130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Window::ActivateNext() +{ + VARIANT result; + InvokeHelper(0x45b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Window::ActivatePrevious() +{ + VARIANT result; + InvokeHelper(0x45c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Window::GetActiveCell() +{ + LPDISPATCH result; + InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Window::GetActiveChart() +{ + LPDISPATCH result; + InvokeHelper(0xb7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Window::GetActivePane() +{ + LPDISPATCH result; + InvokeHelper(0x282, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Window::GetActiveSheet() +{ + LPDISPATCH result; + InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Window::GetCaption() +{ + VARIANT result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Window::SetCaption(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Window::Close(const VARIANT& SaveChanges, const VARIANT& Filename, const VARIANT& RouteWorkbook) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x115, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &SaveChanges, &Filename, &RouteWorkbook); + return result; +} + +BOOL Window::GetDisplayFormulas() +{ + BOOL result; + InvokeHelper(0x284, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayFormulas(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x284, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetDisplayGridlines() +{ + BOOL result; + InvokeHelper(0x285, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayGridlines(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x285, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetDisplayHeadings() +{ + BOOL result; + InvokeHelper(0x286, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayHeadings(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x286, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetDisplayHorizontalScrollBar() +{ + BOOL result; + InvokeHelper(0x399, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayHorizontalScrollBar(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x399, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetDisplayOutline() +{ + BOOL result; + InvokeHelper(0x287, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayOutline(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x287, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetDisplayVerticalScrollBar() +{ + BOOL result; + InvokeHelper(0x39a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayVerticalScrollBar(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x39a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetDisplayWorkbookTabs() +{ + BOOL result; + InvokeHelper(0x39b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayWorkbookTabs(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x39b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetDisplayZeros() +{ + BOOL result; + InvokeHelper(0x289, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayZeros(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x289, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetEnableResize() +{ + BOOL result; + InvokeHelper(0x4a8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetEnableResize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4a8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Window::GetFreezePanes() +{ + BOOL result; + InvokeHelper(0x28a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetFreezePanes(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x28a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Window::GetGridlineColor() +{ + long result; + InvokeHelper(0x28b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Window::SetGridlineColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x28b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Window::GetGridlineColorIndex() +{ + long result; + InvokeHelper(0x28c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Window::SetGridlineColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x28c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +double Window::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Window::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Window::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Window::LargeScroll(const VARIANT& Down, const VARIANT& Up, const VARIANT& ToRight, const VARIANT& ToLeft) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x223, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Down, &Up, &ToRight, &ToLeft); + return result; +} + +double Window::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Window::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Window::NewWindow() +{ + LPDISPATCH result; + InvokeHelper(0x118, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Window::GetOnWindow() +{ + CString result; + InvokeHelper(0x26f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Window::SetOnWindow(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x26f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Window::GetPanes() +{ + LPDISPATCH result; + InvokeHelper(0x28d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Window::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); + return result; +} + +VARIANT Window::PrintPreview(const VARIANT& EnableChanges) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &EnableChanges); + return result; +} + +LPDISPATCH Window::GetRangeSelection() +{ + LPDISPATCH result; + InvokeHelper(0x4a5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Window::GetScrollColumn() +{ + long result; + InvokeHelper(0x28e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Window::SetScrollColumn(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x28e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Window::GetScrollRow() +{ + long result; + InvokeHelper(0x28f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Window::SetScrollRow(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x28f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Window::ScrollWorkbookTabs(const VARIANT& Sheets, const VARIANT& Position) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x296, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Sheets, &Position); + return result; +} + +LPDISPATCH Window::GetSelectedSheets() +{ + LPDISPATCH result; + InvokeHelper(0x290, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Window::GetSelection() +{ + LPDISPATCH result; + InvokeHelper(0x93, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Window::SmallScroll(const VARIANT& Down, const VARIANT& Up, const VARIANT& ToRight, const VARIANT& ToLeft) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x224, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Down, &Up, &ToRight, &ToLeft); + return result; +} + +BOOL Window::GetSplit() +{ + BOOL result; + InvokeHelper(0x291, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetSplit(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x291, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Window::GetSplitColumn() +{ + long result; + InvokeHelper(0x292, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Window::SetSplitColumn(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x292, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +double Window::GetSplitHorizontal() +{ + double result; + InvokeHelper(0x293, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Window::SetSplitHorizontal(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x293, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Window::GetSplitRow() +{ + long result; + InvokeHelper(0x294, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Window::SetSplitRow(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x294, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +double Window::GetSplitVertical() +{ + double result; + InvokeHelper(0x295, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Window::SetSplitVertical(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x295, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Window::GetTabRatio() +{ + double result; + InvokeHelper(0x2a1, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Window::SetTabRatio(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x2a1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Window::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Window::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Window::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Window::GetUsableHeight() +{ + double result; + InvokeHelper(0x185, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double Window::GetUsableWidth() +{ + double result; + InvokeHelper(0x186, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +BOOL Window::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Window::GetVisibleRange() +{ + LPDISPATCH result; + InvokeHelper(0x45e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +double Window::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Window::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Window::GetWindowNumber() +{ + long result; + InvokeHelper(0x45f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long Window::GetWindowState() +{ + long result; + InvokeHelper(0x18c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Window::SetWindowState(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x18c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Window::GetZoom() +{ + VARIANT result; + InvokeHelper(0x297, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Window::SetZoom(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x297, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Window::GetView() +{ + long result; + InvokeHelper(0x4aa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Window::SetView(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4aa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Window::GetDisplayRightToLeft() +{ + BOOL result; + InvokeHelper(0x6ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Window::SetDisplayRightToLeft(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x6ee, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Window::PointsToScreenPixelsX(long Points) +{ + long result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6f0, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + Points); + return result; +} + +long Window::PointsToScreenPixelsY(long Points) +{ + long result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6f1, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + Points); + return result; +} + +LPDISPATCH Window::RangeFromPoint(long x, long y) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x6f2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + x, y); + return result; +} + +void Window::ScrollIntoView(long Left, long Top, long Width, long Height, const VARIANT& Start) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x6f5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Left, Top, Width, Height, &Start); +} + + +///////////////////////////////////////////////////////////////////////////// +// Windows properties + +///////////////////////////////////////////////////////////////////////////// +// Windows operations + +LPDISPATCH Windows::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Windows::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Windows::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Windows::Arrange(long ArrangeStyle, const VARIANT& ActiveWorkbook, const VARIANT& SyncHorizontal, const VARIANT& SyncVertical) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + ArrangeStyle, &ActiveWorkbook, &SyncHorizontal, &SyncVertical); + return result; +} + +long Windows::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Windows::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Windows::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH Windows::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +BOOL Windows::CompareSideBySideWith(const VARIANT& WindowName) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x8c6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &WindowName); + return result; +} + +BOOL Windows::BreakSideBySide() +{ + BOOL result; + InvokeHelper(0x8c8, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Windows::GetSyncScrollingSideBySide() +{ + BOOL result; + InvokeHelper(0x8c9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Windows::SetSyncScrollingSideBySide(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8c9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void Windows::ResetPositionsSideBySide() +{ + InvokeHelper(0x8ca, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// AppEvents properties + +///////////////////////////////////////////////////////////////////////////// +// AppEvents operations + +void AppEvents::NewWorkbook(LPDISPATCH Wb) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x61d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb); +} + +void AppEvents::SheetSelectionChange(LPDISPATCH Sh, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x616, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target); +} + +void AppEvents::SheetBeforeDoubleClick(LPDISPATCH Sh, LPDISPATCH Target, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_PBOOL; + InvokeHelper(0x617, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target, Cancel); +} + +void AppEvents::SheetBeforeRightClick(LPDISPATCH Sh, LPDISPATCH Target, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_PBOOL; + InvokeHelper(0x618, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target, Cancel); +} + +void AppEvents::SheetActivate(LPDISPATCH Sh) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x619, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh); +} + +void AppEvents::SheetDeactivate(LPDISPATCH Sh) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x61a, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh); +} + +void AppEvents::SheetCalculate(LPDISPATCH Sh) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x61b, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh); +} + +void AppEvents::SheetChange(LPDISPATCH Sh, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x61c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target); +} + +void AppEvents::WorkbookOpen(LPDISPATCH Wb) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x61f, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb); +} + +void AppEvents::WorkbookActivate(LPDISPATCH Wb) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x620, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb); +} + +void AppEvents::WorkbookDeactivate(LPDISPATCH Wb) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x621, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb); +} + +void AppEvents::WorkbookBeforeClose(LPDISPATCH Wb, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_PBOOL; + InvokeHelper(0x622, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Cancel); +} + +void AppEvents::WorkbookBeforeSave(LPDISPATCH Wb, BOOL SaveAsUI, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_BOOL VTS_PBOOL; + InvokeHelper(0x623, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, SaveAsUI, Cancel); +} + +void AppEvents::WorkbookBeforePrint(LPDISPATCH Wb, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_PBOOL; + InvokeHelper(0x624, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Cancel); +} + +void AppEvents::WorkbookNewSheet(LPDISPATCH Wb, LPDISPATCH Sh) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x625, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Sh); +} + +void AppEvents::WorkbookAddinInstall(LPDISPATCH Wb) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x626, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb); +} + +void AppEvents::WorkbookAddinUninstall(LPDISPATCH Wb) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x627, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb); +} + +void AppEvents::WindowResize(LPDISPATCH Wb, LPDISPATCH Wn) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x612, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Wn); +} + +void AppEvents::WindowActivate(LPDISPATCH Wb, LPDISPATCH Wn) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x614, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Wn); +} + +void AppEvents::WindowDeactivate(LPDISPATCH Wb, LPDISPATCH Wn) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x615, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Wn); +} + +void AppEvents::SheetFollowHyperlink(LPDISPATCH Sh, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x73e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target); +} + +void AppEvents::SheetPivotTableUpdate(LPDISPATCH Sh, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x86d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target); +} + +void AppEvents::WorkbookPivotTableCloseConnection(LPDISPATCH Wb, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x870, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Target); +} + +void AppEvents::WorkbookPivotTableOpenConnection(LPDISPATCH Wb, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x871, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Target); +} + +void AppEvents::WorkbookSync(LPDISPATCH Wb, long SyncEventType) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0x8f1, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, SyncEventType); +} + +void AppEvents::WorkbookBeforeXmlImport(LPDISPATCH Wb, LPDISPATCH Map, LPCTSTR Url, BOOL IsRefresh, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_BSTR VTS_BOOL VTS_PBOOL; + InvokeHelper(0x8f2, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Map, Url, IsRefresh, Cancel); +} + +void AppEvents::WorkbookAfterXmlImport(LPDISPATCH Wb, LPDISPATCH Map, BOOL IsRefresh, long Result) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_BOOL VTS_I4; + InvokeHelper(0x8f3, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Map, IsRefresh, Result); +} + +void AppEvents::WorkbookBeforeXmlExport(LPDISPATCH Wb, LPDISPATCH Map, LPCTSTR Url, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_BSTR VTS_PBOOL; + InvokeHelper(0x8f4, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Map, Url, Cancel); +} + +void AppEvents::WorkbookAfterXmlExport(LPDISPATCH Wb, LPDISPATCH Map, LPCTSTR Url, long Result) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_BSTR VTS_I4; + InvokeHelper(0x8f5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wb, Map, Url, Result); +} + + +///////////////////////////////////////////////////////////////////////////// +// WorksheetFunction properties + +///////////////////////////////////////////////////////////////////////////// +// WorksheetFunction operations + +LPDISPATCH WorksheetFunction::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long WorksheetFunction::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH WorksheetFunction::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +double WorksheetFunction::Count(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4000, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +BOOL WorksheetFunction::IsNA(const VARIANT& Arg1) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x4002, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1); + return result; +} + +BOOL WorksheetFunction::IsError(const VARIANT& Arg1) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x4003, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1); + return result; +} + +double WorksheetFunction::Sum(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4004, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Average(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4005, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Min(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4006, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Max(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4007, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Npv(double Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x400b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::StDev(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x400c, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +CString WorksheetFunction::Dollar(double Arg1, const VARIANT& Arg2) +{ + CString result; + static BYTE parms[] = + VTS_R8 VTS_VARIANT; + InvokeHelper(0x400d, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1, &Arg2); + return result; +} + +CString WorksheetFunction::Fixed(double Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + CString result; + static BYTE parms[] = + VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x400e, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::Pi() +{ + double result; + InvokeHelper(0x4013, DISPATCH_METHOD, VT_R8, (void*)&result, NULL); + return result; +} + +double WorksheetFunction::Ln(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4016, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Log10(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4017, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Round(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x401b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +VARIANT WorksheetFunction::Lookup(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x401c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3); + return result; +} + +VARIANT WorksheetFunction::Index(const VARIANT& Arg1, double Arg2, const VARIANT& Arg3, const VARIANT& Arg4) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x401d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, Arg2, &Arg3, &Arg4); + return result; +} + +CString WorksheetFunction::Rept(LPCTSTR Arg1, double Arg2) +{ + CString result; + static BYTE parms[] = + VTS_BSTR VTS_R8; + InvokeHelper(0x401e, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +BOOL WorksheetFunction::And(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4024, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +BOOL WorksheetFunction::Or(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4025, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::DCount(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4028, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::DSum(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4029, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::DAverage(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x402a, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::DMin(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x402b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::DMax(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x402c, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::DStDev(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x402d, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::Var(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x402e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::DVar(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x402f, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +CString WorksheetFunction::Text(const VARIANT& Arg1, LPCTSTR Arg2) +{ + CString result; + static BYTE parms[] = + VTS_VARIANT VTS_BSTR; + InvokeHelper(0x4030, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + &Arg1, Arg2); + return result; +} + +VARIANT WorksheetFunction::LinEst(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4031, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4); + return result; +} + +VARIANT WorksheetFunction::Trend(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4032, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4); + return result; +} + +VARIANT WorksheetFunction::LogEst(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4033, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4); + return result; +} + +VARIANT WorksheetFunction::Growth(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4034, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4); + return result; +} + +double WorksheetFunction::Pv(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4038, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, &Arg4, &Arg5); + return result; +} + +double WorksheetFunction::Fv(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4039, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, &Arg4, &Arg5); + return result; +} + +double WorksheetFunction::NPer(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x403a, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, &Arg4, &Arg5); + return result; +} + +double WorksheetFunction::Pmt(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x403b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, &Arg4, &Arg5); + return result; +} + +double WorksheetFunction::Rate(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x403c, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, &Arg4, &Arg5, &Arg6); + return result; +} + +double WorksheetFunction::MIrr(const VARIANT& Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_R8 VTS_R8; + InvokeHelper(0x403d, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::Irr(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x403e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Match(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4040, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::Weekday(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4046, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Search(LPCTSTR Arg1, LPCTSTR Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_VARIANT; + InvokeHelper(0x4052, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, &Arg3); + return result; +} + +VARIANT WorksheetFunction::Transpose(const VARIANT& Arg1) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x4053, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1); + return result; +} + +double WorksheetFunction::Atan2(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x4061, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::Asin(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4062, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Acos(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4063, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +VARIANT WorksheetFunction::Choose(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4064, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +VARIANT WorksheetFunction::HLookup(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4065, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4); + return result; +} + +VARIANT WorksheetFunction::VLookup(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4066, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4); + return result; +} + +double WorksheetFunction::Log(double Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_VARIANT; + InvokeHelper(0x406d, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2); + return result; +} + +CString WorksheetFunction::Proper(LPCTSTR Arg1) +{ + CString result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x4072, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1); + return result; +} + +CString WorksheetFunction::Trim(LPCTSTR Arg1) +{ + CString result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x4076, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1); + return result; +} + +CString WorksheetFunction::Replace(LPCTSTR Arg1, double Arg2, double Arg3, LPCTSTR Arg4) +{ + CString result; + static BYTE parms[] = + VTS_BSTR VTS_R8 VTS_R8 VTS_BSTR; + InvokeHelper(0x4077, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +CString WorksheetFunction::Substitute(LPCTSTR Arg1, LPCTSTR Arg2, LPCTSTR Arg3, const VARIANT& Arg4) +{ + CString result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_BSTR VTS_VARIANT; + InvokeHelper(0x4078, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1, Arg2, Arg3, &Arg4); + return result; +} + +double WorksheetFunction::Find(LPCTSTR Arg1, LPCTSTR Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_VARIANT; + InvokeHelper(0x407c, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, &Arg3); + return result; +} + +BOOL WorksheetFunction::IsErr(const VARIANT& Arg1) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x407e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1); + return result; +} + +BOOL WorksheetFunction::IsText(const VARIANT& Arg1) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x407f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1); + return result; +} + +BOOL WorksheetFunction::IsNumber(const VARIANT& Arg1) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x4080, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1); + return result; +} + +double WorksheetFunction::Sln(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x408e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::Syd(double Arg1, double Arg2, double Arg3, double Arg4) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x408f, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +double WorksheetFunction::Ddb(double Arg1, double Arg2, double Arg3, double Arg4, const VARIANT& Arg5) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT; + InvokeHelper(0x4090, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4, &Arg5); + return result; +} + +CString WorksheetFunction::Clean(LPCTSTR Arg1) +{ + CString result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x40a2, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::MDeterm(const VARIANT& Arg1) +{ + double result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x40a3, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1); + return result; +} + +VARIANT WorksheetFunction::MInverse(const VARIANT& Arg1) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x40a4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1); + return result; +} + +VARIANT WorksheetFunction::MMult(const VARIANT& Arg1, const VARIANT& Arg2) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40a5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Ipmt(double Arg1, double Arg2, double Arg3, double Arg4, const VARIANT& Arg5, const VARIANT& Arg6) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40a7, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4, &Arg5, &Arg6); + return result; +} + +double WorksheetFunction::Ppmt(double Arg1, double Arg2, double Arg3, double Arg4, const VARIANT& Arg5, const VARIANT& Arg6) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40a8, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4, &Arg5, &Arg6); + return result; +} + +double WorksheetFunction::CountA(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40a9, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Product(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40b7, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Fact(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x40b8, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::DProduct(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40bd, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +BOOL WorksheetFunction::IsNonText(const VARIANT& Arg1) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x40be, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1); + return result; +} + +double WorksheetFunction::StDevP(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40c1, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::VarP(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40c2, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::DStDevP(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40c3, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::DVarP(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40c4, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +BOOL WorksheetFunction::IsLogical(const VARIANT& Arg1) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x40c6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1); + return result; +} + +double WorksheetFunction::DCountA(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40c7, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +CString WorksheetFunction::USDollar(double Arg1, double Arg2) +{ + CString result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x40cc, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::FindB(LPCTSTR Arg1, LPCTSTR Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_VARIANT; + InvokeHelper(0x40cd, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, &Arg3); + return result; +} + +double WorksheetFunction::SearchB(LPCTSTR Arg1, LPCTSTR Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_VARIANT; + InvokeHelper(0x40ce, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, &Arg3); + return result; +} + +CString WorksheetFunction::ReplaceB(LPCTSTR Arg1, double Arg2, double Arg3, LPCTSTR Arg4) +{ + CString result; + static BYTE parms[] = + VTS_BSTR VTS_R8 VTS_R8 VTS_BSTR; + InvokeHelper(0x40cf, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +double WorksheetFunction::RoundUp(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x40d4, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::RoundDown(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x40d5, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::Rank(double Arg1, LPDISPATCH Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_DISPATCH VTS_VARIANT; + InvokeHelper(0x40d8, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, &Arg3); + return result; +} + +double WorksheetFunction::Days360(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40dc, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::Vdb(double Arg1, double Arg2, double Arg3, double Arg4, double Arg5, const VARIANT& Arg6, const VARIANT& Arg7) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40de, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4, Arg5, &Arg6, &Arg7); + return result; +} + +double WorksheetFunction::Median(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40e3, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::SumProduct(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40e4, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Sinh(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x40e5, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Cosh(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x40e6, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Tanh(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x40e7, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Asinh(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x40e8, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Acosh(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x40e9, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Atanh(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x40ea, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +VARIANT WorksheetFunction::DGet(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + VARIANT result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40eb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::Db(double Arg1, double Arg2, double Arg3, double Arg4, const VARIANT& Arg5) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT; + InvokeHelper(0x40f7, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4, &Arg5); + return result; +} + +VARIANT WorksheetFunction::Frequency(const VARIANT& Arg1, const VARIANT& Arg2) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x40fc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::AveDev(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x410d, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::BetaDist(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x410e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, &Arg4, &Arg5); + return result; +} + +double WorksheetFunction::GammaLn(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x410f, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::BetaInv(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4110, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, &Arg4, &Arg5); + return result; +} + +double WorksheetFunction::BinomDist(double Arg1, double Arg2, double Arg3, BOOL Arg4) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_BOOL; + InvokeHelper(0x4111, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +double WorksheetFunction::ChiDist(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x4112, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::ChiInv(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x4113, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::Combin(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x4114, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::Confidence(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4115, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::CritBinom(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4116, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::Even(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4117, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::ExponDist(double Arg1, double Arg2, BOOL Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_BOOL; + InvokeHelper(0x4118, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::FDist(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4119, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::FInv(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x411a, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::Fisher(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x411b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::FisherInv(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x411c, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Floor(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x411d, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::GammaDist(double Arg1, double Arg2, double Arg3, BOOL Arg4) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_BOOL; + InvokeHelper(0x411e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +double WorksheetFunction::GammaInv(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x411f, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::Ceiling(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x4120, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::HypGeomDist(double Arg1, double Arg2, double Arg3, double Arg4) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4121, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +double WorksheetFunction::LogNormDist(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4122, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::LogInv(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4123, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::NegBinomDist(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4124, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::NormDist(double Arg1, double Arg2, double Arg3, BOOL Arg4) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_BOOL; + InvokeHelper(0x4125, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +double WorksheetFunction::NormSDist(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4126, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::NormInv(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4127, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::NormSInv(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4128, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Standardize(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x4129, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::Odd(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x412a, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Permut(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x412b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::Poisson(double Arg1, double Arg2, BOOL Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_BOOL; + InvokeHelper(0x412c, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::TDist(double Arg1, double Arg2, double Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x412d, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3); + return result; +} + +double WorksheetFunction::Weibull(double Arg1, double Arg2, double Arg3, BOOL Arg4) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_BOOL; + InvokeHelper(0x412e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +double WorksheetFunction::SumXMY2(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x412f, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::SumX2MY2(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4130, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::SumX2PY2(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4131, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::ChiTest(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4132, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Correl(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4133, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Covar(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4134, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Forecast(double Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4135, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::FTest(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4136, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Intercept(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4137, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Pearson(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4138, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::RSq(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4139, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::StEyx(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x413a, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::Slope(const VARIANT& Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x413b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2); + return result; +} + +double WorksheetFunction::TTest(const VARIANT& Arg1, const VARIANT& Arg2, double Arg3, double Arg4) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_R8 VTS_R8; + InvokeHelper(0x413c, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, Arg3, Arg4); + return result; +} + +double WorksheetFunction::Prob(const VARIANT& Arg1, const VARIANT& Arg2, double Arg3, const VARIANT& Arg4) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_R8 VTS_VARIANT; + InvokeHelper(0x413d, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, Arg3, &Arg4); + return result; +} + +double WorksheetFunction::DevSq(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x413e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::GeoMean(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x413f, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::HarMean(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4140, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::SumSq(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4141, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Kurt(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4142, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::Skew(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4143, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::ZTest(const VARIANT& Arg1, double Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_R8 VTS_VARIANT; + InvokeHelper(0x4144, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, Arg2, &Arg3); + return result; +} + +double WorksheetFunction::Large(const VARIANT& Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_R8; + InvokeHelper(0x4145, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, Arg2); + return result; +} + +double WorksheetFunction::Small(const VARIANT& Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_R8; + InvokeHelper(0x4146, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, Arg2); + return result; +} + +double WorksheetFunction::Quartile(const VARIANT& Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_R8; + InvokeHelper(0x4147, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, Arg2); + return result; +} + +double WorksheetFunction::Percentile(const VARIANT& Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_R8; + InvokeHelper(0x4148, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, Arg2); + return result; +} + +double WorksheetFunction::PercentRank(const VARIANT& Arg1, double Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_R8 VTS_VARIANT; + InvokeHelper(0x4149, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, Arg2, &Arg3); + return result; +} + +double WorksheetFunction::Mode(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x414a, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::TrimMean(const VARIANT& Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_VARIANT VTS_R8; + InvokeHelper(0x414b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + &Arg1, Arg2); + return result; +} + +double WorksheetFunction::TInv(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x414c, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::Power(double Arg1, double Arg2) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x4151, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2); + return result; +} + +double WorksheetFunction::Radians(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4156, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Degrees(double Arg1) +{ + double result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4157, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Subtotal(double Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4158, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +double WorksheetFunction::SumIf(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x4159, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2, &Arg3); + return result; +} + +double WorksheetFunction::CountIf(LPDISPATCH Arg1, const VARIANT& Arg2) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT; + InvokeHelper(0x415a, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, &Arg2); + return result; +} + +double WorksheetFunction::CountBlank(LPDISPATCH Arg1) +{ + double result; + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x415b, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1); + return result; +} + +double WorksheetFunction::Ispmt(double Arg1, double Arg2, double Arg3, double Arg4) +{ + double result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0x415e, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Arg1, Arg2, Arg3, Arg4); + return result; +} + +CString WorksheetFunction::Roman(double Arg1, const VARIANT& Arg2) +{ + CString result; + static BYTE parms[] = + VTS_R8 VTS_VARIANT; + InvokeHelper(0x4162, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1, &Arg2); + return result; +} + +CString WorksheetFunction::Asc(LPCTSTR Arg1) +{ + CString result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x40d6, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1); + return result; +} + +CString WorksheetFunction::Dbcs(LPCTSTR Arg1) +{ + CString result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x40d7, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1); + return result; +} + +CString WorksheetFunction::Phonetic(LPDISPATCH Arg1) +{ + CString result; + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x4168, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1); + return result; +} + +CString WorksheetFunction::BahtText(double Arg1) +{ + CString result; + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x4170, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + Arg1); + return result; +} + +VARIANT WorksheetFunction::RTD(const VARIANT& progID, const VARIANT& server, const VARIANT& topic1, const VARIANT& topic2, const VARIANT& topic3, const VARIANT& topic4, const VARIANT& topic5, const VARIANT& topic6, const VARIANT& topic7, const VARIANT& topic8, + const VARIANT& topic9, const VARIANT& topic10, const VARIANT& topic11, const VARIANT& topic12, const VARIANT& topic13, const VARIANT& topic14, const VARIANT& topic15, const VARIANT& topic16, const VARIANT& topic17, const VARIANT& topic18, + const VARIANT& topic19, const VARIANT& topic20, const VARIANT& topic21, const VARIANT& topic22, const VARIANT& topic23, const VARIANT& topic24, const VARIANT& topic25, const VARIANT& topic26, const VARIANT& topic27, + const VARIANT& topic28) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x417b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &progID, &server, &topic1, &topic2, &topic3, &topic4, &topic5, &topic6, &topic7, &topic8, &topic9, &topic10, &topic11, &topic12, &topic13, &topic14, &topic15, &topic16, &topic17, &topic18, &topic19, &topic20, &topic21, &topic22, &topic23, + &topic24, &topic25, &topic26, &topic27, &topic28); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Range properties + +///////////////////////////////////////////////////////////////////////////// +// Range operations + +LPDISPATCH Range::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Range::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::Activate() +{ + VARIANT result; + InvokeHelper(0x130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetAddIndent() +{ + VARIANT result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetAddIndent(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Range::GetAddress(const VARIANT& RowAbsolute, const VARIANT& ColumnAbsolute, long ReferenceStyle, const VARIANT& External, const VARIANT& RelativeTo) +{ + CString result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xec, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms, + &RowAbsolute, &ColumnAbsolute, ReferenceStyle, &External, &RelativeTo); + return result; +} + +CString Range::GetAddressLocal(const VARIANT& RowAbsolute, const VARIANT& ColumnAbsolute, long ReferenceStyle, const VARIANT& External, const VARIANT& RelativeTo) +{ + CString result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1b5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms, + &RowAbsolute, &ColumnAbsolute, ReferenceStyle, &External, &RelativeTo); + return result; +} + +VARIANT Range::AdvancedFilter(long Action, const VARIANT& CriteriaRange, const VARIANT& CopyToRange, const VARIANT& Unique) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x36c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Action, &CriteriaRange, &CopyToRange, &Unique); + return result; +} + +VARIANT Range::ApplyNames(const VARIANT& Names, const VARIANT& IgnoreRelativeAbsolute, const VARIANT& UseRowColumnNames, const VARIANT& OmitColumn, const VARIANT& OmitRow, long Order, const VARIANT& AppendLast) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT; + InvokeHelper(0x1b9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Names, &IgnoreRelativeAbsolute, &UseRowColumnNames, &OmitColumn, &OmitRow, Order, &AppendLast); + return result; +} + +VARIANT Range::ApplyOutlineStyles() +{ + VARIANT result; + InvokeHelper(0x1c0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetAreas() +{ + LPDISPATCH result; + InvokeHelper(0x238, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Range::AutoComplete(LPCTSTR String) +{ + CString result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x4a1, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + String); + return result; +} + +VARIANT Range::AutoFill(LPDISPATCH Destination, long Type) +{ + VARIANT result; + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0x1c1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Destination, Type); + return result; +} + +VARIANT Range::AutoFilter(const VARIANT& Field, const VARIANT& Criteria1, long Operator, const VARIANT& Criteria2, const VARIANT& VisibleDropDown) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x319, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Field, &Criteria1, Operator, &Criteria2, &VisibleDropDown); + return result; +} + +VARIANT Range::AutoFit() +{ + VARIANT result; + InvokeHelper(0xed, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::AutoFormat(long Format, const VARIANT& Number, const VARIANT& MyFont, const VARIANT& Alignment, const VARIANT& Border, const VARIANT& Pattern, const VARIANT& Width) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x72, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Format, &Number, &MyFont, &Alignment, &Border, &Pattern, &Width); + return result; +} + +VARIANT Range::AutoOutline() +{ + VARIANT result; + InvokeHelper(0x40c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::BorderAround(const VARIANT& LineStyle, long Weight, long ColorIndex, const VARIANT& Color) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x42b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &LineStyle, Weight, ColorIndex, &Color); + return result; +} + +LPDISPATCH Range::GetBorders() +{ + LPDISPATCH result; + InvokeHelper(0x1b3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::Calculate() +{ + VARIANT result; + InvokeHelper(0x117, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetCells() +{ + LPDISPATCH result; + InvokeHelper(0xee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Range::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +VARIANT Range::Clear() +{ + VARIANT result; + InvokeHelper(0x6f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::ClearContents() +{ + VARIANT result; + InvokeHelper(0x71, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::ClearNotes() +{ + VARIANT result; + InvokeHelper(0xef, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::ClearOutline() +{ + VARIANT result; + InvokeHelper(0x40d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Range::GetColumn() +{ + long result; + InvokeHelper(0xf0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::ColumnDifferences(const VARIANT& Comparison) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x1fe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Comparison); + return result; +} + +LPDISPATCH Range::GetColumns() +{ + LPDISPATCH result; + InvokeHelper(0xf1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetColumnWidth() +{ + VARIANT result; + InvokeHelper(0xf2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetColumnWidth(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xf2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::Consolidate(const VARIANT& Sources, const VARIANT& Function, const VARIANT& TopRow, const VARIANT& LeftColumn, const VARIANT& CreateLinks) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1e2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Sources, &Function, &TopRow, &LeftColumn, &CreateLinks); + return result; +} + +VARIANT Range::Copy(const VARIANT& Destination) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Destination); + return result; +} + +long Range::CopyFromRecordset(LPUNKNOWN Data, const VARIANT& MaxRows, const VARIANT& MaxColumns) +{ + long result; + static BYTE parms[] = + VTS_UNKNOWN VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x480, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + Data, &MaxRows, &MaxColumns); + return result; +} + +VARIANT Range::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +long Range::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Range::CreateNames(const VARIANT& Top, const VARIANT& Left, const VARIANT& Bottom, const VARIANT& Right) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1c9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Top, &Left, &Bottom, &Right); + return result; +} + +VARIANT Range::CreatePublisher(const VARIANT& Edition, long Appearance, const VARIANT& ContainsPICT, const VARIANT& ContainsBIFF, const VARIANT& ContainsRTF, const VARIANT& ContainsVALU) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1ca, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Edition, Appearance, &ContainsPICT, &ContainsBIFF, &ContainsRTF, &ContainsVALU); + return result; +} + +LPDISPATCH Range::GetCurrentArray() +{ + LPDISPATCH result; + InvokeHelper(0x1f5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetCurrentRegion() +{ + LPDISPATCH result; + InvokeHelper(0xf3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::Cut(const VARIANT& Destination) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Destination); + return result; +} + +VARIANT Range::DataSeries(const VARIANT& Rowcol, long Type, long Date, const VARIANT& Step, const VARIANT& Stop, const VARIANT& Trend) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1d0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Rowcol, Type, Date, &Step, &Stop, &Trend); + return result; +} + +VARIANT Range::Get_Default(const VARIANT& RowIndex, const VARIANT& ColumnIndex) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &RowIndex, &ColumnIndex); + return result; +} + +void Range::Set_Default(const VARIANT& RowIndex, const VARIANT& ColumnIndex, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &RowIndex, &ColumnIndex, &newValue); +} + +VARIANT Range::Delete(const VARIANT& Shift) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Shift); + return result; +} + +LPDISPATCH Range::GetDependents() +{ + LPDISPATCH result; + InvokeHelper(0x21f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::DialogBox_() +{ + VARIANT result; + InvokeHelper(0xf5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetDirectDependents() +{ + LPDISPATCH result; + InvokeHelper(0x221, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetDirectPrecedents() +{ + LPDISPATCH result; + InvokeHelper(0x222, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::EditionOptions(long Type, long Option, const VARIANT& Name, const VARIANT& Reference, long Appearance, long ChartSize, const VARIANT& Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x46b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Type, Option, &Name, &Reference, Appearance, ChartSize, &Format); + return result; +} + +LPDISPATCH Range::GetEnd(long Direction) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1f4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Direction); + return result; +} + +LPDISPATCH Range::GetEntireColumn() +{ + LPDISPATCH result; + InvokeHelper(0xf6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetEntireRow() +{ + LPDISPATCH result; + InvokeHelper(0xf7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::FillDown() +{ + VARIANT result; + InvokeHelper(0xf8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::FillLeft() +{ + VARIANT result; + InvokeHelper(0xf9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::FillRight() +{ + VARIANT result; + InvokeHelper(0xfa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::FillUp() +{ + VARIANT result; + InvokeHelper(0xfb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::Find(const VARIANT& What, const VARIANT& After, const VARIANT& LookIn, const VARIANT& LookAt, const VARIANT& SearchOrder, long SearchDirection, const VARIANT& MatchCase, const VARIANT& MatchByte, const VARIANT& SearchFormat) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x18e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &What, &After, &LookIn, &LookAt, &SearchOrder, SearchDirection, &MatchCase, &MatchByte, &SearchFormat); + return result; +} + +LPDISPATCH Range::FindNext(const VARIANT& After) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x18f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &After); + return result; +} + +LPDISPATCH Range::FindPrevious(const VARIANT& After) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x190, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &After); + return result; +} + +LPDISPATCH Range::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetFormula() +{ + VARIANT result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetFormula(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetFormulaArray() +{ + VARIANT result; + InvokeHelper(0x24a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetFormulaArray(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x24a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Range::GetFormulaLabel() +{ + long result; + InvokeHelper(0x564, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Range::SetFormulaLabel(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x564, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Range::GetFormulaHidden() +{ + VARIANT result; + InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetFormulaHidden(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x106, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetFormulaLocal() +{ + VARIANT result; + InvokeHelper(0x107, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetFormulaLocal(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x107, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetFormulaR1C1() +{ + VARIANT result; + InvokeHelper(0x108, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetFormulaR1C1(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x108, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetFormulaR1C1Local() +{ + VARIANT result; + InvokeHelper(0x109, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetFormulaR1C1Local(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x109, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::FunctionWizard() +{ + VARIANT result; + InvokeHelper(0x23b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL Range::GoalSeek(const VARIANT& Goal, LPDISPATCH ChangingCell) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT VTS_DISPATCH; + InvokeHelper(0x1d8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Goal, ChangingCell); + return result; +} + +VARIANT Range::Group(const VARIANT& Start, const VARIANT& End, const VARIANT& By, const VARIANT& Periods) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Start, &End, &By, &Periods); + return result; +} + +VARIANT Range::GetHasArray() +{ + VARIANT result; + InvokeHelper(0x10a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetHasFormula() +{ + VARIANT result; + InvokeHelper(0x10b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetHeight() +{ + VARIANT result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetHidden() +{ + VARIANT result; + InvokeHelper(0x10c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetHidden(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x10c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetIndentLevel() +{ + VARIANT result; + InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetIndentLevel(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xc9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +void Range::InsertIndent(long InsertAmount) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x565, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + InsertAmount); +} + +VARIANT Range::Insert(const VARIANT& Shift, const VARIANT& CopyOrigin) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xfc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Shift, &CopyOrigin); + return result; +} + +LPDISPATCH Range::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetItem(const VARIANT& RowIndex, const VARIANT& ColumnIndex) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &RowIndex, &ColumnIndex); + return result; +} + +void Range::SetItem(const VARIANT& RowIndex, const VARIANT& ColumnIndex, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &RowIndex, &ColumnIndex, &newValue); +} + +VARIANT Range::Justify() +{ + VARIANT result; + InvokeHelper(0x1ef, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetLeft() +{ + VARIANT result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Range::GetListHeaderRows() +{ + long result; + InvokeHelper(0x4a3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Range::ListNames() +{ + VARIANT result; + InvokeHelper(0xfd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Range::GetLocationInTable() +{ + long result; + InvokeHelper(0x2b3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetLocked() +{ + VARIANT result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetLocked(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +void Range::Merge(const VARIANT& Across) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x234, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Across); +} + +void Range::UnMerge() +{ + InvokeHelper(0x568, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Range::GetMergeArea() +{ + LPDISPATCH result; + InvokeHelper(0x569, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetMergeCells() +{ + VARIANT result; + InvokeHelper(0xd0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetMergeCells(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetName() +{ + VARIANT result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetName(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::NavigateArrow(const VARIANT& TowardPrecedent, const VARIANT& ArrowNumber, const VARIANT& LinkNumber) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x408, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &TowardPrecedent, &ArrowNumber, &LinkNumber); + return result; +} + +LPUNKNOWN Range::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetNext() +{ + LPDISPATCH result; + InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Range::NoteText(const VARIANT& Text, const VARIANT& Start, const VARIANT& Length) +{ + CString result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x467, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + &Text, &Start, &Length); + return result; +} + +VARIANT Range::GetNumberFormat() +{ + VARIANT result; + InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetNumberFormat(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetNumberFormatLocal() +{ + VARIANT result; + InvokeHelper(0x449, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetNumberFormatLocal(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x449, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Range::GetOffset(const VARIANT& RowOffset, const VARIANT& ColumnOffset) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xfe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &RowOffset, &ColumnOffset); + return result; +} + +VARIANT Range::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetOutlineLevel() +{ + VARIANT result; + InvokeHelper(0x10f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetOutlineLevel(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x10f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Range::GetPageBreak() +{ + long result; + InvokeHelper(0xff, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Range::SetPageBreak(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xff, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Range::Parse(const VARIANT& ParseLine, const VARIANT& Destination) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1dd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &ParseLine, &Destination); + return result; +} + +LPDISPATCH Range::GetPivotField() +{ + LPDISPATCH result; + InvokeHelper(0x2db, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetPivotItem() +{ + LPDISPATCH result; + InvokeHelper(0x2e4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetPivotTable() +{ + LPDISPATCH result; + InvokeHelper(0x2cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetPrecedents() +{ + LPDISPATCH result; + InvokeHelper(0x220, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetPrefixCharacter() +{ + VARIANT result; + InvokeHelper(0x1f8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetPrevious() +{ + LPDISPATCH result; + InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::_PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x389, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate); + return result; +} + +VARIANT Range::PrintPreview(const VARIANT& EnableChanges) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &EnableChanges); + return result; +} + +LPDISPATCH Range::GetQueryTable() +{ + LPDISPATCH result; + InvokeHelper(0x56a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetRange(const VARIANT& Cell1, const VARIANT& Cell2) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Cell1, &Cell2); + return result; +} + +VARIANT Range::RemoveSubtotal() +{ + VARIANT result; + InvokeHelper(0x373, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL Range::Replace(const VARIANT& What, const VARIANT& Replacement, const VARIANT& LookAt, const VARIANT& SearchOrder, const VARIANT& MatchCase, const VARIANT& MatchByte, const VARIANT& SearchFormat, const VARIANT& ReplaceFormat) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xe2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &What, &Replacement, &LookAt, &SearchOrder, &MatchCase, &MatchByte, &SearchFormat, &ReplaceFormat); + return result; +} + +LPDISPATCH Range::GetResize(const VARIANT& RowSize, const VARIANT& ColumnSize) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x100, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &RowSize, &ColumnSize); + return result; +} + +long Range::GetRow() +{ + long result; + InvokeHelper(0x101, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::RowDifferences(const VARIANT& Comparison) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x1ff, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Comparison); + return result; +} + +VARIANT Range::GetRowHeight() +{ + VARIANT result; + InvokeHelper(0x110, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetRowHeight(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x110, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Range::GetRows() +{ + LPDISPATCH result; + InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::Run(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x103, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + +VARIANT Range::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::Show() +{ + VARIANT result; + InvokeHelper(0x1f0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::ShowDependents(const VARIANT& Remove) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x36d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Remove); + return result; +} + +VARIANT Range::GetShowDetail() +{ + VARIANT result; + InvokeHelper(0x249, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetShowDetail(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x249, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::ShowErrors() +{ + VARIANT result; + InvokeHelper(0x36e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::ShowPrecedents(const VARIANT& Remove) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x36f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Remove); + return result; +} + +VARIANT Range::GetShrinkToFit() +{ + VARIANT result; + InvokeHelper(0xd1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetShrinkToFit(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::Sort(const VARIANT& Key1, long Order1, const VARIANT& Key2, const VARIANT& Type, long Order2, const VARIANT& Key3, long Order3, long Header, const VARIANT& OrderCustom, const VARIANT& MatchCase, long Orientation, long SortMethod, + long DataOption1, long DataOption2, long DataOption3) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x370, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Key1, Order1, &Key2, &Type, Order2, &Key3, Order3, Header, &OrderCustom, &MatchCase, Orientation, SortMethod, DataOption1, DataOption2, DataOption3); + return result; +} + +VARIANT Range::SortSpecial(long SortMethod, const VARIANT& Key1, long Order1, const VARIANT& Type, const VARIANT& Key2, long Order2, const VARIANT& Key3, long Order3, long Header, const VARIANT& OrderCustom, const VARIANT& MatchCase, + long Orientation, long DataOption1, long DataOption2, long DataOption3) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x371, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + SortMethod, &Key1, Order1, &Type, &Key2, Order2, &Key3, Order3, Header, &OrderCustom, &MatchCase, Orientation, DataOption1, DataOption2, DataOption3); + return result; +} + +LPDISPATCH Range::GetSoundNote() +{ + LPDISPATCH result; + InvokeHelper(0x394, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::SpecialCells(long Type, const VARIANT& Value) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x19a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, &Value); + return result; +} + +VARIANT Range::GetStyle() +{ + VARIANT result; + InvokeHelper(0x104, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x104, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::SubscribeTo(LPCTSTR Edition, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR VTS_I4; + InvokeHelper(0x1e1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Edition, Format); + return result; +} + +VARIANT Range::Subtotal(long GroupBy, long Function, const VARIANT& TotalList, const VARIANT& Replace, const VARIANT& PageBreaks, long SummaryBelowData) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4; + InvokeHelper(0x372, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + GroupBy, Function, &TotalList, &Replace, &PageBreaks, SummaryBelowData); + return result; +} + +VARIANT Range::GetSummary() +{ + VARIANT result; + InvokeHelper(0x111, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::Table(const VARIANT& RowInput, const VARIANT& ColumnInput) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &RowInput, &ColumnInput); + return result; +} + +VARIANT Range::GetText() +{ + VARIANT result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::TextToColumns(const VARIANT& Destination, long DataType, long TextQualifier, const VARIANT& ConsecutiveDelimiter, const VARIANT& Tab, const VARIANT& Semicolon, const VARIANT& Comma, const VARIANT& Space, const VARIANT& Other, + const VARIANT& OtherChar, const VARIANT& FieldInfo, const VARIANT& DecimalSeparator, const VARIANT& ThousandsSeparator, const VARIANT& TrailingMinusNumbers) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x410, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Destination, DataType, TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo, &DecimalSeparator, &ThousandsSeparator, &TrailingMinusNumbers); + return result; +} + +VARIANT Range::GetTop() +{ + VARIANT result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::Ungroup() +{ + VARIANT result; + InvokeHelper(0xf4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetUseStandardHeight() +{ + VARIANT result; + InvokeHelper(0x112, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetUseStandardHeight(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x112, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetUseStandardWidth() +{ + VARIANT result; + InvokeHelper(0x113, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetUseStandardWidth(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x113, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Range::GetValidation() +{ + LPDISPATCH result; + InvokeHelper(0x56b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetValue(const VARIANT& RangeValueDataType) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &RangeValueDataType); + return result; +} + +void Range::SetValue(const VARIANT& RangeValueDataType, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &RangeValueDataType, &newValue); +} + +VARIANT Range::GetValue2() +{ + VARIANT result; + InvokeHelper(0x56c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetValue2(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x56c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Range::GetWidth() +{ + VARIANT result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetWorksheet() +{ + LPDISPATCH result; + InvokeHelper(0x15c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Range::GetWrapText() +{ + VARIANT result; + InvokeHelper(0x114, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Range::SetWrapText(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x114, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Range::AddComment(const VARIANT& Text) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x56d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Text); + return result; +} + +LPDISPATCH Range::GetComment() +{ + LPDISPATCH result; + InvokeHelper(0x38e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Range::ClearComments() +{ + InvokeHelper(0x56e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Range::GetPhonetic() +{ + LPDISPATCH result; + InvokeHelper(0x56f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetFormatConditions() +{ + LPDISPATCH result; + InvokeHelper(0x570, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Range::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Range::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Range::GetHyperlinks() +{ + LPDISPATCH result; + InvokeHelper(0x571, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetPhonetics() +{ + LPDISPATCH result; + InvokeHelper(0x713, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Range::SetPhonetic() +{ + InvokeHelper(0x714, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString Range::GetId() +{ + CString result; + InvokeHelper(0x715, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Range::SetId(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x715, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Range::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); + return result; +} + +LPDISPATCH Range::GetPivotCell() +{ + LPDISPATCH result; + InvokeHelper(0x7dd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Range::Dirty() +{ + InvokeHelper(0x7de, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Range::GetErrors() +{ + LPDISPATCH result; + InvokeHelper(0x7df, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetSmartTags() +{ + LPDISPATCH result; + InvokeHelper(0x7e0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Range::Speak(const VARIANT& SpeakDirection, const VARIANT& SpeakFormulas) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7e1, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &SpeakDirection, &SpeakFormulas); +} + +VARIANT Range::PasteSpecial(long Paste, long Operation, const VARIANT& SkipBlanks, const VARIANT& Transpose) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x788, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Paste, Operation, &SkipBlanks, &Transpose); + return result; +} + +BOOL Range::GetAllowEdit() +{ + BOOL result; + InvokeHelper(0x7e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetListObject() +{ + LPDISPATCH result; + InvokeHelper(0x8d1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Range::GetXPath() +{ + LPDISPATCH result; + InvokeHelper(0x8d2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartEvents properties + +///////////////////////////////////////////////////////////////////////////// +// ChartEvents operations + +void ChartEvents::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ChartEvents::Deactivate() +{ + InvokeHelper(0x5fa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ChartEvents::Resize() +{ + InvokeHelper(0x100, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ChartEvents::MouseDown(long Button, long Shift, long x, long y) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x5fb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Button, Shift, x, y); +} + +void ChartEvents::MouseUp(long Button, long Shift, long x, long y) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x5fc, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Button, Shift, x, y); +} + +void ChartEvents::MouseMove(long Button, long Shift, long x, long y) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x5fd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Button, Shift, x, y); +} + +void ChartEvents::BeforeRightClick(BOOL* Cancel) +{ + static BYTE parms[] = + VTS_PBOOL; + InvokeHelper(0x5fe, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Cancel); +} + +void ChartEvents::DragPlot() +{ + InvokeHelper(0x5ff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ChartEvents::DragOver() +{ + InvokeHelper(0x600, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ChartEvents::BeforeDoubleClick(long ElementID, long Arg1, long Arg2, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_PBOOL; + InvokeHelper(0x601, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ElementID, Arg1, Arg2, Cancel); +} + +void ChartEvents::Select(long ElementID, long Arg1, long Arg2) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ElementID, Arg1, Arg2); +} + +void ChartEvents::SeriesChange(long SeriesIndex, long PointIndex) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x602, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + SeriesIndex, PointIndex); +} + +void ChartEvents::Calculate() +{ + InvokeHelper(0x117, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// VPageBreak properties + +///////////////////////////////////////////////////////////////////////////// +// VPageBreak operations + +LPDISPATCH VPageBreak::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long VPageBreak::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH VPageBreak::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void VPageBreak::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void VPageBreak::DragOff(long Direction, long RegionIndex) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x58c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Direction, RegionIndex); +} + +long VPageBreak::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void VPageBreak::SetType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long VPageBreak::GetExtent() +{ + long result; + InvokeHelper(0x58e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH VPageBreak::GetLocation() +{ + LPDISPATCH result; + InvokeHelper(0x575, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void VPageBreak::SetRefLocation(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x575, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// HPageBreak properties + +///////////////////////////////////////////////////////////////////////////// +// HPageBreak operations + +LPDISPATCH HPageBreak::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long HPageBreak::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH HPageBreak::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void HPageBreak::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void HPageBreak::DragOff(long Direction, long RegionIndex) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x58c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Direction, RegionIndex); +} + +long HPageBreak::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void HPageBreak::SetType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long HPageBreak::GetExtent() +{ + long result; + InvokeHelper(0x58e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH HPageBreak::GetLocation() +{ + LPDISPATCH result; + InvokeHelper(0x575, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void HPageBreak::SetRefLocation(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x575, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// HPageBreaks properties + +///////////////////////////////////////////////////////////////////////////// +// HPageBreaks operations + +LPDISPATCH HPageBreaks::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long HPageBreaks::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH HPageBreaks::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long HPageBreaks::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH HPageBreaks::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH HPageBreaks::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN HPageBreaks::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH HPageBreaks::Add(LPDISPATCH Before) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Before); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// VPageBreaks properties + +///////////////////////////////////////////////////////////////////////////// +// VPageBreaks operations + +LPDISPATCH VPageBreaks::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long VPageBreaks::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH VPageBreaks::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long VPageBreaks::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH VPageBreaks::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH VPageBreaks::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN VPageBreaks::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH VPageBreaks::Add(LPDISPATCH Before) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Before); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// RecentFile properties + +///////////////////////////////////////////////////////////////////////////// +// RecentFile operations + +LPDISPATCH RecentFile::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long RecentFile::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH RecentFile::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString RecentFile::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString RecentFile::GetPath() +{ + CString result; + InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long RecentFile::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH RecentFile::Open() +{ + LPDISPATCH result; + InvokeHelper(0x783, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void RecentFile::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// RecentFiles properties + +///////////////////////////////////////////////////////////////////////////// +// RecentFiles operations + +LPDISPATCH RecentFiles::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long RecentFiles::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH RecentFiles::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long RecentFiles::GetMaximum() +{ + long result; + InvokeHelper(0x58f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void RecentFiles::SetMaximum(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x58f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long RecentFiles::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH RecentFiles::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH RecentFiles::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH RecentFiles::Add(LPCTSTR Name) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name); + return result; +} + +LPUNKNOWN RecentFiles::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DocEvents properties + +///////////////////////////////////////////////////////////////////////////// +// DocEvents operations + +void DocEvents::SelectionChange(LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x607, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Target); +} + +void DocEvents::BeforeDoubleClick(LPDISPATCH Target, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_PBOOL; + InvokeHelper(0x601, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Target, Cancel); +} + +void DocEvents::BeforeRightClick(LPDISPATCH Target, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_PBOOL; + InvokeHelper(0x5fe, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Target, Cancel); +} + +void DocEvents::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void DocEvents::Deactivate() +{ + InvokeHelper(0x5fa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void DocEvents::Calculate() +{ + InvokeHelper(0x117, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void DocEvents::Change(LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x609, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Target); +} + +void DocEvents::FollowHyperlink(LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x5be, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Target); +} + +void DocEvents::PivotTableUpdate(LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x86c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Target); +} + + +///////////////////////////////////////////////////////////////////////////// +// Style properties + +///////////////////////////////////////////////////////////////////////////// +// Style operations + +LPDISPATCH Style::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Style::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Style::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Style::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Style::GetBuiltIn() +{ + BOOL result; + InvokeHelper(0x229, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH Style::GetBorders() +{ + LPDISPATCH result; + InvokeHelper(0x1b3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Style::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Style::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Style::GetFormulaHidden() +{ + BOOL result; + InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetFormulaHidden(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x106, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Style::GetHorizontalAlignment() +{ + long result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Style::SetHorizontalAlignment(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Style::GetIncludeAlignment() +{ + BOOL result; + InvokeHelper(0x19d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetIncludeAlignment(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x19d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Style::GetIncludeBorder() +{ + BOOL result; + InvokeHelper(0x19e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetIncludeBorder(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x19e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Style::GetIncludeFont() +{ + BOOL result; + InvokeHelper(0x19f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetIncludeFont(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x19f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Style::GetIncludeNumber() +{ + BOOL result; + InvokeHelper(0x1a0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetIncludeNumber(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x1a0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Style::GetIncludePatterns() +{ + BOOL result; + InvokeHelper(0x1a1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetIncludePatterns(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x1a1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Style::GetIncludeProtection() +{ + BOOL result; + InvokeHelper(0x1a2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetIncludeProtection(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x1a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Style::GetIndentLevel() +{ + long result; + InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Style::SetIndentLevel(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xc9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Style::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Style::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Style::GetMergeCells() +{ + VARIANT result; + InvokeHelper(0xd0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Style::SetMergeCells(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Style::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString Style::GetNameLocal() +{ + CString result; + InvokeHelper(0x3a9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString Style::GetNumberFormat() +{ + CString result; + InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Style::SetNumberFormat(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Style::GetNumberFormatLocal() +{ + CString result; + InvokeHelper(0x449, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Style::SetNumberFormatLocal(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x449, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long Style::GetOrientation() +{ + long result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Style::SetOrientation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Style::GetShrinkToFit() +{ + BOOL result; + InvokeHelper(0xd1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetShrinkToFit(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xd1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Style::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long Style::GetVerticalAlignment() +{ + long result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Style::SetVerticalAlignment(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Style::GetWrapText() +{ + BOOL result; + InvokeHelper(0x114, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Style::SetWrapText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x114, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Style::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long Style::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Style::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Styles properties + +///////////////////////////////////////////////////////////////////////////// +// Styles operations + +LPDISPATCH Styles::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Styles::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Styles::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Styles::Add(LPCTSTR Name, const VARIANT& BasedOn) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, &BasedOn); + return result; +} + +long Styles::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Styles::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +VARIANT Styles::Merge(const VARIANT& Workbook) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x234, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Workbook); + return result; +} + +LPUNKNOWN Styles::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH Styles::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Borders properties + +///////////////////////////////////////////////////////////////////////////// +// Borders operations + +LPDISPATCH Borders::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Borders::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Borders::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Borders::GetColor() +{ + VARIANT result; + InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Borders::SetColor(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Borders::GetColorIndex() +{ + VARIANT result; + InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Borders::SetColorIndex(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Borders::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Borders::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +VARIANT Borders::GetLineStyle() +{ + VARIANT result; + InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Borders::SetLineStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPUNKNOWN Borders::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +VARIANT Borders::GetValue() +{ + VARIANT result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Borders::SetValue(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Borders::GetWeight() +{ + VARIANT result; + InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Borders::SetWeight(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Borders::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// AddIn properties + +///////////////////////////////////////////////////////////////////////////// +// AddIn operations + +LPDISPATCH AddIn::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long AddIn::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH AddIn::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString AddIn::GetFullName() +{ + CString result; + InvokeHelper(0x121, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL AddIn::GetInstalled() +{ + BOOL result; + InvokeHelper(0x226, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AddIn::SetInstalled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x226, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString AddIn::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString AddIn::GetPath() +{ + CString result; + InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString AddIn::GetProgID() +{ + CString result; + InvokeHelper(0x5f3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString AddIn::GetClsid() +{ + CString result; + InvokeHelper(0x7fb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// AddIns properties + +///////////////////////////////////////////////////////////////////////////// +// AddIns operations + +LPDISPATCH AddIns::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long AddIns::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH AddIns::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH AddIns::Add(LPCTSTR Filename, const VARIANT& CopyFile) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Filename, &CopyFile); + return result; +} + +long AddIns::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH AddIns::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN AddIns::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH AddIns::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Toolbar properties + +///////////////////////////////////////////////////////////////////////////// +// Toolbar operations + +LPDISPATCH Toolbar::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Toolbar::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Toolbar::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Toolbar::GetBuiltIn() +{ + BOOL result; + InvokeHelper(0x229, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Toolbar::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long Toolbar::GetHeight() +{ + long result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Toolbar::SetHeight(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Toolbar::GetLeft() +{ + long result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Toolbar::SetLeft(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString Toolbar::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long Toolbar::GetPosition() +{ + long result; + InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Toolbar::SetPosition(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Toolbar::GetProtection() +{ + long result; + InvokeHelper(0xb0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Toolbar::SetProtection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xb0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void Toolbar::Reset() +{ + InvokeHelper(0x22b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Toolbar::GetToolbarButtons() +{ + LPDISPATCH result; + InvokeHelper(0x3c4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Toolbar::GetTop() +{ + long result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Toolbar::SetTop(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Toolbar::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Toolbar::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Toolbar::GetWidth() +{ + long result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Toolbar::SetWidth(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Toolbars properties + +///////////////////////////////////////////////////////////////////////////// +// Toolbars operations + +LPDISPATCH Toolbars::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Toolbars::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Toolbars::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Toolbars::Add(const VARIANT& Name) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Name); + return result; +} + +long Toolbars::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Toolbars::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH Toolbars::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Toolbars::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ToolbarButton properties + +///////////////////////////////////////////////////////////////////////////// +// ToolbarButton operations + +LPDISPATCH ToolbarButton::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ToolbarButton::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ToolbarButton::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ToolbarButton::GetBuiltIn() +{ + BOOL result; + InvokeHelper(0x229, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL ToolbarButton::GetBuiltInFace() +{ + BOOL result; + InvokeHelper(0x22a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetBuiltInFace(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void ToolbarButton::Copy(LPDISPATCH Toolbar, long Before) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Toolbar, Before); +} + +void ToolbarButton::CopyFace() +{ + InvokeHelper(0x3c6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ToolbarButton::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ToolbarButton::Edit() +{ + InvokeHelper(0x232, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL ToolbarButton::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ToolbarButton::GetHelpContextID() +{ + long result; + InvokeHelper(0x163, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetHelpContextID(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x163, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString ToolbarButton::GetHelpFile() +{ + CString result; + InvokeHelper(0x168, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetHelpFile(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x168, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long ToolbarButton::GetId() +{ + long result; + InvokeHelper(0x23a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL ToolbarButton::GetIsGap() +{ + BOOL result; + InvokeHelper(0x231, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ToolbarButton::Move(LPDISPATCH Toolbar, long Before) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Toolbar, Before); +} + +CString ToolbarButton::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString ToolbarButton::GetOnAction() +{ + CString result; + InvokeHelper(0x254, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetOnAction(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x254, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void ToolbarButton::PasteFace() +{ + InvokeHelper(0x3c7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL ToolbarButton::GetPushed() +{ + BOOL result; + InvokeHelper(0x230, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetPushed(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x230, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void ToolbarButton::Reset() +{ + InvokeHelper(0x22b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString ToolbarButton::GetStatusBar() +{ + CString result; + InvokeHelper(0x182, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetStatusBar(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x182, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long ToolbarButton::GetWidth() +{ + long result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ToolbarButton::SetWidth(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ToolbarButtons properties + +///////////////////////////////////////////////////////////////////////////// +// ToolbarButtons operations + +LPDISPATCH ToolbarButtons::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ToolbarButtons::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ToolbarButtons::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ToolbarButtons::Add(const VARIANT& Button, const VARIANT& Before, const VARIANT& OnAction, const VARIANT& Pushed, const VARIANT& Enabled, const VARIANT& StatusBar, const VARIANT& HelpFile, const VARIANT& HelpContextID) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Button, &Before, &OnAction, &Pushed, &Enabled, &StatusBar, &HelpFile, &HelpContextID); + return result; +} + +long ToolbarButtons::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ToolbarButtons::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN ToolbarButtons::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH ToolbarButtons::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Areas properties + +///////////////////////////////////////////////////////////////////////////// +// Areas operations + +LPDISPATCH Areas::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Areas::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Areas::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Areas::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Areas::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN Areas::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH Areas::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// WorkbookEvents properties + +///////////////////////////////////////////////////////////////////////////// +// WorkbookEvents operations + +void WorkbookEvents::Open() +{ + InvokeHelper(0x783, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void WorkbookEvents::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void WorkbookEvents::Deactivate() +{ + InvokeHelper(0x5fa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void WorkbookEvents::BeforeClose(BOOL* Cancel) +{ + static BYTE parms[] = + VTS_PBOOL; + InvokeHelper(0x60a, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Cancel); +} + +void WorkbookEvents::BeforeSave(BOOL SaveAsUI, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_BOOL VTS_PBOOL; + InvokeHelper(0x60b, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + SaveAsUI, Cancel); +} + +void WorkbookEvents::BeforePrint(BOOL* Cancel) +{ + static BYTE parms[] = + VTS_PBOOL; + InvokeHelper(0x60d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Cancel); +} + +void WorkbookEvents::NewSheet(LPDISPATCH Sh) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x60e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh); +} + +void WorkbookEvents::AddinInstall() +{ + InvokeHelper(0x610, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void WorkbookEvents::AddinUninstall() +{ + InvokeHelper(0x611, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void WorkbookEvents::WindowResize(LPDISPATCH Wn) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x612, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wn); +} + +void WorkbookEvents::WindowActivate(LPDISPATCH Wn) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x614, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wn); +} + +void WorkbookEvents::WindowDeactivate(LPDISPATCH Wn) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x615, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Wn); +} + +void WorkbookEvents::SheetSelectionChange(LPDISPATCH Sh, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x616, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target); +} + +void WorkbookEvents::SheetBeforeDoubleClick(LPDISPATCH Sh, LPDISPATCH Target, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_PBOOL; + InvokeHelper(0x617, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target, Cancel); +} + +void WorkbookEvents::SheetBeforeRightClick(LPDISPATCH Sh, LPDISPATCH Target, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH VTS_PBOOL; + InvokeHelper(0x618, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target, Cancel); +} + +void WorkbookEvents::SheetActivate(LPDISPATCH Sh) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x619, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh); +} + +void WorkbookEvents::SheetDeactivate(LPDISPATCH Sh) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x61a, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh); +} + +void WorkbookEvents::SheetCalculate(LPDISPATCH Sh) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x61b, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh); +} + +void WorkbookEvents::SheetChange(LPDISPATCH Sh, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x61c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target); +} + +void WorkbookEvents::SheetFollowHyperlink(LPDISPATCH Sh, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x73e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target); +} + +void WorkbookEvents::SheetPivotTableUpdate(LPDISPATCH Sh, LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_DISPATCH; + InvokeHelper(0x86d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Sh, Target); +} + +void WorkbookEvents::PivotTableCloseConnection(LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x86e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Target); +} + +void WorkbookEvents::PivotTableOpenConnection(LPDISPATCH Target) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x86f, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Target); +} + +void WorkbookEvents::Sync(long SyncEventType) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8da, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + SyncEventType); +} + +void WorkbookEvents::BeforeXmlImport(LPDISPATCH Map, LPCTSTR Url, BOOL IsRefresh, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_BSTR VTS_BOOL VTS_PBOOL; + InvokeHelper(0x8eb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Map, Url, IsRefresh, Cancel); +} + +void WorkbookEvents::AfterXmlImport(LPDISPATCH Map, BOOL IsRefresh, long Result) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_BOOL VTS_I4; + InvokeHelper(0x8ed, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Map, IsRefresh, Result); +} + +void WorkbookEvents::BeforeXmlExport(LPDISPATCH Map, LPCTSTR Url, BOOL* Cancel) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_BSTR VTS_PBOOL; + InvokeHelper(0x8ef, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Map, Url, Cancel); +} + +void WorkbookEvents::AfterXmlExport(LPDISPATCH Map, LPCTSTR Url, long Result) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_BSTR VTS_I4; + InvokeHelper(0x8f0, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Map, Url, Result); +} + + +///////////////////////////////////////////////////////////////////////////// +// MenuBars properties + +///////////////////////////////////////////////////////////////////////////// +// MenuBars operations + +LPDISPATCH MenuBars::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long MenuBars::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuBars::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuBars::Add(const VARIANT& Name) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Name); + return result; +} + +long MenuBars::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuBars::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH MenuBars::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN MenuBars::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// MenuBar properties + +///////////////////////////////////////////////////////////////////////////// +// MenuBar operations + +LPDISPATCH MenuBar::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long MenuBar::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuBar::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void MenuBar::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL MenuBar::GetBuiltIn() +{ + BOOL result; + InvokeHelper(0x229, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +CString MenuBar::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void MenuBar::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void MenuBar::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long MenuBar::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuBar::GetMenus() +{ + LPDISPATCH result; + InvokeHelper(0x24f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void MenuBar::Reset() +{ + InvokeHelper(0x22b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// Menus properties + +///////////////////////////////////////////////////////////////////////////// +// Menus operations + +LPDISPATCH Menus::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Menus::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Menus::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Menus::Add(LPCTSTR Caption, const VARIANT& Before, const VARIANT& Restore) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Caption, &Before, &Restore); + return result; +} + +long Menus::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Menus::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH Menus::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Menus::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Menu properties + +///////////////////////////////////////////////////////////////////////////// +// Menu operations + +LPDISPATCH Menu::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Menu::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Menu::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Menu::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Menu::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void Menu::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL Menu::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Menu::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Menu::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Menu::GetMenuItems() +{ + LPDISPATCH result; + InvokeHelper(0x251, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// MenuItems properties + +///////////////////////////////////////////////////////////////////////////// +// MenuItems operations + +LPDISPATCH MenuItems::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long MenuItems::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuItems::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuItems::Add(LPCTSTR Caption, const VARIANT& OnAction, const VARIANT& ShortcutKey, const VARIANT& Before, const VARIANT& Restore, const VARIANT& StatusBar, const VARIANT& HelpFile, const VARIANT& HelpContextID) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Caption, &OnAction, &ShortcutKey, &Before, &Restore, &StatusBar, &HelpFile, &HelpContextID); + return result; +} + +LPDISPATCH MenuItems::AddMenu(LPCTSTR Caption, const VARIANT& Before, const VARIANT& Restore) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x256, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Caption, &Before, &Restore); + return result; +} + +long MenuItems::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuItems::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH MenuItems::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN MenuItems::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// MenuItem properties + +///////////////////////////////////////////////////////////////////////////// +// MenuItem operations + +LPDISPATCH MenuItem::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long MenuItem::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MenuItem::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString MenuItem::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void MenuItem::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL MenuItem::GetChecked() +{ + BOOL result; + InvokeHelper(0x257, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void MenuItem::SetChecked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x257, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void MenuItem::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL MenuItem::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void MenuItem::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long MenuItem::GetHelpContextID() +{ + long result; + InvokeHelper(0x163, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void MenuItem::SetHelpContextID(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x163, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString MenuItem::GetHelpFile() +{ + CString result; + InvokeHelper(0x168, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void MenuItem::SetHelpFile(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x168, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long MenuItem::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString MenuItem::GetOnAction() +{ + CString result; + InvokeHelper(0x254, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void MenuItem::SetOnAction(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x254, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString MenuItem::GetStatusBar() +{ + CString result; + InvokeHelper(0x182, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void MenuItem::SetStatusBar(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x182, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Charts properties + +///////////////////////////////////////////////////////////////////////////// +// Charts operations + +LPDISPATCH Charts::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Charts::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Charts::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Charts::Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Before, &After, &Count); + return result; +} + +void Charts::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +long Charts::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Charts::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Charts::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Charts::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +LPUNKNOWN Charts::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void Charts::PrintPreview(const VARIANT& EnableChanges) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EnableChanges); +} + +void Charts::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +LPDISPATCH Charts::GetHPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Charts::GetVPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Charts::GetVisible() +{ + VARIANT result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Charts::SetVisible(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Charts::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Charts::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + + +///////////////////////////////////////////////////////////////////////////// +// DrawingObjects properties + +///////////////////////////////////////////////////////////////////////////// +// DrawingObjects operations + +LPDISPATCH DrawingObjects::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DrawingObjects::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DrawingObjects::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DrawingObjects::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DrawingObjects::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DrawingObjects::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT DrawingObjects::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DrawingObjects::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DrawingObjects::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DrawingObjects::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double DrawingObjects::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double DrawingObjects::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL DrawingObjects::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DrawingObjects::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DrawingObjects::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DrawingObjects::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT DrawingObjects::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double DrawingObjects::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL DrawingObjects::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double DrawingObjects::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long DrawingObjects::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DrawingObjects::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DrawingObjects::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DrawingObjects::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DrawingObjects::AddItem(const VARIANT& Text, const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x353, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Text, &Index); + return result; +} + +VARIANT DrawingObjects::GetArrowHeadLength() +{ + VARIANT result; + InvokeHelper(0x263, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetArrowHeadLength(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x263, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT DrawingObjects::GetArrowHeadStyle() +{ + VARIANT result; + InvokeHelper(0x264, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetArrowHeadStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x264, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT DrawingObjects::GetArrowHeadWidth() +{ + VARIANT result; + InvokeHelper(0x265, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetArrowHeadWidth(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x265, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DrawingObjects::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH DrawingObjects::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DrawingObjects::GetCancelButton() +{ + BOOL result; + InvokeHelper(0x35a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetCancelButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString DrawingObjects::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DrawingObjects::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT DrawingObjects::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +long DrawingObjects::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL DrawingObjects::GetDefaultButton() +{ + BOOL result; + InvokeHelper(0x359, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetDefaultButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x359, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DrawingObjects::GetDismissButton() +{ + BOOL result; + InvokeHelper(0x35b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetDismissButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DrawingObjects::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DrawingObjects::GetDisplayVerticalScrollBar() +{ + BOOL result; + InvokeHelper(0x39a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetDisplayVerticalScrollBar(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x39a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long DrawingObjects::GetDropDownLines() +{ + long result; + InvokeHelper(0x350, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetDropDownLines(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x350, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH DrawingObjects::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DrawingObjects::GetHelpButton() +{ + BOOL result; + InvokeHelper(0x35c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetHelpButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DrawingObjects::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long DrawingObjects::GetInputType() +{ + long result; + InvokeHelper(0x356, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetInputType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x356, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH DrawingObjects::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DrawingObjects::GetLargeChange() +{ + long result; + InvokeHelper(0x34d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetLargeChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DrawingObjects::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT DrawingObjects::List(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +CString DrawingObjects::GetListFillRange() +{ + CString result; + InvokeHelper(0x34f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetListFillRange(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x34f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long DrawingObjects::GetListIndex() +{ + long result; + InvokeHelper(0x352, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetListIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x352, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL DrawingObjects::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long DrawingObjects::GetMax() +{ + long result; + InvokeHelper(0x34a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetMax(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long DrawingObjects::GetMin() +{ + long result; + InvokeHelper(0x34b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetMin(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL DrawingObjects::GetMultiLine() +{ + BOOL result; + InvokeHelper(0x357, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetMultiLine(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x357, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DrawingObjects::GetMultiSelect() +{ + BOOL result; + InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetMultiSelect(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DrawingObjects::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT DrawingObjects::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT DrawingObjects::RemoveAllItems() +{ + VARIANT result; + InvokeHelper(0x355, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DrawingObjects::RemoveItem(long Index, const VARIANT& Count) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x354, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Index, &Count); + return result; +} + +VARIANT DrawingObjects::Reshape(long Vertex, const VARIANT& Insert, const VARIANT& Left, const VARIANT& Top) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Vertex, &Insert, &Left, &Top); + return result; +} + +BOOL DrawingObjects::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DrawingObjects::Selected(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +BOOL DrawingObjects::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long DrawingObjects::GetSmallChange() +{ + long result; + InvokeHelper(0x34c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetSmallChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DrawingObjects::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DrawingObjects::Ungroup() +{ + LPDISPATCH result; + InvokeHelper(0xf4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DrawingObjects::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT DrawingObjects::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT DrawingObjects::Vertices(const VARIANT& Index1, const VARIANT& Index2) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x26d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Index1, &Index2); + return result; +} + +long DrawingObjects::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DrawingObjects::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long DrawingObjects::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DrawingObjects::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH DrawingObjects::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DrawingObjects::LinkCombo(const VARIANT& Link) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x358, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Link); + return result; +} + +LPUNKNOWN DrawingObjects::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotCache properties + +///////////////////////////////////////////////////////////////////////////// +// PivotCache operations + +LPDISPATCH PivotCache::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotCache::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCache::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL PivotCache::GetBackgroundQuery() +{ + BOOL result; + InvokeHelper(0x593, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotCache::SetBackgroundQuery(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x593, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT PivotCache::GetConnection() +{ + VARIANT result; + InvokeHelper(0x598, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotCache::SetConnection(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x598, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL PivotCache::GetEnableRefresh() +{ + BOOL result; + InvokeHelper(0x5c5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotCache::SetEnableRefresh(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5c5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PivotCache::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long PivotCache::GetMemoryUsed() +{ + long result; + InvokeHelper(0x174, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL PivotCache::GetOptimizeCache() +{ + BOOL result; + InvokeHelper(0x594, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotCache::SetOptimizeCache(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x594, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PivotCache::GetRecordCount() +{ + long result; + InvokeHelper(0x5c6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotCache::Refresh() +{ + InvokeHelper(0x589, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +DATE PivotCache::GetRefreshDate() +{ + DATE result; + InvokeHelper(0x2b8, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL); + return result; +} + +CString PivotCache::GetRefreshName() +{ + CString result; + InvokeHelper(0x2b9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL PivotCache::GetRefreshOnFileOpen() +{ + BOOL result; + InvokeHelper(0x5c7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotCache::SetRefreshOnFileOpen(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5c7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotCache::GetSavePassword() +{ + BOOL result; + InvokeHelper(0x5c9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotCache::SetSavePassword(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5c9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT PivotCache::GetSourceData() +{ + VARIANT result; + InvokeHelper(0x2ae, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotCache::SetSourceData(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2ae, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT PivotCache::GetCommandText() +{ + VARIANT result; + InvokeHelper(0x725, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotCache::SetCommandText(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x725, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long PivotCache::GetCommandType() +{ + long result; + InvokeHelper(0x726, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotCache::SetCommandType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x726, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long PivotCache::GetQueryType() +{ + long result; + InvokeHelper(0x727, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL PivotCache::GetMaintainConnection() +{ + BOOL result; + InvokeHelper(0x728, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotCache::SetMaintainConnection(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x728, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PivotCache::GetRefreshPeriod() +{ + long result; + InvokeHelper(0x729, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotCache::SetRefreshPeriod(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x729, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH PivotCache::GetRecordset() +{ + LPDISPATCH result; + InvokeHelper(0x48d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void PivotCache::SetRefRecordset(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x48d, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + +void PivotCache::ResetTimer() +{ + InvokeHelper(0x72a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +VARIANT PivotCache::GetLocalConnection() +{ + VARIANT result; + InvokeHelper(0x72b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotCache::SetLocalConnection(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x72b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH PivotCache::CreatePivotTable(const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& ReadData, const VARIANT& DefaultVersion) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x72c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &TableDestination, &TableName, &ReadData, &DefaultVersion); + return result; +} + +BOOL PivotCache::GetUseLocalConnection() +{ + BOOL result; + InvokeHelper(0x72d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotCache::SetUseLocalConnection(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x72d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotCache::GetADOConnection() +{ + LPDISPATCH result; + InvokeHelper(0x81a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL PivotCache::GetIsConnected() +{ + BOOL result; + InvokeHelper(0x81b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotCache::MakeConnection() +{ + InvokeHelper(0x81c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL PivotCache::GetOlap() +{ + BOOL result; + InvokeHelper(0x81d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long PivotCache::GetSourceType() +{ + long result; + InvokeHelper(0x2ad, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long PivotCache::GetMissingItemsLimit() +{ + long result; + InvokeHelper(0x81e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotCache::SetMissingItemsLimit(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x81e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString PivotCache::GetSourceConnectionFile() +{ + CString result; + InvokeHelper(0x81f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotCache::SetSourceConnectionFile(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x81f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotCache::GetSourceDataFile() +{ + CString result; + InvokeHelper(0x820, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long PivotCache::GetRobustConnect() +{ + long result; + InvokeHelper(0x821, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotCache::SetRobustConnect(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x821, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void PivotCache::SaveAsODC(LPCTSTR ODCFileName, const VARIANT& Description, const VARIANT& Keywords) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x822, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ODCFileName, &Description, &Keywords); +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotCaches properties + +///////////////////////////////////////////////////////////////////////////// +// PivotCaches operations + +LPDISPATCH PivotCaches::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotCaches::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCaches::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotCaches::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCaches::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PivotCaches::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN PivotCaches::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCaches::Add(long SourceType, const VARIANT& SourceData) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + SourceType, &SourceData); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotFormula properties + +///////////////////////////////////////////////////////////////////////////// +// PivotFormula operations + +LPDISPATCH PivotFormula::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotFormula::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotFormula::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void PivotFormula::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString PivotFormula::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotFormula::Set_Default(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotFormula::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotFormula::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotFormula::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotFormula::SetValue(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long PivotFormula::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotFormula::SetIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1e6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString PivotFormula::GetStandardFormula() +{ + CString result; + InvokeHelper(0x824, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotFormula::SetStandardFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x824, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotFormulas properties + +///////////////////////////////////////////////////////////////////////////// +// PivotFormulas operations + +LPDISPATCH PivotFormulas::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotFormulas::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotFormulas::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotFormulas::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotFormulas::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PivotFormulas::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN PivotFormulas::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotFormulas::Add(LPCTSTR Formula, const VARIANT& UseStandardFormula) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Formula, &UseStandardFormula); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotTable properties + +///////////////////////////////////////////////////////////////////////////// +// PivotTable operations + +LPDISPATCH PivotTable::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotTable::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTable::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT PivotTable::AddFields(const VARIANT& RowFields, const VARIANT& ColumnFields, const VARIANT& PageFields, const VARIANT& AddToTable) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2c4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &RowFields, &ColumnFields, &PageFields, &AddToTable); + return result; +} + +LPDISPATCH PivotTable::GetColumnFields(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2c9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +BOOL PivotTable::GetColumnGrand() +{ + BOOL result; + InvokeHelper(0x2b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetColumnGrand(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x2b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotTable::GetColumnRange() +{ + LPDISPATCH result; + InvokeHelper(0x2be, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT PivotTable::ShowPages(const VARIANT& PageField) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2c2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &PageField); + return result; +} + +LPDISPATCH PivotTable::GetDataBodyRange() +{ + LPDISPATCH result; + InvokeHelper(0x2c1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTable::GetDataFields(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2cb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PivotTable::GetDataLabelRange() +{ + LPDISPATCH result; + InvokeHelper(0x2c0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString PivotTable::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::Set_Default(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PivotTable::GetHasAutoFormat() +{ + BOOL result; + InvokeHelper(0x2b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetHasAutoFormat(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x2b7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotTable::GetHiddenFields(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2c7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +CString PivotTable::GetInnerDetail() +{ + CString result; + InvokeHelper(0x2ba, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetInnerDetail(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x2ba, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotTable::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH PivotTable::GetPageFields(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2ca, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PivotTable::GetPageRange() +{ + LPDISPATCH result; + InvokeHelper(0x2bf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTable::GetPageRangeCells() +{ + LPDISPATCH result; + InvokeHelper(0x5ca, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTable::PivotFields(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2ce, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +DATE PivotTable::GetRefreshDate() +{ + DATE result; + InvokeHelper(0x2b8, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL); + return result; +} + +CString PivotTable::GetRefreshName() +{ + CString result; + InvokeHelper(0x2b9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL PivotTable::RefreshTable() +{ + BOOL result; + InvokeHelper(0x2cd, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTable::GetRowFields(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2c8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +BOOL PivotTable::GetRowGrand() +{ + BOOL result; + InvokeHelper(0x2b5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetRowGrand(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x2b5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotTable::GetRowRange() +{ + LPDISPATCH result; + InvokeHelper(0x2bd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL PivotTable::GetSaveData() +{ + BOOL result; + InvokeHelper(0x2b4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetSaveData(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x2b4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT PivotTable::GetSourceData() +{ + VARIANT result; + InvokeHelper(0x2ae, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotTable::SetSourceData(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2ae, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH PivotTable::GetTableRange1() +{ + LPDISPATCH result; + InvokeHelper(0x2bb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTable::GetTableRange2() +{ + LPDISPATCH result; + InvokeHelper(0x2bc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString PivotTable::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetValue(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH PivotTable::GetVisibleFields(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2c6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long PivotTable::GetCacheIndex() +{ + long result; + InvokeHelper(0x5cb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotTable::SetCacheIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x5cb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH PivotTable::CalculatedFields() +{ + LPDISPATCH result; + InvokeHelper(0x5cc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL PivotTable::GetDisplayErrorString() +{ + BOOL result; + InvokeHelper(0x5cd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetDisplayErrorString(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5cd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetDisplayNullString() +{ + BOOL result; + InvokeHelper(0x5ce, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetDisplayNullString(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5ce, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetEnableDrilldown() +{ + BOOL result; + InvokeHelper(0x5cf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetEnableDrilldown(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetEnableFieldDialog() +{ + BOOL result; + InvokeHelper(0x5d0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetEnableFieldDialog(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5d0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetEnableWizard() +{ + BOOL result; + InvokeHelper(0x5d1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetEnableWizard(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5d1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString PivotTable::GetErrorString() +{ + CString result; + InvokeHelper(0x5d2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetErrorString(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5d2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +double PivotTable::GetData(LPCTSTR Name) +{ + double result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5d3, DISPATCH_METHOD, VT_R8, (void*)&result, parms, + Name); + return result; +} + +void PivotTable::ListFormulas() +{ + InvokeHelper(0x5d4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL PivotTable::GetManualUpdate() +{ + BOOL result; + InvokeHelper(0x5d5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetManualUpdate(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5d5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetMergeLabels() +{ + BOOL result; + InvokeHelper(0x5d6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetMergeLabels(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5d6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString PivotTable::GetNullString() +{ + CString result; + InvokeHelper(0x5d7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetNullString(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5d7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH PivotTable::PivotCache() +{ + LPDISPATCH result; + InvokeHelper(0x5d8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTable::GetPivotFormulas() +{ + LPDISPATCH result; + InvokeHelper(0x5d9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void PivotTable::PivotTableWizard(const VARIANT& SourceType, const VARIANT& SourceData, const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& RowGrand, const VARIANT& ColumnGrand, const VARIANT& SaveData, const VARIANT& HasAutoFormat, + const VARIANT& AutoPage, const VARIANT& Reserved, const VARIANT& BackgroundQuery, const VARIANT& OptimizeCache, const VARIANT& PageFieldOrder, const VARIANT& PageFieldWrapCount, const VARIANT& ReadData, const VARIANT& Connection) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2ac, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &SourceType, &SourceData, &TableDestination, &TableName, &RowGrand, &ColumnGrand, &SaveData, &HasAutoFormat, &AutoPage, &Reserved, &BackgroundQuery, &OptimizeCache, &PageFieldOrder, &PageFieldWrapCount, &ReadData, &Connection); +} + +BOOL PivotTable::GetSubtotalHiddenPageItems() +{ + BOOL result; + InvokeHelper(0x5da, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetSubtotalHiddenPageItems(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5da, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PivotTable::GetPageFieldOrder() +{ + long result; + InvokeHelper(0x595, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotTable::SetPageFieldOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x595, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString PivotTable::GetPageFieldStyle() +{ + CString result; + InvokeHelper(0x5db, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetPageFieldStyle(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5db, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long PivotTable::GetPageFieldWrapCount() +{ + long result; + InvokeHelper(0x596, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotTable::SetPageFieldWrapCount(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x596, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL PivotTable::GetPreserveFormatting() +{ + BOOL result; + InvokeHelper(0x5dc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetPreserveFormatting(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5dc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString PivotTable::GetPivotSelection() +{ + CString result; + InvokeHelper(0x5de, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetPivotSelection(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5de, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long PivotTable::GetSelectionMode() +{ + long result; + InvokeHelper(0x5df, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotTable::SetSelectionMode(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x5df, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString PivotTable::GetTableStyle() +{ + CString result; + InvokeHelper(0x5e0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetTableStyle(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5e0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotTable::GetTag() +{ + CString result; + InvokeHelper(0x5e1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetTag(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5e1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void PivotTable::Update() +{ + InvokeHelper(0x2a8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString PivotTable::GetVacatedStyle() +{ + CString result; + InvokeHelper(0x5e2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetVacatedStyle(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5e2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void PivotTable::Format(long Format) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x74, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Format); +} + +BOOL PivotTable::GetPrintTitles() +{ + BOOL result; + InvokeHelper(0x72e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetPrintTitles(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x72e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotTable::GetCubeFields() +{ + LPDISPATCH result; + InvokeHelper(0x72f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString PivotTable::GetGrandTotalName() +{ + CString result; + InvokeHelper(0x730, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetGrandTotalName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x730, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PivotTable::GetSmallGrid() +{ + BOOL result; + InvokeHelper(0x731, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetSmallGrid(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x731, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetRepeatItemsOnEachPrintedPage() +{ + BOOL result; + InvokeHelper(0x732, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetRepeatItemsOnEachPrintedPage(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x732, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetTotalsAnnotation() +{ + BOOL result; + InvokeHelper(0x733, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetTotalsAnnotation(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x733, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void PivotTable::PivotSelect(LPCTSTR Name, long Mode, const VARIANT& UseStandardName) +{ + static BYTE parms[] = + VTS_BSTR VTS_I4 VTS_VARIANT; + InvokeHelper(0x5dd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Name, Mode, &UseStandardName); +} + +CString PivotTable::GetPivotSelectionStandard() +{ + CString result; + InvokeHelper(0x829, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotTable::SetPivotSelectionStandard(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x829, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH PivotTable::GetPivotData(const VARIANT& DataField, const VARIANT& Field1, const VARIANT& Item1, const VARIANT& Field2, const VARIANT& Item2, const VARIANT& Field3, const VARIANT& Item3, const VARIANT& Field4, const VARIANT& Item4, + const VARIANT& Field5, const VARIANT& Item5, const VARIANT& Field6, const VARIANT& Item6, const VARIANT& Field7, const VARIANT& Item7, const VARIANT& Field8, const VARIANT& Item8, const VARIANT& Field9, const VARIANT& Item9, + const VARIANT& Field10, const VARIANT& Item10, const VARIANT& Field11, const VARIANT& Item11, const VARIANT& Field12, const VARIANT& Item12, const VARIANT& Field13, const VARIANT& Item13, const VARIANT& Field14, const VARIANT& Item14) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x82a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &DataField, &Field1, &Item1, &Field2, &Item2, &Field3, &Item3, &Field4, &Item4, &Field5, &Item5, &Field6, &Item6, &Field7, &Item7, &Field8, &Item8, &Field9, &Item9, &Field10, &Item10, &Field11, &Item11, &Field12, &Item12, &Field13, + &Item13, &Field14, &Item14); + return result; +} + +LPDISPATCH PivotTable::GetDataPivotField() +{ + LPDISPATCH result; + InvokeHelper(0x848, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL PivotTable::GetEnableDataValueEditing() +{ + BOOL result; + InvokeHelper(0x849, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetEnableDataValueEditing(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x849, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotTable::AddDataField(LPDISPATCH Field, const VARIANT& Caption, const VARIANT& Function) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x84a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Field, &Caption, &Function); + return result; +} + +CString PivotTable::GetMdx() +{ + CString result; + InvokeHelper(0x84b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL PivotTable::GetViewCalculatedMembers() +{ + BOOL result; + InvokeHelper(0x84c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetViewCalculatedMembers(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x84c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotTable::GetCalculatedMembers() +{ + LPDISPATCH result; + InvokeHelper(0x84d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL PivotTable::GetDisplayImmediateItems() +{ + BOOL result; + InvokeHelper(0x84e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetDisplayImmediateItems(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x84e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetEnableFieldList() +{ + BOOL result; + InvokeHelper(0x850, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetEnableFieldList(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x850, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetVisualTotals() +{ + BOOL result; + InvokeHelper(0x851, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetVisualTotals(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x851, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetShowPageMultipleItemLabel() +{ + BOOL result; + InvokeHelper(0x852, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetShowPageMultipleItemLabel(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x852, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PivotTable::GetVersion() +{ + long result; + InvokeHelper(0x188, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString PivotTable::CreateCubeFile(LPCTSTR File, const VARIANT& Measures, const VARIANT& Levels, const VARIANT& Members, const VARIANT& Properties) +{ + CString result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x853, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + File, &Measures, &Levels, &Members, &Properties); + return result; +} + +BOOL PivotTable::GetDisplayEmptyRow() +{ + BOOL result; + InvokeHelper(0x858, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetDisplayEmptyRow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x858, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetDisplayEmptyColumn() +{ + BOOL result; + InvokeHelper(0x859, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetDisplayEmptyColumn(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x859, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotTable::GetShowCellBackgroundFromOLAP() +{ + BOOL result; + InvokeHelper(0x85a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotTable::SetShowCellBackgroundFromOLAP(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x85a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotTables properties + +///////////////////////////////////////////////////////////////////////////// +// PivotTables operations + +LPDISPATCH PivotTables::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotTables::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTables::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotTables::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTables::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN PivotTables::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotTables::Add(LPDISPATCH PivotCache, const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& ReadData, const VARIANT& DefaultVersion) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + PivotCache, &TableDestination, &TableName, &ReadData, &DefaultVersion); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotField properties + +///////////////////////////////////////////////////////////////////////////// +// PivotField operations + +LPDISPATCH PivotField::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotField::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotField::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotField::GetCalculation() +{ + long result; + InvokeHelper(0x13c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotField::SetCalculation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x13c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH PivotField::GetChildField() +{ + LPDISPATCH result; + InvokeHelper(0x2e0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT PivotField::GetChildItems(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2da, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +VARIANT PivotField::GetCurrentPage() +{ + VARIANT result; + InvokeHelper(0x2e2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotField::SetCurrentPage(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2e2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH PivotField::GetDataRange() +{ + LPDISPATCH result; + InvokeHelper(0x2d0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotField::GetDataType() +{ + long result; + InvokeHelper(0x2d2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString PivotField::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::Set_Default(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long PivotField::GetFunction() +{ + long result; + InvokeHelper(0x383, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotField::SetFunction(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x383, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT PivotField::GetGroupLevel() +{ + VARIANT result; + InvokeHelper(0x2d3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT PivotField::GetHiddenItems(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2d8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PivotField::GetLabelRange() +{ + LPDISPATCH result; + InvokeHelper(0x2cf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString PivotField::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotField::GetNumberFormat() +{ + CString result; + InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::SetNumberFormat(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long PivotField::GetOrientation() +{ + long result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotField::SetOrientation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL PivotField::GetShowAllItems() +{ + BOOL result; + InvokeHelper(0x1c4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetShowAllItems(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x1c4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotField::GetParentField() +{ + LPDISPATCH result; + InvokeHelper(0x2dc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT PivotField::GetParentItems(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2d9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +VARIANT PivotField::PivotItems(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2e1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +VARIANT PivotField::GetPosition() +{ + VARIANT result; + InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotField::SetPosition(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString PivotField::GetSourceName() +{ + CString result; + InvokeHelper(0x2d1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT PivotField::GetSubtotals(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2dd, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void PivotField::SetSubtotals(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x2dd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +VARIANT PivotField::GetBaseField() +{ + VARIANT result; + InvokeHelper(0x2de, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotField::SetBaseField(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2de, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT PivotField::GetBaseItem() +{ + VARIANT result; + InvokeHelper(0x2df, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotField::SetBaseItem(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2df, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT PivotField::GetTotalLevels() +{ + VARIANT result; + InvokeHelper(0x2d4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +CString PivotField::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::SetValue(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT PivotField::GetVisibleItems(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2d7, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PivotField::CalculatedItems() +{ + LPDISPATCH result; + InvokeHelper(0x5e3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void PivotField::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL PivotField::GetDragToColumn() +{ + BOOL result; + InvokeHelper(0x5e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetDragToColumn(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotField::GetDragToHide() +{ + BOOL result; + InvokeHelper(0x5e5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetDragToHide(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotField::GetDragToPage() +{ + BOOL result; + InvokeHelper(0x5e6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetDragToPage(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotField::GetDragToRow() +{ + BOOL result; + InvokeHelper(0x5e7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetDragToRow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotField::GetDragToData() +{ + BOOL result; + InvokeHelper(0x734, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetDragToData(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x734, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString PivotField::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PivotField::GetIsCalculated() +{ + BOOL result; + InvokeHelper(0x5e8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long PivotField::GetMemoryUsed() +{ + long result; + InvokeHelper(0x174, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL PivotField::GetServerBased() +{ + BOOL result; + InvokeHelper(0x5e9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetServerBased(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5e9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void PivotField::AutoSort(long Order, LPCTSTR Field) +{ + static BYTE parms[] = + VTS_I4 VTS_BSTR; + InvokeHelper(0x5ea, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Order, Field); +} + +void PivotField::AutoShow(long Type, long Range, long Count, LPCTSTR Field) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_BSTR; + InvokeHelper(0x5eb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Type, Range, Count, Field); +} + +long PivotField::GetAutoSortOrder() +{ + long result; + InvokeHelper(0x5ec, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString PivotField::GetAutoSortField() +{ + CString result; + InvokeHelper(0x5ed, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long PivotField::GetAutoShowType() +{ + long result; + InvokeHelper(0x5ee, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long PivotField::GetAutoShowRange() +{ + long result; + InvokeHelper(0x5ef, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long PivotField::GetAutoShowCount() +{ + long result; + InvokeHelper(0x5f0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString PivotField::GetAutoShowField() +{ + CString result; + InvokeHelper(0x5f1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL PivotField::GetLayoutBlankLine() +{ + BOOL result; + InvokeHelper(0x735, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetLayoutBlankLine(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x735, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PivotField::GetLayoutSubtotalLocation() +{ + long result; + InvokeHelper(0x736, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotField::SetLayoutSubtotalLocation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x736, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL PivotField::GetLayoutPageBreak() +{ + BOOL result; + InvokeHelper(0x737, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetLayoutPageBreak(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x737, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PivotField::GetLayoutForm() +{ + long result; + InvokeHelper(0x738, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotField::SetLayoutForm(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x738, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString PivotField::GetSubtotalName() +{ + CString result; + InvokeHelper(0x739, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::SetSubtotalName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x739, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotField::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PivotField::GetDrilledDown() +{ + BOOL result; + InvokeHelper(0x73a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetDrilledDown(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x73a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH PivotField::GetCubeField() +{ + LPDISPATCH result; + InvokeHelper(0x73b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString PivotField::GetCurrentPageName() +{ + CString result; + InvokeHelper(0x73c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::SetCurrentPageName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x73c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotField::GetStandardFormula() +{ + CString result; + InvokeHelper(0x824, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotField::SetStandardFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x824, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT PivotField::GetHiddenItemsList() +{ + VARIANT result; + InvokeHelper(0x85b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotField::SetHiddenItemsList(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x85b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL PivotField::GetDatabaseSort() +{ + BOOL result; + InvokeHelper(0x85c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetDatabaseSort(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x85c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PivotField::GetIsMemberProperty() +{ + BOOL result; + InvokeHelper(0x85d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotField::GetPropertyParentField() +{ + LPDISPATCH result; + InvokeHelper(0x85e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotField::GetPropertyOrder() +{ + long result; + InvokeHelper(0x85f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotField::SetPropertyOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x85f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL PivotField::GetEnableItemSelection() +{ + BOOL result; + InvokeHelper(0x860, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotField::SetEnableItemSelection(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x860, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT PivotField::GetCurrentPageList() +{ + VARIANT result; + InvokeHelper(0x861, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PivotField::SetCurrentPageList(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x861, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +void PivotField::AddPageItem(LPCTSTR Item, const VARIANT& ClearList) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x862, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Item, &ClearList); +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotFields properties + +///////////////////////////////////////////////////////////////////////////// +// PivotFields operations + +LPDISPATCH PivotFields::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotFields::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotFields::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotFields::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotFields::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN PivotFields::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// CalculatedFields properties + +///////////////////////////////////////////////////////////////////////////// +// CalculatedFields operations + +LPDISPATCH CalculatedFields::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CalculatedFields::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedFields::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CalculatedFields::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedFields::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH CalculatedFields::Get_Default(const VARIANT& Field) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Field); + return result; +} + +LPUNKNOWN CalculatedFields::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedFields::Add(LPCTSTR Name, LPCTSTR Formula, const VARIANT& UseStandardFormula) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, Formula, &UseStandardFormula); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotItem properties + +///////////////////////////////////////////////////////////////////////////// +// PivotItem operations + +LPDISPATCH PivotItem::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotItem::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotItem::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT PivotItem::GetChildItems(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x2da, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PivotItem::GetDataRange() +{ + LPDISPATCH result; + InvokeHelper(0x2d0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString PivotItem::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotItem::Set_Default(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH PivotItem::GetLabelRange() +{ + LPDISPATCH result; + InvokeHelper(0x2cf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString PivotItem::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotItem::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH PivotItem::GetParentItem() +{ + LPDISPATCH result; + InvokeHelper(0x2e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL PivotItem::GetParentShowDetail() +{ + BOOL result; + InvokeHelper(0x2e3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long PivotItem::GetPosition() +{ + long result; + InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PivotItem::SetPosition(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL PivotItem::GetShowDetail() +{ + BOOL result; + InvokeHelper(0x249, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotItem::SetShowDetail(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x249, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT PivotItem::GetSourceName() +{ + VARIANT result; + InvokeHelper(0x2d1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +CString PivotItem::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotItem::SetValue(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PivotItem::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotItem::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void PivotItem::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL PivotItem::GetIsCalculated() +{ + BOOL result; + InvokeHelper(0x5e8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long PivotItem::GetRecordCount() +{ + long result; + InvokeHelper(0x5c6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString PivotItem::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotItem::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotItem::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotItem::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PivotItem::GetDrilledDown() +{ + BOOL result; + InvokeHelper(0x73a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PivotItem::SetDrilledDown(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x73a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString PivotItem::GetStandardFormula() +{ + CString result; + InvokeHelper(0x824, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PivotItem::SetStandardFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x824, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PivotItem::GetSourceNameStandard() +{ + CString result; + InvokeHelper(0x864, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotItems properties + +///////////////////////////////////////////////////////////////////////////// +// PivotItems operations + +LPDISPATCH PivotItems::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotItems::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotItems::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void PivotItems::Add(LPCTSTR Name) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Name); +} + +long PivotItems::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotItems::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN PivotItems::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// CalculatedItems properties + +///////////////////////////////////////////////////////////////////////////// +// CalculatedItems operations + +LPDISPATCH CalculatedItems::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CalculatedItems::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedItems::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CalculatedItems::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedItems::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH CalculatedItems::Get_Default(const VARIANT& Field) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Field); + return result; +} + +LPUNKNOWN CalculatedItems::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedItems::Add(LPCTSTR Name, LPCTSTR Formula, const VARIANT& UseStandardFormula) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, Formula, &UseStandardFormula); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Characters properties + +///////////////////////////////////////////////////////////////////////////// +// Characters operations + +LPDISPATCH Characters::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Characters::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Characters::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Characters::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Characters::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long Characters::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Characters::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Characters::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Characters::Insert(LPCTSTR String) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xfc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + String); + return result; +} + +CString Characters::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Characters::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Characters::GetPhoneticCharacters() +{ + CString result; + InvokeHelper(0x5f2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Characters::SetPhoneticCharacters(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5f2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Dialogs properties + +///////////////////////////////////////////////////////////////////////////// +// Dialogs operations + +LPDISPATCH Dialogs::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Dialogs::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Dialogs::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Dialogs::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Dialogs::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH Dialogs::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN Dialogs::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Dialog properties + +///////////////////////////////////////////////////////////////////////////// +// Dialog operations + +LPDISPATCH Dialog::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Dialog::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Dialog::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Dialog::Show(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f0, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// SoundNote properties + +///////////////////////////////////////////////////////////////////////////// +// SoundNote operations + +LPDISPATCH SoundNote::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SoundNote::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SoundNote::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT SoundNote::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT SoundNote::Import(LPCTSTR Filename) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x395, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Filename); + return result; +} + +VARIANT SoundNote::Play() +{ + VARIANT result; + InvokeHelper(0x396, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT SoundNote::Record() +{ + VARIANT result; + InvokeHelper(0x397, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Button properties + +///////////////////////////////////////////////////////////////////////////// +// Button operations + +LPDISPATCH Button::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Button::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Button::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Button::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Button::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Button::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Button::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Button::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Button::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Button::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Button::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Button::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Button::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Button::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Button::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Button::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Button::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Button::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Button::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Button::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Button::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Button::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Button::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Button::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Button::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Button::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Button::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Button::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Button::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Button::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Button::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Button::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Button::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Button::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Button::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Button::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Button::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Button::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Button::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Button::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Button::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Button::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Button::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Button::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Button::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Button::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Button::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Button::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Button::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Button::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Button::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Button::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Button::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Button::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Button::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Button::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Button::GetCancelButton() +{ + BOOL result; + InvokeHelper(0x35a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetCancelButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Button::GetDefaultButton() +{ + BOOL result; + InvokeHelper(0x359, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetDefaultButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x359, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Button::GetDismissButton() +{ + BOOL result; + InvokeHelper(0x35b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetDismissButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Button::GetHelpButton() +{ + BOOL result; + InvokeHelper(0x35c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Button::SetHelpButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Button::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Button::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Buttons properties + +///////////////////////////////////////////////////////////////////////////// +// Buttons operations + +LPDISPATCH Buttons::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Buttons::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Buttons::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Buttons::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Buttons::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Buttons::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Buttons::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Buttons::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Buttons::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Buttons::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Buttons::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Buttons::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Buttons::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Buttons::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Buttons::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Buttons::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Buttons::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Buttons::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Buttons::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Buttons::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Buttons::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Buttons::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Buttons::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Buttons::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Buttons::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Buttons::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Buttons::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Buttons::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Buttons::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Buttons::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Buttons::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Buttons::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Buttons::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Buttons::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Buttons::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Buttons::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Buttons::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Buttons::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Buttons::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Buttons::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Buttons::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Buttons::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Buttons::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Buttons::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Buttons::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Buttons::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Buttons::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Buttons::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Buttons::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Buttons::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Buttons::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Buttons::GetCancelButton() +{ + BOOL result; + InvokeHelper(0x35a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetCancelButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Buttons::GetDefaultButton() +{ + BOOL result; + InvokeHelper(0x359, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetDefaultButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x359, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Buttons::GetDismissButton() +{ + BOOL result; + InvokeHelper(0x35b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetDismissButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Buttons::GetHelpButton() +{ + BOOL result; + InvokeHelper(0x35c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Buttons::SetHelpButton(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x35c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Buttons::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Buttons::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Buttons::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long Buttons::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Buttons::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Buttons::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Buttons::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// CheckBox properties + +///////////////////////////////////////////////////////////////////////////// +// CheckBox operations + +LPDISPATCH CheckBox::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CheckBox::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBox::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBox::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT CheckBox::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT CheckBox::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT CheckBox::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT CheckBox::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT CheckBox::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBox::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL CheckBox::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBox::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double CheckBox::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void CheckBox::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long CheckBox::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double CheckBox::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void CheckBox::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL CheckBox::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBox::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString CheckBox::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CheckBox::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT CheckBox::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CheckBox::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL CheckBox::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBox::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT CheckBox::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT CheckBox::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double CheckBox::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void CheckBox::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH CheckBox::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL CheckBox::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBox::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double CheckBox::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void CheckBox::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long CheckBox::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBox::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString CheckBox::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CheckBox::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH CheckBox::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT CheckBox::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL CheckBox::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBox::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString CheckBox::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CheckBox::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT CheckBox::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CheckBox::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH CheckBox::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CheckBox::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CheckBox::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL CheckBox::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBox::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH CheckBox::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString CheckBox::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CheckBox::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT CheckBox::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CheckBox::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CheckBox::GetValue() +{ + VARIANT result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CheckBox::SetValue(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// CheckBoxes properties + +///////////////////////////////////////////////////////////////////////////// +// CheckBoxes operations + +LPDISPATCH CheckBoxes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CheckBoxes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBoxes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT CheckBoxes::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT CheckBoxes::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT CheckBoxes::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT CheckBoxes::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT CheckBoxes::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBoxes::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL CheckBoxes::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double CheckBoxes::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double CheckBoxes::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL CheckBoxes::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT CheckBoxes::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL CheckBoxes::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT CheckBoxes::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT CheckBoxes::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double CheckBoxes::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL CheckBoxes::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double CheckBoxes::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long CheckBoxes::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBoxes::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString CheckBoxes::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH CheckBoxes::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT CheckBoxes::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL CheckBoxes::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString CheckBoxes::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT CheckBoxes::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH CheckBoxes::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CheckBoxes::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void CheckBoxes::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL CheckBoxes::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH CheckBoxes::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString CheckBoxes::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT CheckBoxes::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CheckBoxes::GetValue() +{ + VARIANT result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CheckBoxes::SetValue(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH CheckBoxes::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long CheckBoxes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBoxes::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH CheckBoxes::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN CheckBoxes::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// OptionButton properties + +///////////////////////////////////////////////////////////////////////////// +// OptionButton operations + +LPDISPATCH OptionButton::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OptionButton::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButton::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButton::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT OptionButton::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OptionButton::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OptionButton::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT OptionButton::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OptionButton::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButton::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL OptionButton::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButton::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double OptionButton::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OptionButton::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long OptionButton::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double OptionButton::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OptionButton::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL OptionButton::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButton::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString OptionButton::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OptionButton::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT OptionButton::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OptionButton::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL OptionButton::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButton::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT OptionButton::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT OptionButton::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double OptionButton::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OptionButton::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH OptionButton::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL OptionButton::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButton::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double OptionButton::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OptionButton::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long OptionButton::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButton::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString OptionButton::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OptionButton::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH OptionButton::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT OptionButton::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL OptionButton::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButton::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString OptionButton::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OptionButton::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT OptionButton::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OptionButton::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH OptionButton::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OptionButton::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void OptionButton::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL OptionButton::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButton::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH OptionButton::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString OptionButton::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OptionButton::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT OptionButton::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OptionButton::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT OptionButton::GetValue() +{ + VARIANT result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OptionButton::SetValue(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH OptionButton::GetGroupBox() +{ + LPDISPATCH result; + InvokeHelper(0x341, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// OptionButtons properties + +///////////////////////////////////////////////////////////////////////////// +// OptionButtons operations + +LPDISPATCH OptionButtons::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OptionButtons::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButtons::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT OptionButtons::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OptionButtons::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OptionButtons::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT OptionButtons::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OptionButtons::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButtons::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL OptionButtons::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double OptionButtons::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double OptionButtons::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL OptionButtons::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT OptionButtons::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL OptionButtons::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT OptionButtons::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT OptionButtons::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double OptionButtons::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL OptionButtons::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double OptionButtons::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long OptionButtons::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButtons::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString OptionButtons::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH OptionButtons::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT OptionButtons::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL OptionButtons::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString OptionButtons::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT OptionButtons::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH OptionButtons::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OptionButtons::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void OptionButtons::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL OptionButtons::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH OptionButtons::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString OptionButtons::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT OptionButtons::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT OptionButtons::GetValue() +{ + VARIANT result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OptionButtons::SetValue(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH OptionButtons::GetGroupBox() +{ + LPDISPATCH result; + InvokeHelper(0x341, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButtons::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long OptionButtons::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButtons::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH OptionButtons::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN OptionButtons::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// EditBox properties + +///////////////////////////////////////////////////////////////////////////// +// EditBox operations + +LPDISPATCH EditBox::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long EditBox::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH EditBox::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH EditBox::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT EditBox::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT EditBox::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT EditBox::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT EditBox::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT EditBox::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH EditBox::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL EditBox::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBox::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double EditBox::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void EditBox::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long EditBox::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double EditBox::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void EditBox::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL EditBox::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBox::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString EditBox::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void EditBox::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT EditBox::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void EditBox::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL EditBox::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBox::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT EditBox::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT EditBox::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double EditBox::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void EditBox::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH EditBox::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL EditBox::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBox::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double EditBox::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void EditBox::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long EditBox::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH EditBox::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString EditBox::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void EditBox::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH EditBox::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT EditBox::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL EditBox::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBox::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString EditBox::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void EditBox::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL EditBox::GetDisplayVerticalScrollBar() +{ + BOOL result; + InvokeHelper(0x39a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBox::SetDisplayVerticalScrollBar(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x39a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long EditBox::GetInputType() +{ + long result; + InvokeHelper(0x356, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void EditBox::SetInputType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x356, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString EditBox::GetLinkedObject() +{ + CString result; + InvokeHelper(0x35e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL EditBox::GetMultiLine() +{ + BOOL result; + InvokeHelper(0x357, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBox::SetMultiLine(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x357, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL EditBox::GetPasswordEdit() +{ + BOOL result; + InvokeHelper(0x48a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBox::SetPasswordEdit(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x48a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// EditBoxes properties + +///////////////////////////////////////////////////////////////////////////// +// EditBoxes operations + +LPDISPATCH EditBoxes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long EditBoxes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH EditBoxes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT EditBoxes::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT EditBoxes::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT EditBoxes::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT EditBoxes::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT EditBoxes::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH EditBoxes::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL EditBoxes::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double EditBoxes::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double EditBoxes::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL EditBoxes::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT EditBoxes::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL EditBoxes::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT EditBoxes::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT EditBoxes::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double EditBoxes::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL EditBoxes::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double EditBoxes::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long EditBoxes::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH EditBoxes::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString EditBoxes::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH EditBoxes::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT EditBoxes::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL EditBoxes::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString EditBoxes::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL EditBoxes::GetDisplayVerticalScrollBar() +{ + BOOL result; + InvokeHelper(0x39a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetDisplayVerticalScrollBar(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x39a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long EditBoxes::GetInputType() +{ + long result; + InvokeHelper(0x356, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetInputType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x356, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL EditBoxes::GetMultiLine() +{ + BOOL result; + InvokeHelper(0x357, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetMultiLine(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x357, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL EditBoxes::GetPasswordEdit() +{ + BOOL result; + InvokeHelper(0x48a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void EditBoxes::SetPasswordEdit(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x48a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH EditBoxes::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long EditBoxes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH EditBoxes::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT EditBoxes::Item(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN EditBoxes::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ScrollBar properties + +///////////////////////////////////////////////////////////////////////////// +// ScrollBar operations + +LPDISPATCH ScrollBar::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ScrollBar::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBar::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBar::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ScrollBar::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ScrollBar::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ScrollBar::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT ScrollBar::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ScrollBar::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBar::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ScrollBar::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ScrollBar::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ScrollBar::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double ScrollBar::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ScrollBar::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString ScrollBar::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT ScrollBar::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL ScrollBar::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ScrollBar::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT ScrollBar::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double ScrollBar::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH ScrollBar::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ScrollBar::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ScrollBar::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ScrollBar::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBar::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ScrollBar::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBar::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ScrollBar::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString ScrollBar::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long ScrollBar::GetMax() +{ + long result; + InvokeHelper(0x34a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetMax(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ScrollBar::GetMin() +{ + long result; + InvokeHelper(0x34b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetMin(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ScrollBar::GetSmallChange() +{ + long result; + InvokeHelper(0x34c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetSmallChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ScrollBar::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ScrollBar::GetLargeChange() +{ + long result; + InvokeHelper(0x34d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBar::SetLargeChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ScrollBars properties + +///////////////////////////////////////////////////////////////////////////// +// ScrollBars operations + +LPDISPATCH ScrollBars::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ScrollBars::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBars::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ScrollBars::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ScrollBars::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ScrollBars::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT ScrollBars::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ScrollBars::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBars::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ScrollBars::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ScrollBars::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double ScrollBars::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ScrollBars::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ScrollBars::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL ScrollBars::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ScrollBars::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT ScrollBars::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double ScrollBars::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ScrollBars::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ScrollBars::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ScrollBars::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBars::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ScrollBars::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBars::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ScrollBars::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString ScrollBars::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long ScrollBars::GetMax() +{ + long result; + InvokeHelper(0x34a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetMax(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ScrollBars::GetMin() +{ + long result; + InvokeHelper(0x34b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetMin(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ScrollBars::GetSmallChange() +{ + long result; + InvokeHelper(0x34c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetSmallChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ScrollBars::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ScrollBars::GetLargeChange() +{ + long result; + InvokeHelper(0x34d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ScrollBars::SetLargeChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH ScrollBars::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long ScrollBars::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBars::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ScrollBars::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ScrollBars::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ListBox properties + +///////////////////////////////////////////////////////////////////////////// +// ListBox operations + +LPDISPATCH ListBox::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListBox::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBox::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBox::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ListBox::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBox::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBox::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT ListBox::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBox::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBox::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ListBox::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBox::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ListBox::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ListBox::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ListBox::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double ListBox::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ListBox::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ListBox::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBox::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString ListBox::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ListBox::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT ListBox::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ListBox::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL ListBox::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBox::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ListBox::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT ListBox::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double ListBox::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ListBox::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH ListBox::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ListBox::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBox::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ListBox::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ListBox::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ListBox::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBox::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ListBox::AddItem(const VARIANT& Text, const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x353, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Text, &Index); + return result; +} + +BOOL ListBox::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBox::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ListBox::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListBox::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString ListBox::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ListBox::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT ListBox::GetLinkedObject() +{ + VARIANT result; + InvokeHelper(0x35e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBox::GetList(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void ListBox::SetList(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +long ListBox::GetListCount() +{ + long result; + InvokeHelper(0x351, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString ListBox::GetListFillRange() +{ + CString result; + InvokeHelper(0x34f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ListBox::SetListFillRange(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x34f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long ListBox::GetListIndex() +{ + long result; + InvokeHelper(0x352, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListBox::SetListIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x352, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ListBox::GetMultiSelect() +{ + long result; + InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListBox::SetMultiSelect(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT ListBox::RemoveAllItems() +{ + VARIANT result; + InvokeHelper(0x355, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBox::RemoveItem(long Index, const VARIANT& Count) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x354, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Index, &Count); + return result; +} + +VARIANT ListBox::GetSelected(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void ListBox::SetSelected(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +long ListBox::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListBox::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ListBoxes properties + +///////////////////////////////////////////////////////////////////////////// +// ListBoxes operations + +LPDISPATCH ListBoxes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListBoxes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBoxes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ListBoxes::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBoxes::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBoxes::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT ListBoxes::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBoxes::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBoxes::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ListBoxes::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ListBoxes::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double ListBoxes::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ListBoxes::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ListBoxes::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL ListBoxes::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ListBoxes::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT ListBoxes::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double ListBoxes::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ListBoxes::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ListBoxes::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ListBoxes::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBoxes::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ListBoxes::AddItem(const VARIANT& Text, const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x353, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Text, &Index); + return result; +} + +BOOL ListBoxes::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ListBoxes::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListBoxes::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString ListBoxes::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT ListBoxes::GetList(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void ListBoxes::SetList(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +CString ListBoxes::GetListFillRange() +{ + CString result; + InvokeHelper(0x34f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetListFillRange(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x34f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long ListBoxes::GetListIndex() +{ + long result; + InvokeHelper(0x352, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetListIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x352, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ListBoxes::GetMultiSelect() +{ + long result; + InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetMultiSelect(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT ListBoxes::RemoveAllItems() +{ + VARIANT result; + InvokeHelper(0x355, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListBoxes::RemoveItem(long Index, const VARIANT& Count) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x354, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Index, &Count); + return result; +} + +VARIANT ListBoxes::GetSelected(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void ListBoxes::SetSelected(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +long ListBoxes::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListBoxes::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH ListBoxes::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long ListBoxes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBoxes::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListBoxes::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ListBoxes::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// GroupBox properties + +///////////////////////////////////////////////////////////////////////////// +// GroupBox operations + +LPDISPATCH GroupBox::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long GroupBox::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBox::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBox::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupBox::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupBox::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupBox::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT GroupBox::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupBox::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBox::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL GroupBox::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBox::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double GroupBox::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupBox::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long GroupBox::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double GroupBox::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupBox::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL GroupBox::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBox::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString GroupBox::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void GroupBox::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT GroupBox::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupBox::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupBox::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBox::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupBox::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT GroupBox::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double GroupBox::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupBox::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH GroupBox::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL GroupBox::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBox::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double GroupBox::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupBox::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long GroupBox::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBox::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString GroupBox::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void GroupBox::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH GroupBox::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT GroupBox::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL GroupBox::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBox::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString GroupBox::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void GroupBox::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT GroupBox::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupBox::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupBox::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBox::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupBox::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupBox::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// GroupBoxes properties + +///////////////////////////////////////////////////////////////////////////// +// GroupBoxes operations + +LPDISPATCH GroupBoxes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long GroupBoxes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBoxes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupBoxes::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupBoxes::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupBoxes::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT GroupBoxes::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupBoxes::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBoxes::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL GroupBoxes::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double GroupBoxes::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double GroupBoxes::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL GroupBoxes::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupBoxes::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupBoxes::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupBoxes::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT GroupBoxes::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double GroupBoxes::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL GroupBoxes::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double GroupBoxes::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long GroupBoxes::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBoxes::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString GroupBoxes::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH GroupBoxes::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT GroupBoxes::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL GroupBoxes::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString GroupBoxes::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT GroupBoxes::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupBoxes::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupBoxes::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupBoxes::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH GroupBoxes::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long GroupBoxes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBoxes::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupBoxes::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN GroupBoxes::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DropDown properties + +///////////////////////////////////////////////////////////////////////////// +// DropDown operations + +LPDISPATCH DropDown::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DropDown::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDown::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDown::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DropDown::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDown::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDown::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT DropDown::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDown::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDown::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DropDown::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDown::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double DropDown::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DropDown::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long DropDown::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double DropDown::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DropDown::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL DropDown::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDown::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString DropDown::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDown::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT DropDown::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DropDown::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DropDown::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDown::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DropDown::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT DropDown::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double DropDown::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DropDown::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH DropDown::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DropDown::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDown::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double DropDown::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DropDown::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long DropDown::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDown::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DropDown::AddItem(const VARIANT& Text, const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x353, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Text, &Index); + return result; +} + +BOOL DropDown::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDown::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long DropDown::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DropDown::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DropDown::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDown::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT DropDown::GetLinkedObject() +{ + VARIANT result; + InvokeHelper(0x35e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDown::GetList(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void DropDown::SetList(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +long DropDown::GetListCount() +{ + long result; + InvokeHelper(0x351, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString DropDown::GetListFillRange() +{ + CString result; + InvokeHelper(0x34f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDown::SetListFillRange(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x34f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long DropDown::GetListIndex() +{ + long result; + InvokeHelper(0x352, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DropDown::SetListIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x352, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT DropDown::RemoveAllItems() +{ + VARIANT result; + InvokeHelper(0x355, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDown::RemoveItem(long Index, const VARIANT& Count) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x354, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Index, &Count); + return result; +} + +VARIANT DropDown::GetSelected(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void DropDown::SetSelected(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +long DropDown::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DropDown::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DropDown::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDown::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DropDown::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +long DropDown::GetDropDownLines() +{ + long result; + InvokeHelper(0x350, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DropDown::SetDropDownLines(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x350, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DropDown::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDown::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// DropDowns properties + +///////////////////////////////////////////////////////////////////////////// +// DropDowns operations + +LPDISPATCH DropDowns::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DropDowns::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDowns::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DropDowns::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDowns::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDowns::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT DropDowns::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDowns::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDowns::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DropDowns::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDowns::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double DropDowns::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DropDowns::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double DropDowns::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DropDowns::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL DropDowns::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDowns::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DropDowns::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DropDowns::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DropDowns::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDowns::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DropDowns::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT DropDowns::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double DropDowns::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DropDowns::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL DropDowns::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDowns::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double DropDowns::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DropDowns::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long DropDowns::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDowns::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DropDowns::AddItem(const VARIANT& Text, const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x353, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Text, &Index); + return result; +} + +BOOL DropDowns::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DropDowns::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long DropDowns::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DropDowns::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DropDowns::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDowns::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT DropDowns::GetList(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void DropDowns::SetList(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +CString DropDowns::GetListFillRange() +{ + CString result; + InvokeHelper(0x34f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDowns::SetListFillRange(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x34f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long DropDowns::GetListIndex() +{ + long result; + InvokeHelper(0x352, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DropDowns::SetListIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x352, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT DropDowns::RemoveAllItems() +{ + VARIANT result; + InvokeHelper(0x355, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT DropDowns::RemoveItem(long Index, const VARIANT& Count) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x354, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Index, &Count); + return result; +} + +VARIANT DropDowns::GetSelected(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void DropDowns::SetSelected(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x463, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +long DropDowns::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DropDowns::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DropDowns::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDowns::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DropDowns::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +long DropDowns::GetDropDownLines() +{ + long result; + InvokeHelper(0x350, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DropDowns::SetDropDownLines(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x350, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString DropDowns::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DropDowns::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DropDowns::Add(double Left, double Top, double Width, double Height, const VARIANT& Editable) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height, &Editable); + return result; +} + +long DropDowns::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDowns::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropDowns::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN DropDowns::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Spinner properties + +///////////////////////////////////////////////////////////////////////////// +// Spinner operations + +LPDISPATCH Spinner::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Spinner::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinner::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinner::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Spinner::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Spinner::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Spinner::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Spinner::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Spinner::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinner::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Spinner::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinner::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Spinner::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Spinner::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Spinner::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Spinner::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Spinner::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Spinner::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinner::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Spinner::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Spinner::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Spinner::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Spinner::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Spinner::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinner::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Spinner::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Spinner::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Spinner::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Spinner::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Spinner::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Spinner::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinner::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Spinner::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Spinner::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Spinner::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinner::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Spinner::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinner::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Spinner::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinner::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Spinner::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Spinner::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long Spinner::GetMax() +{ + long result; + InvokeHelper(0x34a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinner::SetMax(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Spinner::GetMin() +{ + long result; + InvokeHelper(0x34b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinner::SetMin(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Spinner::GetSmallChange() +{ + long result; + InvokeHelper(0x34c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinner::SetSmallChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Spinner::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinner::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Spinners properties + +///////////////////////////////////////////////////////////////////////////// +// Spinners operations + +LPDISPATCH Spinners::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Spinners::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinners::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Spinners::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Spinners::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Spinners::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Spinners::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Spinners::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinners::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Spinners::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinners::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Spinners::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Spinners::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Spinners::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Spinners::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Spinners::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinners::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Spinners::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Spinners::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Spinners::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinners::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Spinners::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Spinners::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Spinners::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Spinners::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Spinners::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinners::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Spinners::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Spinners::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Spinners::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinners::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Spinners::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinners::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Spinners::GetDisplay3DShading() +{ + BOOL result; + InvokeHelper(0x462, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Spinners::SetDisplay3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x462, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Spinners::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Spinners::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long Spinners::GetMax() +{ + long result; + InvokeHelper(0x34a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinners::SetMax(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Spinners::GetMin() +{ + long result; + InvokeHelper(0x34b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinners::SetMin(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Spinners::GetSmallChange() +{ + long result; + InvokeHelper(0x34c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinners::SetSmallChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Spinners::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Spinners::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Spinners::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long Spinners::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinners::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Spinners::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Spinners::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DialogFrame properties + +///////////////////////////////////////////////////////////////////////////// +// DialogFrame operations + +LPDISPATCH DialogFrame::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DialogFrame::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogFrame::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DialogFrame::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +double DialogFrame::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double DialogFrame::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL DialogFrame::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString DialogFrame::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT DialogFrame::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +double DialogFrame::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double DialogFrame::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH DialogFrame::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DialogFrame::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DialogFrame::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT DialogFrame::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL DialogFrame::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString DialogFrame::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DialogFrame::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Label properties + +///////////////////////////////////////////////////////////////////////////// +// Label operations + +LPDISPATCH Label::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Label::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Label::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Label::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Label::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Label::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Label::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Label::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Label::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Label::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Label::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Label::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Label::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Label::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Label::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Label::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Label::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Label::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Label::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Label::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Label::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Label::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Label::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Label::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Label::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Label::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Label::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Label::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Label::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Label::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Label::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Label::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Label::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Label::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Label::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Label::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Label::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Label::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Label::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Label::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL Label::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Label::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Label::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Label::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Label::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Label::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Label::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Label::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Labels properties + +///////////////////////////////////////////////////////////////////////////// +// Labels operations + +LPDISPATCH Labels::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Labels::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Labels::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Labels::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Labels::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Labels::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Labels::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Labels::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Labels::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Labels::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Labels::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Labels::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Labels::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Labels::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Labels::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Labels::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Labels::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Labels::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Labels::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Labels::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Labels::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Labels::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Labels::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Labels::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Labels::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Labels::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Labels::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Labels::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Labels::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Labels::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Labels::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Labels::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Labels::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Labels::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Labels::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +BOOL Labels::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Labels::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Labels::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Labels::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Labels::GetAccelerator() +{ + VARIANT result; + InvokeHelper(0x34e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Labels::SetAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x34e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Labels::GetPhoneticAccelerator() +{ + VARIANT result; + InvokeHelper(0x461, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Labels::SetPhoneticAccelerator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x461, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Labels::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long Labels::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Labels::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Labels::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Labels::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Panes properties + +///////////////////////////////////////////////////////////////////////////// +// Panes operations + +LPDISPATCH Panes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Panes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Panes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Panes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Panes::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH Panes::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Pane properties + +///////////////////////////////////////////////////////////////////////////// +// Pane operations + +LPDISPATCH Pane::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Pane::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pane::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Pane::Activate() +{ + BOOL result; + InvokeHelper(0x130, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL); + return result; +} + +long Pane::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Pane::LargeScroll(const VARIANT& Down, const VARIANT& Up, const VARIANT& ToRight, const VARIANT& ToLeft) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x223, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Down, &Up, &ToRight, &ToLeft); + return result; +} + +long Pane::GetScrollColumn() +{ + long result; + InvokeHelper(0x28e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Pane::SetScrollColumn(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x28e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Pane::GetScrollRow() +{ + long result; + InvokeHelper(0x28f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Pane::SetScrollRow(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x28f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Pane::SmallScroll(const VARIANT& Down, const VARIANT& Up, const VARIANT& ToRight, const VARIANT& ToLeft) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x224, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Down, &Up, &ToRight, &ToLeft); + return result; +} + +LPDISPATCH Pane::GetVisibleRange() +{ + LPDISPATCH result; + InvokeHelper(0x45e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Pane::ScrollIntoView(long Left, long Top, long Width, long Height, const VARIANT& Start) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x6f5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Left, Top, Width, Height, &Start); +} + + +///////////////////////////////////////////////////////////////////////////// +// Scenarios properties + +///////////////////////////////////////////////////////////////////////////// +// Scenarios operations + +LPDISPATCH Scenarios::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Scenarios::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Scenarios::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Scenarios::Add(LPCTSTR Name, const VARIANT& ChangingCells, const VARIANT& Values, const VARIANT& Comment, const VARIANT& Locked, const VARIANT& Hidden) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, &ChangingCells, &Values, &Comment, &Locked, &Hidden); + return result; +} + +long Scenarios::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Scenarios::CreateSummary(long ReportType, const VARIANT& ResultCells) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x391, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + ReportType, &ResultCells); + return result; +} + +LPDISPATCH Scenarios::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +VARIANT Scenarios::Merge(const VARIANT& Source) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x234, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Source); + return result; +} + +LPUNKNOWN Scenarios::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Scenario properties + +///////////////////////////////////////////////////////////////////////////// +// Scenario operations + +LPDISPATCH Scenario::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Scenario::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Scenario::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Scenario::ChangeScenario(const VARIANT& ChangingCells, const VARIANT& Values) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x390, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &ChangingCells, &Values); + return result; +} + +LPDISPATCH Scenario::GetChangingCells() +{ + LPDISPATCH result; + InvokeHelper(0x38f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Scenario::GetComment() +{ + CString result; + InvokeHelper(0x38e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Scenario::SetComment(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x38e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Scenario::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL Scenario::GetHidden() +{ + BOOL result; + InvokeHelper(0x10c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Scenario::SetHidden(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Scenario::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL Scenario::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Scenario::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Scenario::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Scenario::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Scenario::Show() +{ + VARIANT result; + InvokeHelper(0x1f0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Scenario::GetValues(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xa4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// GroupObject properties + +///////////////////////////////////////////////////////////////////////////// +// GroupObject operations + +LPDISPATCH GroupObject::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long GroupObject::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObject::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObject::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObject::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupObject::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupObject::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT GroupObject::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupObject::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObject::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL GroupObject::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObject::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double GroupObject::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupObject::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long GroupObject::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double GroupObject::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupObject::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL GroupObject::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObject::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString GroupObject::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void GroupObject::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT GroupObject::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObject::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupObject::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObject::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupObject::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT GroupObject::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double GroupObject::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupObject::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH GroupObject::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL GroupObject::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObject::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double GroupObject::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupObject::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long GroupObject::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObject::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL GroupObject::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObject::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupObject::GetArrowHeadLength() +{ + VARIANT result; + InvokeHelper(0x263, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObject::SetArrowHeadLength(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x263, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT GroupObject::GetArrowHeadStyle() +{ + VARIANT result; + InvokeHelper(0x264, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObject::SetArrowHeadStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x264, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT GroupObject::GetArrowHeadWidth() +{ + VARIANT result; + InvokeHelper(0x265, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObject::SetArrowHeadWidth(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x265, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupObject::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObject::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH GroupObject::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObject::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +long GroupObject::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void GroupObject::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH GroupObject::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObject::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObject::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH GroupObject::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObject::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObject::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupObject::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObject::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL GroupObject::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObject::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH GroupObject::Ungroup() +{ + LPDISPATCH result; + InvokeHelper(0xf4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObject::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObject::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long GroupObject::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void GroupObject::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// GroupObjects properties + +///////////////////////////////////////////////////////////////////////////// +// GroupObjects operations + +LPDISPATCH GroupObjects::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long GroupObjects::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObjects::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObjects::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupObjects::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupObjects::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT GroupObjects::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT GroupObjects::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObjects::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL GroupObjects::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double GroupObjects::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double GroupObjects::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL GroupObjects::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupObjects::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupObjects::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupObjects::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT GroupObjects::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double GroupObjects::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL GroupObjects::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double GroupObjects::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long GroupObjects::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObjects::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL GroupObjects::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT GroupObjects::GetArrowHeadLength() +{ + VARIANT result; + InvokeHelper(0x263, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetArrowHeadLength(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x263, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT GroupObjects::GetArrowHeadStyle() +{ + VARIANT result; + InvokeHelper(0x264, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetArrowHeadStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x264, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT GroupObjects::GetArrowHeadWidth() +{ + VARIANT result; + InvokeHelper(0x265, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetArrowHeadWidth(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x265, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupObjects::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH GroupObjects::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObjects::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +long GroupObjects::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void GroupObjects::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH GroupObjects::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObjects::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH GroupObjects::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObjects::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL GroupObjects::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL GroupObjects::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH GroupObjects::Ungroup() +{ + LPDISPATCH result; + InvokeHelper(0xf4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT GroupObjects::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long GroupObjects::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void GroupObjects::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long GroupObjects::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObjects::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupObjects::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN GroupObjects::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Line properties + +///////////////////////////////////////////////////////////////////////////// +// Line operations + +LPDISPATCH Line::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Line::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Line::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Line::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Line::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Line::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Line::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Line::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Line::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Line::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Line::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Line::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Line::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Line::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Line::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Line::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Line::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Line::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Line::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Line::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Line::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Line::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Line::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Line::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Line::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Line::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Line::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Line::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Line::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Line::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Line::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Line::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Line::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Line::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Line::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Line::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Line::GetArrowHeadLength() +{ + VARIANT result; + InvokeHelper(0x263, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Line::SetArrowHeadLength(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x263, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Line::GetArrowHeadStyle() +{ + VARIANT result; + InvokeHelper(0x264, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Line::SetArrowHeadStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x264, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Line::GetArrowHeadWidth() +{ + VARIANT result; + InvokeHelper(0x265, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Line::SetArrowHeadWidth(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x265, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Line::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Lines properties + +///////////////////////////////////////////////////////////////////////////// +// Lines operations + +LPDISPATCH Lines::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Lines::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Lines::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Lines::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Lines::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Lines::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Lines::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Lines::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Lines::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Lines::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Lines::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Lines::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Lines::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Lines::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Lines::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Lines::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Lines::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Lines::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Lines::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Lines::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Lines::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Lines::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Lines::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Lines::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Lines::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Lines::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Lines::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Lines::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Lines::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Lines::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Lines::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Lines::GetArrowHeadLength() +{ + VARIANT result; + InvokeHelper(0x263, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Lines::SetArrowHeadLength(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x263, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Lines::GetArrowHeadStyle() +{ + VARIANT result; + InvokeHelper(0x264, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Lines::SetArrowHeadStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x264, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Lines::GetArrowHeadWidth() +{ + VARIANT result; + InvokeHelper(0x265, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Lines::SetArrowHeadWidth(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x265, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Lines::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Lines::Add(double X1, double Y1, double X2, double Y2) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + X1, Y1, X2, Y2); + return result; +} + +long Lines::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Lines::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Lines::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Lines::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Rectangle properties + +///////////////////////////////////////////////////////////////////////////// +// Rectangle operations + +LPDISPATCH Rectangle::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Rectangle::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangle::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangle::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Rectangle::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Rectangle::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Rectangle::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Rectangle::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Rectangle::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangle::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Rectangle::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Rectangle::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Rectangle::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Rectangle::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Rectangle::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Rectangle::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Rectangle::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Rectangle::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Rectangle::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Rectangle::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangle::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Rectangle::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Rectangle::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Rectangle::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Rectangle::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Rectangle::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Rectangle::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Rectangle::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Rectangle::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Rectangle::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Rectangle::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangle::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Rectangle::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Rectangle::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangle::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Rectangle::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Rectangle::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Rectangle::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Rectangle::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Rectangle::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Rectangle::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Rectangle::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Rectangle::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Rectangle::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangle::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Rectangle::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Rectangle::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangle::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Rectangle::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Rectangle::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Rectangle::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangle::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Rectangle::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Rectangle::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Rectangle::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangle::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Rectangle::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Rectangle::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangle::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Rectangles properties + +///////////////////////////////////////////////////////////////////////////// +// Rectangles operations + +LPDISPATCH Rectangles::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Rectangles::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangles::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Rectangles::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Rectangles::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Rectangles::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Rectangles::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Rectangles::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangles::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Rectangles::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Rectangles::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Rectangles::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Rectangles::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Rectangles::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Rectangles::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Rectangles::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangles::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Rectangles::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Rectangles::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Rectangles::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Rectangles::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Rectangles::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Rectangles::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Rectangles::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Rectangles::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Rectangles::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangles::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Rectangles::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Rectangles::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangles::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Rectangles::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Rectangles::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Rectangles::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Rectangles::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Rectangles::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Rectangles::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Rectangles::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Rectangles::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Rectangles::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangles::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Rectangles::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Rectangles::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangles::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Rectangles::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Rectangles::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Rectangles::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Rectangles::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Rectangles::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Rectangles::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Rectangles::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangles::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Rectangles::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Rectangles::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Rectangles::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Rectangles::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long Rectangles::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangles::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Rectangles::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Rectangles::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Oval properties + +///////////////////////////////////////////////////////////////////////////// +// Oval operations + +LPDISPATCH Oval::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Oval::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Oval::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Oval::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Oval::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Oval::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Oval::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Oval::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Oval::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Oval::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Oval::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Oval::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Oval::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Oval::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Oval::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Oval::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Oval::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Oval::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Oval::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Oval::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Oval::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Oval::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Oval::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Oval::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Oval::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Oval::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Oval::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Oval::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Oval::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Oval::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Oval::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Oval::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Oval::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Oval::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Oval::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Oval::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Oval::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Oval::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Oval::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Oval::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Oval::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Oval::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Oval::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Oval::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Oval::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Oval::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Oval::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Oval::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Oval::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Oval::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Oval::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Oval::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Oval::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Oval::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Oval::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Oval::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Oval::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Oval::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Oval::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Oval::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Oval::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Oval::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Oval::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Oval::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Oval::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Ovals properties + +///////////////////////////////////////////////////////////////////////////// +// Ovals operations + +LPDISPATCH Ovals::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Ovals::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Ovals::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Ovals::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Ovals::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Ovals::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Ovals::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Ovals::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Ovals::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Ovals::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Ovals::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Ovals::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Ovals::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Ovals::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Ovals::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Ovals::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Ovals::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Ovals::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Ovals::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Ovals::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Ovals::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Ovals::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Ovals::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Ovals::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Ovals::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Ovals::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Ovals::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Ovals::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Ovals::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Ovals::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Ovals::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Ovals::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Ovals::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Ovals::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Ovals::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Ovals::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Ovals::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Ovals::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Ovals::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Ovals::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Ovals::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Ovals::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Ovals::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Ovals::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Ovals::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Ovals::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Ovals::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Ovals::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Ovals::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Ovals::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Ovals::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Ovals::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Ovals::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Ovals::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Ovals::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Ovals::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Ovals::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Ovals::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Ovals::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Ovals::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Ovals::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long Ovals::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Ovals::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Ovals::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Ovals::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Arc properties + +///////////////////////////////////////////////////////////////////////////// +// Arc operations + +LPDISPATCH Arc::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Arc::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arc::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arc::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Arc::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Arc::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Arc::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Arc::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Arc::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arc::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Arc::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arc::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Arc::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Arc::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Arc::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Arc::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Arc::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Arc::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arc::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Arc::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Arc::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Arc::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arc::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Arc::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arc::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Arc::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Arc::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Arc::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Arc::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Arc::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Arc::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arc::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Arc::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Arc::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Arc::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arc::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Arc::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arc::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Arc::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arc::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Arc::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arc::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Arc::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Arc::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Arc::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Arc::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Arc::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Arc::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Arc::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Arc::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arc::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Arc::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arc::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Arc::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arc::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Arc::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Arc::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Arc::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arc::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Arc::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Arc::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Arc::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arc::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Arcs properties + +///////////////////////////////////////////////////////////////////////////// +// Arcs operations + +LPDISPATCH Arcs::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Arcs::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arcs::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Arcs::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Arcs::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Arcs::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Arcs::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Arcs::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arcs::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Arcs::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arcs::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Arcs::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Arcs::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Arcs::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Arcs::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Arcs::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arcs::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Arcs::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arcs::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Arcs::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arcs::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Arcs::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Arcs::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Arcs::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Arcs::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Arcs::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arcs::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Arcs::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Arcs::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Arcs::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arcs::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Arcs::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arcs::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Arcs::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arcs::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Arcs::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arcs::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Arcs::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Arcs::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Arcs::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Arcs::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Arcs::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Arcs::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Arcs::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Arcs::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arcs::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Arcs::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Arcs::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Arcs::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arcs::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Arcs::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Arcs::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Arcs::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Arcs::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Arcs::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Arcs::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Arcs::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arcs::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arcs::Add(double X1, double Y1, double X2, double Y2) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + X1, Y1, X2, Y2); + return result; +} + +long Arcs::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arcs::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Arcs::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Arcs::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// OLEObjectEvents properties + +///////////////////////////////////////////////////////////////////////////// +// OLEObjectEvents operations + +void OLEObjectEvents::GotFocus() +{ + InvokeHelper(0x605, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void OLEObjectEvents::LostFocus() +{ + InvokeHelper(0x606, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// _OLEObject properties + +///////////////////////////////////////////////////////////////////////////// +// _OLEObject operations + +LPDISPATCH _OLEObject::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x80010094, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _OLEObject::GetCreator() +{ + long result; + InvokeHelper(0x80010095, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _OLEObject::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x80010096, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _OLEObject::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x80010267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT _OLEObject::BringToFront() +{ + VARIANT result; + InvokeHelper(0x8001025a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT _OLEObject::Copy() +{ + VARIANT result; + InvokeHelper(0x80010227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT _OLEObject::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x800100d5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT _OLEObject::Cut() +{ + VARIANT result; + InvokeHelper(0x80010235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT _OLEObject::Delete() +{ + VARIANT result; + InvokeHelper(0x80010075, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH _OLEObject::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x8001040f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _OLEObject::GetEnabled() +{ + BOOL result; + InvokeHelper(0x80010258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x80010258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double _OLEObject::GetHeight() +{ + double result; + InvokeHelper(0x8001007b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x8001007b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long _OLEObject::GetIndex() +{ + long result; + InvokeHelper(0x800101e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double _OLEObject::GetLeft() +{ + double result; + InvokeHelper(0x8001007f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x8001007f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL _OLEObject::GetLocked() +{ + BOOL result; + InvokeHelper(0x8001010d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8001010d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString _OLEObject::GetName() +{ + CString result; + InvokeHelper(0x8001006e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8001006e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT _OLEObject::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x80010269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x80010269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL _OLEObject::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x8001026a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8001026a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _OLEObject::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x800100eb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT _OLEObject::SendToBack() +{ + VARIANT result; + InvokeHelper(0x8001025d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double _OLEObject::GetTop() +{ + double result; + InvokeHelper(0x8001007e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x8001007e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH _OLEObject::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x8001026c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _OLEObject::GetVisible() +{ + BOOL result; + InvokeHelper(0x8001022e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8001022e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double _OLEObject::GetWidth() +{ + double result; + InvokeHelper(0x8001007a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x8001007a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long _OLEObject::GetZOrder() +{ + long result; + InvokeHelper(0x8001026e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _OLEObject::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x800105f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _OLEObject::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80010080, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _OLEObject::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x80010081, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL _OLEObject::GetShadow() +{ + BOOL result; + InvokeHelper(0x80010067, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x80010067, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _OLEObject::Activate() +{ + VARIANT result; + InvokeHelper(0x80010130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL _OLEObject::GetAutoLoad() +{ + BOOL result; + InvokeHelper(0x800104a2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetAutoLoad(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x800104a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _OLEObject::GetAutoUpdate() +{ + BOOL result; + InvokeHelper(0x80010418, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetAutoUpdate(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x80010418, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _OLEObject::GetObject() +{ + LPDISPATCH result; + InvokeHelper(0x80010419, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT _OLEObject::GetOLEType() +{ + VARIANT result; + InvokeHelper(0x8001041e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +CString _OLEObject::GetSourceName() +{ + CString result; + InvokeHelper(0x800102d1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetSourceName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x800102d1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT _OLEObject::Update() +{ + VARIANT result; + InvokeHelper(0x800102a8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT _OLEObject::Verb(long Verb) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8001025e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Verb); + return result; +} + +CString _OLEObject::GetLinkedCell() +{ + CString result; + InvokeHelper(0x80010422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x80010422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _OLEObject::GetListFillRange() +{ + CString result; + InvokeHelper(0x8001034f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _OLEObject::SetListFillRange(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8001034f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _OLEObject::GetProgID() +{ + CString result; + InvokeHelper(0x800105f3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// OLEObjects properties + +///////////////////////////////////////////////////////////////////////////// +// OLEObjects operations + +LPDISPATCH OLEObjects::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OLEObjects::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEObjects::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT OLEObjects::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OLEObjects::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OLEObjects::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT OLEObjects::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT OLEObjects::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEObjects::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL OLEObjects::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double OLEObjects::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double OLEObjects::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL OLEObjects::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT OLEObjects::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL OLEObjects::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT OLEObjects::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT OLEObjects::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double OLEObjects::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL OLEObjects::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double OLEObjects::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long OLEObjects::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEObjects::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEObjects::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEObjects::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL OLEObjects::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL OLEObjects::GetAutoLoad() +{ + BOOL result; + InvokeHelper(0x4a2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetAutoLoad(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString OLEObjects::GetSourceName() +{ + CString result; + InvokeHelper(0x2d1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OLEObjects::SetSourceName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x2d1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH OLEObjects::Add(const VARIANT& ClassType, const VARIANT& Filename, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel, const VARIANT& Left, const VARIANT& Top, + const VARIANT& Width, const VARIANT& Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &ClassType, &Filename, &Link, &DisplayAsIcon, &IconFileName, &IconIndex, &IconLabel, &Left, &Top, &Width, &Height); + return result; +} + +long OLEObjects::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEObjects::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN OLEObjects::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// TextBox properties + +///////////////////////////////////////////////////////////////////////////// +// TextBox operations + +LPDISPATCH TextBox::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long TextBox::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBox::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBox::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT TextBox::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT TextBox::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT TextBox::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT TextBox::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT TextBox::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBox::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL TextBox::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double TextBox::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void TextBox::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long TextBox::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double TextBox::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void TextBox::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL TextBox::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString TextBox::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextBox::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT TextBox::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBox::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL TextBox::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT TextBox::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT TextBox::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double TextBox::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void TextBox::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH TextBox::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL TextBox::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double TextBox::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void TextBox::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long TextBox::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBox::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL TextBox::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT TextBox::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBox::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL TextBox::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString TextBox::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextBox::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH TextBox::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT TextBox::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH TextBox::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString TextBox::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextBox::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT TextBox::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBox::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL TextBox::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT TextBox::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBox::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString TextBox::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextBox::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT TextBox::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBox::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long TextBox::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextBox::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH TextBox::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBox::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL TextBox::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL TextBox::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBox::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// TextBoxes properties + +///////////////////////////////////////////////////////////////////////////// +// TextBoxes operations + +LPDISPATCH TextBoxes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long TextBoxes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBoxes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT TextBoxes::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT TextBoxes::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT TextBoxes::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT TextBoxes::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT TextBoxes::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBoxes::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL TextBoxes::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double TextBoxes::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double TextBoxes::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL TextBoxes::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT TextBoxes::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL TextBoxes::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT TextBoxes::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT TextBoxes::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double TextBoxes::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL TextBoxes::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double TextBoxes::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long TextBoxes::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBoxes::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL TextBoxes::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT TextBoxes::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL TextBoxes::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString TextBoxes::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH TextBoxes::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT TextBoxes::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH TextBoxes::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString TextBoxes::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT TextBoxes::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL TextBoxes::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT TextBoxes::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString TextBoxes::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT TextBoxes::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long TextBoxes::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH TextBoxes::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBoxes::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL TextBoxes::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL TextBoxes::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextBoxes::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH TextBoxes::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long TextBoxes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBoxes::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextBoxes::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN TextBoxes::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// MyPicture properties + +///////////////////////////////////////////////////////////////////////////// +// MyPicture operations + +LPDISPATCH MyPicture::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long MyPicture::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MyPicture::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH MyPicture::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT MyPicture::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT MyPicture::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT MyPicture::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT MyPicture::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT MyPicture::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH MyPicture::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL MyPicture::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void MyPicture::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double MyPicture::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void MyPicture::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long MyPicture::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double MyPicture::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void MyPicture::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL MyPicture::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void MyPicture::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString MyPicture::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void MyPicture::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT MyPicture::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void MyPicture::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL MyPicture::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void MyPicture::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT MyPicture::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT MyPicture::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double MyPicture::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void MyPicture::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH MyPicture::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL MyPicture::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void MyPicture::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double MyPicture::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void MyPicture::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long MyPicture::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH MyPicture::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH MyPicture::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH MyPicture::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL MyPicture::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void MyPicture::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString MyPicture::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void MyPicture::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Pictures properties + +///////////////////////////////////////////////////////////////////////////// +// Pictures operations + +LPDISPATCH Pictures::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Pictures::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pictures::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Pictures::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Pictures::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Pictures::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Pictures::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Pictures::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pictures::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Pictures::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Pictures::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Pictures::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Pictures::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Pictures::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Pictures::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Pictures::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Pictures::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Pictures::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Pictures::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Pictures::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Pictures::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Pictures::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Pictures::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Pictures::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Pictures::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Pictures::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Pictures::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Pictures::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Pictures::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Pictures::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pictures::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pictures::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pictures::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Pictures::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Pictures::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Pictures::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Pictures::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Pictures::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long Pictures::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pictures::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pictures::Insert(LPCTSTR Filename, const VARIANT& Converter) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0xfc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Filename, &Converter); + return result; +} + +LPDISPATCH Pictures::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Pictures::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH Pictures::Paste(const VARIANT& Link) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Link); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Drawing properties + +///////////////////////////////////////////////////////////////////////////// +// Drawing operations + +LPDISPATCH Drawing::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Drawing::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawing::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawing::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Drawing::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Drawing::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Drawing::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Drawing::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Drawing::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawing::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Drawing::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawing::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Drawing::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Drawing::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Drawing::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Drawing::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Drawing::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Drawing::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawing::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Drawing::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Drawing::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Drawing::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawing::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Drawing::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawing::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawing::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Drawing::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Drawing::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Drawing::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Drawing::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Drawing::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawing::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Drawing::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Drawing::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Drawing::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawing::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Drawing::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawing::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawing::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawing::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Drawing::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawing::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Drawing::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Drawing::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Drawing::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Drawing::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Drawing::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Drawing::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Drawing::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Drawing::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawing::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Drawing::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawing::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawing::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawing::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Drawing::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Drawing::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Drawing::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawing::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Drawing::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Drawing::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Drawing::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawing::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Drawing::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawing::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawing::AddVertex(double Left, double Top) +{ + VARIANT result; + static BYTE parms[] = + VTS_R8 VTS_R8; + InvokeHelper(0x259, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Left, Top); + return result; +} + +VARIANT Drawing::Reshape(long Vertex, BOOL Insert, const VARIANT& Left, const VARIANT& Top) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_BOOL VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Vertex, Insert, &Left, &Top); + return result; +} + +VARIANT Drawing::GetVertices(const VARIANT& Index1, const VARIANT& Index2) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x26d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index1, &Index2); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Drawings properties + +///////////////////////////////////////////////////////////////////////////// +// Drawings operations + +LPDISPATCH Drawings::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Drawings::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawings::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Drawings::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Drawings::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Drawings::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT Drawings::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Drawings::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawings::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Drawings::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawings::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Drawings::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Drawings::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Drawings::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Drawings::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Drawings::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawings::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawings::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawings::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Drawings::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawings::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawings::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT Drawings::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Drawings::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Drawings::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Drawings::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawings::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Drawings::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Drawings::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Drawings::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawings::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Drawings::GetAddIndent() +{ + BOOL result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawings::SetAddIndent(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawings::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawings::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Drawings::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawings::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Drawings::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Drawings::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Drawings::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +VARIANT Drawings::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); + return result; +} + +LPDISPATCH Drawings::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Drawings::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Drawings::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Drawings::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawings::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Drawings::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawings::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawings::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawings::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Drawings::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Drawings::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Drawings::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Drawings::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Drawings::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Drawings::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Drawings::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawings::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Drawings::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Drawings::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Drawings::Reshape(long Vertex, BOOL Insert, const VARIANT& Left, const VARIANT& Top) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_BOOL VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Vertex, Insert, &Left, &Top); + return result; +} + +LPDISPATCH Drawings::Add(double X1, double Y1, double X2, double Y2, BOOL Closed) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_BOOL; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + X1, Y1, X2, Y2, Closed); + return result; +} + +long Drawings::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawings::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Drawings::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Drawings::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// RoutingSlip properties + +///////////////////////////////////////////////////////////////////////////// +// RoutingSlip operations + +LPDISPATCH RoutingSlip::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long RoutingSlip::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH RoutingSlip::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long RoutingSlip::GetDelivery() +{ + long result; + InvokeHelper(0x3bb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void RoutingSlip::SetDelivery(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3bb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT RoutingSlip::GetMessage() +{ + VARIANT result; + InvokeHelper(0x3ba, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void RoutingSlip::SetMessage(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3ba, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT RoutingSlip::GetRecipients(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3b8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void RoutingSlip::SetRecipients(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3b8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +VARIANT RoutingSlip::Reset() +{ + VARIANT result; + InvokeHelper(0x22b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL RoutingSlip::GetReturnWhenDone() +{ + BOOL result; + InvokeHelper(0x3bc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void RoutingSlip::SetReturnWhenDone(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3bc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long RoutingSlip::GetStatus() +{ + long result; + InvokeHelper(0x3be, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT RoutingSlip::GetSubject() +{ + VARIANT result; + InvokeHelper(0x3b9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void RoutingSlip::SetSubject(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3b9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL RoutingSlip::GetTrackStatus() +{ + BOOL result; + InvokeHelper(0x3bd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void RoutingSlip::SetTrackStatus(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3bd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Outline properties + +///////////////////////////////////////////////////////////////////////////// +// Outline operations + +LPDISPATCH Outline::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Outline::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Outline::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Outline::GetAutomaticStyles() +{ + BOOL result; + InvokeHelper(0x3bf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Outline::SetAutomaticStyles(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3bf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Outline::ShowLevels(const VARIANT& RowLevels, const VARIANT& ColumnLevels) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3c0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &RowLevels, &ColumnLevels); + return result; +} + +long Outline::GetSummaryColumn() +{ + long result; + InvokeHelper(0x3c1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Outline::SetSummaryColumn(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3c1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Outline::GetSummaryRow() +{ + long result; + InvokeHelper(0x386, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Outline::SetSummaryRow(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x386, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Module properties + +///////////////////////////////////////////////////////////////////////////// +// Module operations + +LPDISPATCH Module::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Module::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Module::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Module::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Module::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +void Module::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString Module::GetCodeName() +{ + CString result; + InvokeHelper(0x55d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString Module::Get_CodeName() +{ + CString result; + InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Module::Set_CodeName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long Module::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Module::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +CString Module::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Module::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Module::GetNext() +{ + LPDISPATCH result; + InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Module::GetPageSetup() +{ + LPDISPATCH result; + InvokeHelper(0x3e6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Module::GetPrevious() +{ + LPDISPATCH result; + InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Module::GetProtectContents() +{ + BOOL result; + InvokeHelper(0x124, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Module::GetProtectionMode() +{ + BOOL result; + InvokeHelper(0x487, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Module::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +void Module::Unprotect(const VARIANT& Password) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password); +} + +long Module::GetVisible() +{ + long result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Module::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Module::GetShapes() +{ + LPDISPATCH result; + InvokeHelper(0x561, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Module::InsertFile(const VARIANT& Filename, const VARIANT& Merge) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x248, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Filename, &Merge); + return result; +} + +void Module::SaveAs(LPCTSTR Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AddToMru, const VARIANT& TextCodepage, + const VARIANT& TextVisualLayout) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x785, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &AddToMru, &TextCodepage, &TextVisualLayout); +} + +void Module::Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7ed, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password, &DrawingObjects, &Contents, &Scenarios, &UserInterfaceOnly); +} + + +///////////////////////////////////////////////////////////////////////////// +// Modules properties + +///////////////////////////////////////////////////////////////////////////// +// Modules operations + +LPDISPATCH Modules::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Modules::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Modules::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Modules::Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Before, &After, &Count); + return result; +} + +void Modules::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +long Modules::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Modules::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Modules::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Modules::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +LPUNKNOWN Modules::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void Modules::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +LPDISPATCH Modules::GetHPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Modules::GetVPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Modules::GetVisible() +{ + VARIANT result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Modules::SetVisible(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Modules::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Modules::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + + +///////////////////////////////////////////////////////////////////////////// +// DialogSheet properties + +///////////////////////////////////////////////////////////////////////////// +// DialogSheet operations + +LPDISPATCH DialogSheet::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DialogSheet::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void DialogSheet::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void DialogSheet::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +void DialogSheet::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString DialogSheet::GetCodeName() +{ + CString result; + InvokeHelper(0x55d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString DialogSheet::Get_CodeName() +{ + CString result; + InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DialogSheet::Set_CodeName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long DialogSheet::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DialogSheet::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +CString DialogSheet::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DialogSheet::GetNext() +{ + LPDISPATCH result; + InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetPageSetup() +{ + LPDISPATCH result; + InvokeHelper(0x3e6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetPrevious() +{ + LPDISPATCH result; + InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void DialogSheet::PrintPreview(const VARIANT& EnableChanges) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EnableChanges); +} + +BOOL DialogSheet::GetProtectContents() +{ + BOOL result; + InvokeHelper(0x124, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL DialogSheet::GetProtectDrawingObjects() +{ + BOOL result; + InvokeHelper(0x125, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL DialogSheet::GetProtectionMode() +{ + BOOL result; + InvokeHelper(0x487, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL DialogSheet::GetProtectScenarios() +{ + BOOL result; + InvokeHelper(0x126, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogSheet::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +void DialogSheet::Unprotect(const VARIANT& Password) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password); +} + +long DialogSheet::GetVisible() +{ + long result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH DialogSheet::GetShapes() +{ + LPDISPATCH result; + InvokeHelper(0x561, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DialogSheet::GetEnableCalculation() +{ + BOOL result; + InvokeHelper(0x590, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetEnableCalculation(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x590, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH DialogSheet::ChartObjects(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x424, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void DialogSheet::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x1f9, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang); +} + +BOOL DialogSheet::GetEnableAutoFilter() +{ + BOOL result; + InvokeHelper(0x484, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetEnableAutoFilter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x484, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long DialogSheet::GetEnableSelection() +{ + long result; + InvokeHelper(0x591, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetEnableSelection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x591, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL DialogSheet::GetEnableOutlining() +{ + BOOL result; + InvokeHelper(0x485, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetEnableOutlining(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x485, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DialogSheet::GetEnablePivotTable() +{ + BOOL result; + InvokeHelper(0x486, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetEnablePivotTable(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x486, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DialogSheet::Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +VARIANT DialogSheet::_Evaluate(const VARIANT& Name) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Name); + return result; +} + +void DialogSheet::ResetAllPageBreaks() +{ + InvokeHelper(0x592, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH DialogSheet::GetNames() +{ + LPDISPATCH result; + InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::OLEObjects(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x31f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void DialogSheet::Paste(const VARIANT& Destination, const VARIANT& Link) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xd3, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Destination, &Link); +} + +CString DialogSheet::GetScrollArea() +{ + CString result; + InvokeHelper(0x599, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetScrollArea(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x599, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DialogSheet::GetHPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetVPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetQueryTables() +{ + LPDISPATCH result; + InvokeHelper(0x59a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DialogSheet::GetDisplayPageBreaks() +{ + BOOL result; + InvokeHelper(0x59b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetDisplayPageBreaks(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x59b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH DialogSheet::GetComments() +{ + LPDISPATCH result; + InvokeHelper(0x23f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetHyperlinks() +{ + LPDISPATCH result; + InvokeHelper(0x571, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void DialogSheet::ClearCircles() +{ + InvokeHelper(0x59c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void DialogSheet::CircleInvalid() +{ + InvokeHelper(0x59d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH DialogSheet::GetAutoFilter() +{ + LPDISPATCH result; + InvokeHelper(0x319, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DialogSheet::GetDisplayRightToLeft() +{ + BOOL result; + InvokeHelper(0x6ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetDisplayRightToLeft(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x6ee, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH DialogSheet::GetScripts() +{ + LPDISPATCH result; + InvokeHelper(0x718, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void DialogSheet::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + +LPDISPATCH DialogSheet::GetTab() +{ + LPDISPATCH result; + InvokeHelper(0x411, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetMailEnvelope() +{ + LPDISPATCH result; + InvokeHelper(0x7e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void DialogSheet::SaveAs(LPCTSTR Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AddToMru, const VARIANT& TextCodepage, + const VARIANT& TextVisualLayout, const VARIANT& Local) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x785, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &AddToMru, &TextCodepage, &TextVisualLayout, &Local); +} + +LPDISPATCH DialogSheet::GetCustomProperties() +{ + LPDISPATCH result; + InvokeHelper(0x7ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetSmartTags() +{ + LPDISPATCH result; + InvokeHelper(0x7e0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheet::GetProtection() +{ + LPDISPATCH result; + InvokeHelper(0xb0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void DialogSheet::PasteSpecial(const VARIANT& Format, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel, const VARIANT& NoHTMLFormatting) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x788, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Format, &Link, &DisplayAsIcon, &IconFileName, &IconIndex, &IconLabel, &NoHTMLFormatting); +} + +void DialogSheet::Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly, const VARIANT& AllowFormattingCells, const VARIANT& AllowFormattingColumns, + const VARIANT& AllowFormattingRows, const VARIANT& AllowInsertingColumns, const VARIANT& AllowInsertingRows, const VARIANT& AllowInsertingHyperlinks, const VARIANT& AllowDeletingColumns, const VARIANT& AllowDeletingRows, + const VARIANT& AllowSorting, const VARIANT& AllowFiltering, const VARIANT& AllowUsingPivotTables) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7ed, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password, &DrawingObjects, &Contents, &Scenarios, &UserInterfaceOnly, &AllowFormattingCells, &AllowFormattingColumns, &AllowFormattingRows, &AllowInsertingColumns, &AllowInsertingRows, &AllowInsertingHyperlinks, &AllowDeletingColumns, + &AllowDeletingRows, &AllowSorting, &AllowFiltering, &AllowUsingPivotTables); +} + +VARIANT DialogSheet::GetDefaultButton() +{ + VARIANT result; + InvokeHelper(0x359, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetDefaultButton(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x359, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT DialogSheet::GetFocus() +{ + VARIANT result; + InvokeHelper(0x32e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DialogSheet::SetFocus(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x32e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DialogSheet::Hide(const VARIANT& Cancel) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x32d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &Cancel); + return result; +} + +BOOL DialogSheet::Show() +{ + BOOL result; + InvokeHelper(0x1f0, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DialogSheets properties + +///////////////////////////////////////////////////////////////////////////// +// DialogSheets operations + +LPDISPATCH DialogSheets::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DialogSheets::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheets::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheets::Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Before, &After, &Count); + return result; +} + +void DialogSheets::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +long DialogSheets::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DialogSheets::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH DialogSheets::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void DialogSheets::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +LPUNKNOWN DialogSheets::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void DialogSheets::PrintPreview(const VARIANT& EnableChanges) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EnableChanges); +} + +void DialogSheets::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +LPDISPATCH DialogSheets::GetHPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DialogSheets::GetVPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DialogSheets::GetVisible() +{ + VARIANT result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DialogSheets::SetVisible(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH DialogSheets::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void DialogSheets::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + + +///////////////////////////////////////////////////////////////////////////// +// Worksheets properties + +///////////////////////////////////////////////////////////////////////////// +// Worksheets operations + +LPDISPATCH Worksheets::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Worksheets::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Worksheets::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Worksheets::Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count, const VARIANT& Type) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Before, &After, &Count, &Type); + return result; +} + +void Worksheets::Copy(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +long Worksheets::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Worksheets::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Worksheets::FillAcrossSheets(LPDISPATCH Range, long Type) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0x1d5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Range, Type); +} + +LPDISPATCH Worksheets::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Worksheets::Move(const VARIANT& Before, const VARIANT& After) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Before, &After); +} + +LPUNKNOWN Worksheets::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void Worksheets::PrintPreview(const VARIANT& EnableChanges) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &EnableChanges); +} + +void Worksheets::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +LPDISPATCH Worksheets::GetHPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Worksheets::GetVPageBreaks() +{ + LPDISPATCH result; + InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Worksheets::GetVisible() +{ + VARIANT result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Worksheets::SetVisible(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Worksheets::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Worksheets::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName); +} + + +///////////////////////////////////////////////////////////////////////////// +// PageSetup properties + +///////////////////////////////////////////////////////////////////////////// +// PageSetup operations + +LPDISPATCH PageSetup::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PageSetup::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PageSetup::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL PageSetup::GetBlackAndWhite() +{ + BOOL result; + InvokeHelper(0x3f1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PageSetup::SetBlackAndWhite(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3f1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double PageSetup::GetBottomMargin() +{ + double result; + InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PageSetup::SetBottomMargin(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x3ea, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +CString PageSetup::GetCenterFooter() +{ + CString result; + InvokeHelper(0x3f2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetCenterFooter(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3f2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PageSetup::GetCenterHeader() +{ + CString result; + InvokeHelper(0x3f3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetCenterHeader(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3f3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PageSetup::GetCenterHorizontally() +{ + BOOL result; + InvokeHelper(0x3ed, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PageSetup::SetCenterHorizontally(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3ed, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PageSetup::GetCenterVertically() +{ + BOOL result; + InvokeHelper(0x3ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PageSetup::SetCenterVertically(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3ee, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PageSetup::GetChartSize() +{ + long result; + InvokeHelper(0x3f4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PageSetup::SetChartSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3f4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL PageSetup::GetDraft() +{ + BOOL result; + InvokeHelper(0x3fc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PageSetup::SetDraft(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3fc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long PageSetup::GetFirstPageNumber() +{ + long result; + InvokeHelper(0x3f0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PageSetup::SetFirstPageNumber(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3f0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT PageSetup::GetFitToPagesTall() +{ + VARIANT result; + InvokeHelper(0x3f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PageSetup::SetFitToPagesTall(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT PageSetup::GetFitToPagesWide() +{ + VARIANT result; + InvokeHelper(0x3f6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PageSetup::SetFitToPagesWide(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3f6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +double PageSetup::GetFooterMargin() +{ + double result; + InvokeHelper(0x3f7, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PageSetup::SetFooterMargin(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x3f7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double PageSetup::GetHeaderMargin() +{ + double result; + InvokeHelper(0x3f8, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PageSetup::SetHeaderMargin(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x3f8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +CString PageSetup::GetLeftFooter() +{ + CString result; + InvokeHelper(0x3f9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetLeftFooter(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3f9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PageSetup::GetLeftHeader() +{ + CString result; + InvokeHelper(0x3fa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetLeftHeader(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3fa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +double PageSetup::GetLeftMargin() +{ + double result; + InvokeHelper(0x3e7, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PageSetup::SetLeftMargin(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x3e7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long PageSetup::GetOrder() +{ + long result; + InvokeHelper(0xc0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PageSetup::SetOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xc0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long PageSetup::GetOrientation() +{ + long result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PageSetup::SetOrientation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long PageSetup::GetPaperSize() +{ + long result; + InvokeHelper(0x3ef, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPaperSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3ef, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString PageSetup::GetPrintArea() +{ + CString result; + InvokeHelper(0x3fb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPrintArea(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3fb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL PageSetup::GetPrintGridlines() +{ + BOOL result; + InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPrintGridlines(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3ec, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PageSetup::GetPrintHeadings() +{ + BOOL result; + InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPrintHeadings(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3eb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL PageSetup::GetPrintNotes() +{ + BOOL result; + InvokeHelper(0x3fd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPrintNotes(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3fd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT PageSetup::GetPrintQuality(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3fe, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void PageSetup::SetPrintQuality(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x3fe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +CString PageSetup::GetPrintTitleColumns() +{ + CString result; + InvokeHelper(0x3ff, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPrintTitleColumns(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3ff, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PageSetup::GetPrintTitleRows() +{ + CString result; + InvokeHelper(0x400, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPrintTitleRows(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x400, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PageSetup::GetRightFooter() +{ + CString result; + InvokeHelper(0x401, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetRightFooter(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x401, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString PageSetup::GetRightHeader() +{ + CString result; + InvokeHelper(0x402, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void PageSetup::SetRightHeader(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x402, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +double PageSetup::GetRightMargin() +{ + double result; + InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PageSetup::SetRightMargin(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x3e8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double PageSetup::GetTopMargin() +{ + double result; + InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PageSetup::SetTopMargin(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x3e9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT PageSetup::GetZoom() +{ + VARIANT result; + InvokeHelper(0x297, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void PageSetup::SetZoom(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x297, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long PageSetup::GetPrintComments() +{ + long result; + InvokeHelper(0x5f4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPrintComments(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x5f4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long PageSetup::GetPrintErrors() +{ + long result; + InvokeHelper(0x865, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void PageSetup::SetPrintErrors(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x865, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH PageSetup::GetCenterHeaderPicture() +{ + LPDISPATCH result; + InvokeHelper(0x866, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PageSetup::GetCenterFooterPicture() +{ + LPDISPATCH result; + InvokeHelper(0x867, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PageSetup::GetLeftHeaderPicture() +{ + LPDISPATCH result; + InvokeHelper(0x868, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PageSetup::GetLeftFooterPicture() +{ + LPDISPATCH result; + InvokeHelper(0x869, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PageSetup::GetRightHeaderPicture() +{ + LPDISPATCH result; + InvokeHelper(0x86a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PageSetup::GetRightFooterPicture() +{ + LPDISPATCH result; + InvokeHelper(0x86b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Names properties + +///////////////////////////////////////////////////////////////////////////// +// Names operations + +LPDISPATCH Names::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Names::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Names::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Names::Add(const VARIANT& Name, const VARIANT& RefersTo, const VARIANT& Visible, const VARIANT& MacroType, const VARIANT& ShortcutKey, const VARIANT& Category, const VARIANT& NameLocal, const VARIANT& RefersToLocal, + const VARIANT& CategoryLocal, const VARIANT& RefersToR1C1, const VARIANT& RefersToR1C1Local) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Name, &RefersTo, &Visible, &MacroType, &ShortcutKey, &Category, &NameLocal, &RefersToLocal, &CategoryLocal, &RefersToR1C1, &RefersToR1C1Local); + return result; +} + +LPDISPATCH Names::Item(const VARIANT& Index, const VARIANT& IndexLocal, const VARIANT& RefersTo) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index, &IndexLocal, &RefersTo); + return result; +} + +LPDISPATCH Names::_Default(const VARIANT& Index, const VARIANT& IndexLocal, const VARIANT& RefersTo) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index, &IndexLocal, &RefersTo); + return result; +} + +long Names::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPUNKNOWN Names::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Name properties + +///////////////////////////////////////////////////////////////////////////// +// Name operations + +LPDISPATCH Name::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Name::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Name::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Name::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long Name::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString Name::GetCategory() +{ + CString result; + InvokeHelper(0x3a6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Name::SetCategory(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3a6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Name::GetCategoryLocal() +{ + CString result; + InvokeHelper(0x3a7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Name::SetCategoryLocal(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3a7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void Name::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long Name::GetMacroType() +{ + long result; + InvokeHelper(0x3a8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Name::SetMacroType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3a8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString Name::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Name::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Name::GetRefersTo() +{ + VARIANT result; + InvokeHelper(0x3aa, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Name::SetRefersTo(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3aa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString Name::GetShortcutKey() +{ + CString result; + InvokeHelper(0x255, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Name::SetShortcutKey(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x255, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Name::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Name::SetValue(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL Name::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Name::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Name::GetNameLocal() +{ + CString result; + InvokeHelper(0x3a9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Name::SetNameLocal(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3a9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Name::GetRefersToLocal() +{ + VARIANT result; + InvokeHelper(0x3ab, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Name::SetRefersToLocal(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3ab, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Name::GetRefersToR1C1() +{ + VARIANT result; + InvokeHelper(0x3ac, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Name::SetRefersToR1C1(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3ac, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Name::GetRefersToR1C1Local() +{ + VARIANT result; + InvokeHelper(0x3ad, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Name::SetRefersToR1C1Local(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3ad, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +LPDISPATCH Name::GetRefersToRange() +{ + LPDISPATCH result; + InvokeHelper(0x488, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartObject properties + +///////////////////////////////////////////////////////////////////////////// +// ChartObject operations + +LPDISPATCH ChartObject::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartObject::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObject::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObject::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ChartObject::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ChartObject::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ChartObject::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT ChartObject::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ChartObject::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObject::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartObject::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObject::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ChartObject::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartObject::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ChartObject::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double ChartObject::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartObject::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ChartObject::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObject::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString ChartObject::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ChartObject::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT ChartObject::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ChartObject::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL ChartObject::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObject::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ChartObject::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT ChartObject::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double ChartObject::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartObject::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH ChartObject::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartObject::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObject::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ChartObject::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartObject::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ChartObject::GetZOrder() +{ + long result; + InvokeHelper(0x26e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObject::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ChartObject::Activate() +{ + VARIANT result; + InvokeHelper(0x130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObject::GetChart() +{ + LPDISPATCH result; + InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartObject::GetProtectChartObject() +{ + BOOL result; + InvokeHelper(0x5f9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObject::SetProtectChartObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5f9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ChartObject::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObject::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH ChartObject::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObject::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartObject::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObject::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartObjects properties + +///////////////////////////////////////////////////////////////////////////// +// ChartObjects operations + +LPDISPATCH ChartObjects::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartObjects::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObjects::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ChartObjects::BringToFront() +{ + VARIANT result; + InvokeHelper(0x25a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ChartObjects::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ChartObjects::CopyPicture(long Appearance, long Format) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Appearance, Format); + return result; +} + +VARIANT ChartObjects::Cut() +{ + VARIANT result; + InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ChartObjects::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObjects::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartObjects::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ChartObjects::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double ChartObjects::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ChartObjects::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ChartObjects::GetPlacement() +{ + VARIANT result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetPlacement(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL ChartObjects::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ChartObjects::Select(const VARIANT& Replace) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Replace); + return result; +} + +VARIANT ChartObjects::SendToBack() +{ + VARIANT result; + InvokeHelper(0x25d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double ChartObjects::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL ChartObjects::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double ChartObjects::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH ChartObjects::GetShapeRange() +{ + LPDISPATCH result; + InvokeHelper(0x5f8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartObjects::GetRoundedCorners() +{ + BOOL result; + InvokeHelper(0x26b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetRoundedCorners(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH ChartObjects::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObjects::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartObjects::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartObjects::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH ChartObjects::Add(double Left, double Top, double Width, double Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R8 VTS_R8 VTS_R8 VTS_R8; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Left, Top, Width, Height); + return result; +} + +long ChartObjects::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartObjects::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ChartObjects::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Mailer properties + +///////////////////////////////////////////////////////////////////////////// +// Mailer operations + +LPDISPATCH Mailer::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Mailer::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Mailer::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Mailer::GetBCCRecipients() +{ + VARIANT result; + InvokeHelper(0x3d7, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Mailer::SetBCCRecipients(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3d7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Mailer::GetCCRecipients() +{ + VARIANT result; + InvokeHelper(0x3d6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Mailer::SetCCRecipients(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3d6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Mailer::GetEnclosures() +{ + VARIANT result; + InvokeHelper(0x3d8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Mailer::SetEnclosures(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3d8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL Mailer::GetReceived() +{ + BOOL result; + InvokeHelper(0x3da, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +DATE Mailer::GetSendDateTime() +{ + DATE result; + InvokeHelper(0x3db, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL); + return result; +} + +CString Mailer::GetSender() +{ + CString result; + InvokeHelper(0x3dc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString Mailer::GetSubject() +{ + CString result; + InvokeHelper(0x3b9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Mailer::SetSubject(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x3b9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Mailer::GetToRecipients() +{ + VARIANT result; + InvokeHelper(0x3d5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Mailer::SetToRecipients(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3d5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Mailer::GetWhichAddress() +{ + VARIANT result; + InvokeHelper(0x3ce, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Mailer::SetWhichAddress(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x3ce, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// CustomViews properties + +///////////////////////////////////////////////////////////////////////////// +// CustomViews operations + +LPDISPATCH CustomViews::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CustomViews::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CustomViews::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CustomViews::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CustomViews::Item(const VARIANT& ViewName) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &ViewName); + return result; +} + +LPDISPATCH CustomViews::Add(LPCTSTR ViewName, const VARIANT& PrintSettings, const VARIANT& RowColSettings) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + ViewName, &PrintSettings, &RowColSettings); + return result; +} + +LPDISPATCH CustomViews::Get_Default(const VARIANT& ViewName) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &ViewName); + return result; +} + +LPUNKNOWN CustomViews::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// CustomView properties + +///////////////////////////////////////////////////////////////////////////// +// CustomView operations + +LPDISPATCH CustomView::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CustomView::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CustomView::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString CustomView::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL CustomView::GetPrintSettings() +{ + BOOL result; + InvokeHelper(0x629, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL CustomView::GetRowColSettings() +{ + BOOL result; + InvokeHelper(0x62a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void CustomView::Show() +{ + InvokeHelper(0x1f0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void CustomView::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// FormatConditions properties + +///////////////////////////////////////////////////////////////////////////// +// FormatConditions operations + +LPDISPATCH FormatConditions::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long FormatConditions::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH FormatConditions::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long FormatConditions::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH FormatConditions::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH FormatConditions::Add(long Type, const VARIANT& Operator, const VARIANT& Formula1, const VARIANT& Formula2) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, &Operator, &Formula1, &Formula2); + return result; +} + +LPDISPATCH FormatConditions::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN FormatConditions::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void FormatConditions::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// FormatCondition properties + +///////////////////////////////////////////////////////////////////////////// +// FormatCondition operations + +LPDISPATCH FormatCondition::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long FormatCondition::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH FormatCondition::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void FormatCondition::Modify(long Type, const VARIANT& Operator, const VARIANT& Formula1, const VARIANT& Formula2) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x62d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Type, &Operator, &Formula1, &Formula2); +} + +long FormatCondition::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long FormatCondition::GetOperator() +{ + long result; + InvokeHelper(0x31d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString FormatCondition::GetFormula1() +{ + CString result; + InvokeHelper(0x62b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString FormatCondition::GetFormula2() +{ + CString result; + InvokeHelper(0x62c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH FormatCondition::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH FormatCondition::GetBorders() +{ + LPDISPATCH result; + InvokeHelper(0x1b3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH FormatCondition::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void FormatCondition::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// Comments properties + +///////////////////////////////////////////////////////////////////////////// +// Comments operations + +LPDISPATCH Comments::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Comments::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Comments::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Comments::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Comments::Item(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH Comments::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN Comments::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Comment properties + +///////////////////////////////////////////////////////////////////////////// +// Comment operations + +LPDISPATCH Comment::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Comment::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Comment::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Comment::GetAuthor() +{ + CString result; + InvokeHelper(0x23e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH Comment::GetShape() +{ + LPDISPATCH result; + InvokeHelper(0x62e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Comment::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Comment::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Comment::Text(const VARIANT& Text, const VARIANT& Start, const VARIANT& Overwrite) +{ + CString result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x8a, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + &Text, &Start, &Overwrite); + return result; +} + +void Comment::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Comment::Next() +{ + LPDISPATCH result; + InvokeHelper(0x1f6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Comment::Previous() +{ + LPDISPATCH result; + InvokeHelper(0x1f7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// RefreshEvents properties + +///////////////////////////////////////////////////////////////////////////// +// RefreshEvents operations + +void RefreshEvents::BeforeRefresh(BOOL* Cancel) +{ + static BYTE parms[] = + VTS_PBOOL; + InvokeHelper(0x63c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Cancel); +} + +void RefreshEvents::AfterRefresh(BOOL Success) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x63d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Success); +} + + +///////////////////////////////////////////////////////////////////////////// +// _QueryTable properties + +///////////////////////////////////////////////////////////////////////////// +// _QueryTable operations + +LPDISPATCH _QueryTable::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _QueryTable::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH _QueryTable::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString _QueryTable::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL _QueryTable::GetFieldNames() +{ + BOOL result; + InvokeHelper(0x630, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetFieldNames(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x630, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetRowNumbers() +{ + BOOL result; + InvokeHelper(0x631, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetRowNumbers(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x631, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetFillAdjacentFormulas() +{ + BOOL result; + InvokeHelper(0x632, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetFillAdjacentFormulas(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x632, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetRefreshOnFileOpen() +{ + BOOL result; + InvokeHelper(0x5c7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetRefreshOnFileOpen(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5c7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetRefreshing() +{ + BOOL result; + InvokeHelper(0x633, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _QueryTable::GetFetchedRowOverflow() +{ + BOOL result; + InvokeHelper(0x634, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL _QueryTable::GetBackgroundQuery() +{ + BOOL result; + InvokeHelper(0x593, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetBackgroundQuery(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x593, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _QueryTable::CancelRefresh() +{ + InvokeHelper(0x635, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long _QueryTable::GetRefreshStyle() +{ + long result; + InvokeHelper(0x636, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetRefreshStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x636, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _QueryTable::GetEnableRefresh() +{ + BOOL result; + InvokeHelper(0x5c5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetEnableRefresh(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5c5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetSavePassword() +{ + BOOL result; + InvokeHelper(0x5c9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetSavePassword(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5c9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH _QueryTable::GetDestination() +{ + LPDISPATCH result; + InvokeHelper(0x2a9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT _QueryTable::GetConnection() +{ + VARIANT result; + InvokeHelper(0x598, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetConnection(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x598, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString _QueryTable::GetPostText() +{ + CString result; + InvokeHelper(0x637, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetPostText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x637, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH _QueryTable::GetResultRange() +{ + LPDISPATCH result; + InvokeHelper(0x638, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _QueryTable::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL _QueryTable::Refresh(const VARIANT& BackgroundQuery) +{ + BOOL result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x589, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms, + &BackgroundQuery); + return result; +} + +LPDISPATCH _QueryTable::GetParameters() +{ + LPDISPATCH result; + InvokeHelper(0x639, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH _QueryTable::GetRecordset() +{ + LPDISPATCH result; + InvokeHelper(0x48d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetRefRecordset(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x48d, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL _QueryTable::GetSaveData() +{ + BOOL result; + InvokeHelper(0x2b4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetSaveData(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x2b4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetEnableEditing() +{ + BOOL result; + InvokeHelper(0x63b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetEnableEditing(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x63b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _QueryTable::GetTextFilePlatform() +{ + long result; + InvokeHelper(0x73f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFilePlatform(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x73f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _QueryTable::GetTextFileStartRow() +{ + long result; + InvokeHelper(0x740, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileStartRow(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x740, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _QueryTable::GetTextFileParseType() +{ + long result; + InvokeHelper(0x741, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileParseType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x741, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _QueryTable::GetTextFileTextQualifier() +{ + long result; + InvokeHelper(0x742, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileTextQualifier(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x742, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _QueryTable::GetTextFileConsecutiveDelimiter() +{ + BOOL result; + InvokeHelper(0x743, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileConsecutiveDelimiter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x743, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetTextFileTabDelimiter() +{ + BOOL result; + InvokeHelper(0x744, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileTabDelimiter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x744, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetTextFileSemicolonDelimiter() +{ + BOOL result; + InvokeHelper(0x745, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileSemicolonDelimiter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x745, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetTextFileCommaDelimiter() +{ + BOOL result; + InvokeHelper(0x746, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileCommaDelimiter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x746, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetTextFileSpaceDelimiter() +{ + BOOL result; + InvokeHelper(0x747, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileSpaceDelimiter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x747, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString _QueryTable::GetTextFileOtherDelimiter() +{ + CString result; + InvokeHelper(0x748, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileOtherDelimiter(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x748, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT _QueryTable::GetTextFileColumnDataTypes() +{ + VARIANT result; + InvokeHelper(0x749, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileColumnDataTypes(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x749, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT _QueryTable::GetTextFileFixedColumnWidths() +{ + VARIANT result; + InvokeHelper(0x74a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileFixedColumnWidths(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x74a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL _QueryTable::GetPreserveColumnInfo() +{ + BOOL result; + InvokeHelper(0x74b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetPreserveColumnInfo(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x74b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetPreserveFormatting() +{ + BOOL result; + InvokeHelper(0x5dc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetPreserveFormatting(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x5dc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetAdjustColumnWidth() +{ + BOOL result; + InvokeHelper(0x74c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetAdjustColumnWidth(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x74c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _QueryTable::GetCommandText() +{ + VARIANT result; + InvokeHelper(0x725, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetCommandText(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x725, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long _QueryTable::GetCommandType() +{ + long result; + InvokeHelper(0x726, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetCommandType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x726, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _QueryTable::GetTextFilePromptOnRefresh() +{ + BOOL result; + InvokeHelper(0x74d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFilePromptOnRefresh(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x74d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long _QueryTable::GetQueryType() +{ + long result; + InvokeHelper(0x727, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL _QueryTable::GetMaintainConnection() +{ + BOOL result; + InvokeHelper(0x728, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetMaintainConnection(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x728, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString _QueryTable::GetTextFileDecimalSeparator() +{ + CString result; + InvokeHelper(0x74e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileDecimalSeparator(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x74e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _QueryTable::GetTextFileThousandsSeparator() +{ + CString result; + InvokeHelper(0x74f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileThousandsSeparator(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x74f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long _QueryTable::GetRefreshPeriod() +{ + long result; + InvokeHelper(0x729, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetRefreshPeriod(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x729, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void _QueryTable::ResetTimer() +{ + InvokeHelper(0x72a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long _QueryTable::GetWebSelectionType() +{ + long result; + InvokeHelper(0x750, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetWebSelectionType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x750, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long _QueryTable::GetWebFormatting() +{ + long result; + InvokeHelper(0x751, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetWebFormatting(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x751, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString _QueryTable::GetWebTables() +{ + CString result; + InvokeHelper(0x752, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetWebTables(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x752, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL _QueryTable::GetWebPreFormattedTextToColumns() +{ + BOOL result; + InvokeHelper(0x753, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetWebPreFormattedTextToColumns(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x753, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetWebSingleBlockTextImport() +{ + BOOL result; + InvokeHelper(0x754, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetWebSingleBlockTextImport(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x754, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetWebDisableDateRecognition() +{ + BOOL result; + InvokeHelper(0x755, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetWebDisableDateRecognition(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x755, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetWebConsecutiveDelimitersAsOne() +{ + BOOL result; + InvokeHelper(0x756, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetWebConsecutiveDelimitersAsOne(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x756, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL _QueryTable::GetWebDisableRedirections() +{ + BOOL result; + InvokeHelper(0x872, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetWebDisableRedirections(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x872, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT _QueryTable::GetEditWebPage() +{ + VARIANT result; + InvokeHelper(0x873, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetEditWebPage(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x873, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +CString _QueryTable::GetSourceConnectionFile() +{ + CString result; + InvokeHelper(0x81f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetSourceConnectionFile(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x81f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString _QueryTable::GetSourceDataFile() +{ + CString result; + InvokeHelper(0x820, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetSourceDataFile(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x820, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long _QueryTable::GetRobustConnect() +{ + long result; + InvokeHelper(0x821, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetRobustConnect(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x821, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL _QueryTable::GetTextFileTrailingMinusNumbers() +{ + BOOL result; + InvokeHelper(0x874, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileTrailingMinusNumbers(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x874, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void _QueryTable::SaveAsODC(LPCTSTR ODCFileName, const VARIANT& Description, const VARIANT& Keywords) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x822, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ODCFileName, &Description, &Keywords); +} + +LPDISPATCH _QueryTable::GetListObject() +{ + LPDISPATCH result; + InvokeHelper(0x8d1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long _QueryTable::GetTextFileVisualLayout() +{ + long result; + InvokeHelper(0x8c5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void _QueryTable::SetTextFileVisualLayout(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8c5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// QueryTables properties + +///////////////////////////////////////////////////////////////////////////// +// QueryTables operations + +LPDISPATCH QueryTables::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long QueryTables::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH QueryTables::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long QueryTables::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH QueryTables::Add(const VARIANT& Connection, LPDISPATCH Destination, const VARIANT& Sql) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_DISPATCH VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Connection, Destination, &Sql); + return result; +} + +LPDISPATCH QueryTables::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH QueryTables::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN QueryTables::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Parameter properties + +///////////////////////////////////////////////////////////////////////////// +// Parameter operations + +LPDISPATCH Parameter::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Parameter::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Parameter::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Parameter::GetDataType() +{ + long result; + InvokeHelper(0x2d2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Parameter::SetDataType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x2d2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Parameter::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString Parameter::GetPromptString() +{ + CString result; + InvokeHelper(0x63f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT Parameter::GetValue() +{ + VARIANT result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Parameter::GetSourceRange() +{ + LPDISPATCH result; + InvokeHelper(0x640, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Parameter::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Parameter::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void Parameter::SetParam(long Type, const VARIANT& Value) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x641, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Type, &Value); +} + +BOOL Parameter::GetRefreshOnChange() +{ + BOOL result; + InvokeHelper(0x757, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Parameter::SetRefreshOnChange(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x757, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Parameters properties + +///////////////////////////////////////////////////////////////////////////// +// Parameters operations + +LPDISPATCH Parameters::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Parameters::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Parameters::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Parameters::Add(LPCTSTR Name, const VARIANT& iDataType) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, &iDataType); + return result; +} + +long Parameters::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Parameters::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH Parameters::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Parameters::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPUNKNOWN Parameters::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ODBCError properties + +///////////////////////////////////////////////////////////////////////////// +// ODBCError operations + +LPDISPATCH ODBCError::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ODBCError::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ODBCError::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString ODBCError::GetSqlState() +{ + CString result; + InvokeHelper(0x643, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString ODBCError::GetErrorString() +{ + CString result; + InvokeHelper(0x5d2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ODBCErrors properties + +///////////////////////////////////////////////////////////////////////////// +// ODBCErrors operations + +LPDISPATCH ODBCErrors::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ODBCErrors::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ODBCErrors::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ODBCErrors::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ODBCErrors::Item(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH ODBCErrors::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN ODBCErrors::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Validation properties + +///////////////////////////////////////////////////////////////////////////// +// Validation operations + +LPDISPATCH Validation::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Validation::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Validation::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Validation::Add(long Type, const VARIANT& AlertStyle, const VARIANT& Operator, const VARIANT& Formula1, const VARIANT& Formula2) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Type, &AlertStyle, &Operator, &Formula1, &Formula2); +} + +long Validation::GetAlertStyle() +{ + long result; + InvokeHelper(0x645, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL Validation::GetIgnoreBlank() +{ + BOOL result; + InvokeHelper(0x646, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Validation::SetIgnoreBlank(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x646, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Validation::GetIMEMode() +{ + long result; + InvokeHelper(0x647, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Validation::SetIMEMode(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x647, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Validation::GetInCellDropdown() +{ + BOOL result; + InvokeHelper(0x648, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Validation::SetInCellDropdown(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x648, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void Validation::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString Validation::GetErrorMessage() +{ + CString result; + InvokeHelper(0x649, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Validation::SetErrorMessage(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x649, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Validation::GetErrorTitle() +{ + CString result; + InvokeHelper(0x64a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Validation::SetErrorTitle(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x64a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Validation::GetInputMessage() +{ + CString result; + InvokeHelper(0x64b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Validation::SetInputMessage(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x64b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Validation::GetInputTitle() +{ + CString result; + InvokeHelper(0x64c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Validation::SetInputTitle(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x64c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Validation::GetFormula1() +{ + CString result; + InvokeHelper(0x62b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString Validation::GetFormula2() +{ + CString result; + InvokeHelper(0x62c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Validation::Modify(const VARIANT& Type, const VARIANT& AlertStyle, const VARIANT& Operator, const VARIANT& Formula1, const VARIANT& Formula2) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x62d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Type, &AlertStyle, &Operator, &Formula1, &Formula2); +} + +long Validation::GetOperator() +{ + long result; + InvokeHelper(0x31d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL Validation::GetShowError() +{ + BOOL result; + InvokeHelper(0x64d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Validation::SetShowError(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x64d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Validation::GetShowInput() +{ + BOOL result; + InvokeHelper(0x64e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Validation::SetShowInput(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x64e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Validation::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL Validation::GetValue() +{ + BOOL result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Hyperlinks properties + +///////////////////////////////////////////////////////////////////////////// +// Hyperlinks operations + +LPDISPATCH Hyperlinks::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Hyperlinks::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Hyperlinks::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Hyperlinks::Add(LPDISPATCH Anchor, LPCTSTR Address, const VARIANT& SubAddress, const VARIANT& ScreenTip, const VARIANT& TextToDisplay) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_DISPATCH VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Anchor, Address, &SubAddress, &ScreenTip, &TextToDisplay); + return result; +} + +long Hyperlinks::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Hyperlinks::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH Hyperlinks::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Hyperlinks::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void Hyperlinks::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// Hyperlink properties + +///////////////////////////////////////////////////////////////////////////// +// Hyperlink operations + +LPDISPATCH Hyperlink::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Hyperlink::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Hyperlink::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Hyperlink::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH Hyperlink::GetRange() +{ + LPDISPATCH result; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Hyperlink::GetShape() +{ + LPDISPATCH result; + InvokeHelper(0x62e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Hyperlink::GetSubAddress() +{ + CString result; + InvokeHelper(0x5bf, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Hyperlink::SetSubAddress(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x5bf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Hyperlink::GetAddress() +{ + CString result; + InvokeHelper(0xec, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Hyperlink::SetAddress(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xec, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long Hyperlink::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Hyperlink::AddToFavorites() +{ + InvokeHelper(0x5c4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Hyperlink::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Hyperlink::Follow(const VARIANT& NewWindow, const VARIANT& AddHistory, const VARIANT& ExtraInfo, const VARIANT& Method, const VARIANT& HeaderInfo) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x650, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &NewWindow, &AddHistory, &ExtraInfo, &Method, &HeaderInfo); +} + +CString Hyperlink::GetEmailSubject() +{ + CString result; + InvokeHelper(0x75b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Hyperlink::SetEmailSubject(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x75b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Hyperlink::GetScreenTip() +{ + CString result; + InvokeHelper(0x759, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Hyperlink::SetScreenTip(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x759, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Hyperlink::GetTextToDisplay() +{ + CString result; + InvokeHelper(0x75a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Hyperlink::SetTextToDisplay(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x75a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +void Hyperlink::CreateNewDocument(LPCTSTR Filename, BOOL EditNow, BOOL Overwrite) +{ + static BYTE parms[] = + VTS_BSTR VTS_BOOL VTS_BOOL; + InvokeHelper(0x75c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Filename, EditNow, Overwrite); +} + + +///////////////////////////////////////////////////////////////////////////// +// AutoFilter properties + +///////////////////////////////////////////////////////////////////////////// +// AutoFilter operations + +LPDISPATCH AutoFilter::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long AutoFilter::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH AutoFilter::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH AutoFilter::GetRange() +{ + LPDISPATCH result; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH AutoFilter::GetFilters() +{ + LPDISPATCH result; + InvokeHelper(0x651, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Filters properties + +///////////////////////////////////////////////////////////////////////////// +// Filters operations + +LPDISPATCH Filters::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Filters::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Filters::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Filters::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Filters::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH Filters::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN Filters::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Filter properties + +///////////////////////////////////////////////////////////////////////////// +// Filter operations + +LPDISPATCH Filter::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Filter::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Filter::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Filter::GetOn() +{ + BOOL result; + InvokeHelper(0x652, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +VARIANT Filter::GetCriteria1() +{ + VARIANT result; + InvokeHelper(0x31c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Filter::GetOperator() +{ + long result; + InvokeHelper(0x31d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Filter::GetCriteria2() +{ + VARIANT result; + InvokeHelper(0x31e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// AutoCorrect properties + +///////////////////////////////////////////////////////////////////////////// +// AutoCorrect operations + +LPDISPATCH AutoCorrect::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long AutoCorrect::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH AutoCorrect::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT AutoCorrect::AddReplacement(LPCTSTR What, LPCTSTR Replacement) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR; + InvokeHelper(0x47a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + What, Replacement); + return result; +} + +BOOL AutoCorrect::GetCapitalizeNamesOfDays() +{ + BOOL result; + InvokeHelper(0x47e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AutoCorrect::SetCapitalizeNamesOfDays(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x47e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT AutoCorrect::DeleteReplacement(LPCTSTR What) +{ + VARIANT result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x47b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + What); + return result; +} + +VARIANT AutoCorrect::GetReplacementList(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x47f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +void AutoCorrect::SetReplacementList(const VARIANT& Index, const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x47f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &Index, &newValue); +} + +BOOL AutoCorrect::GetReplaceText() +{ + BOOL result; + InvokeHelper(0x47c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AutoCorrect::SetReplaceText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x47c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL AutoCorrect::GetTwoInitialCapitals() +{ + BOOL result; + InvokeHelper(0x47d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AutoCorrect::SetTwoInitialCapitals(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x47d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL AutoCorrect::GetCorrectSentenceCap() +{ + BOOL result; + InvokeHelper(0x653, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AutoCorrect::SetCorrectSentenceCap(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x653, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL AutoCorrect::GetCorrectCapsLock() +{ + BOOL result; + InvokeHelper(0x654, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AutoCorrect::SetCorrectCapsLock(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x654, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL AutoCorrect::GetDisplayAutoCorrectOptions() +{ + BOOL result; + InvokeHelper(0x786, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AutoCorrect::SetDisplayAutoCorrectOptions(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x786, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL AutoCorrect::GetAutoExpandListRange() +{ + BOOL result; + InvokeHelper(0x8f6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AutoCorrect::SetAutoExpandListRange(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8f6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Border properties + +///////////////////////////////////////////////////////////////////////////// +// Border operations + +LPDISPATCH Border::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Border::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Border::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Border::GetColor() +{ + VARIANT result; + InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Border::SetColor(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Border::GetColorIndex() +{ + VARIANT result; + InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Border::SetColorIndex(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Border::GetLineStyle() +{ + VARIANT result; + InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Border::SetLineStyle(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Border::GetWeight() +{ + VARIANT result; + InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Border::SetWeight(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Interior properties + +///////////////////////////////////////////////////////////////////////////// +// Interior operations + +LPDISPATCH Interior::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Interior::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Interior::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Interior::GetColor() +{ + VARIANT result; + InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Interior::SetColor(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Interior::GetColorIndex() +{ + VARIANT result; + InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Interior::SetColorIndex(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Interior::GetInvertIfNegative() +{ + VARIANT result; + InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Interior::SetInvertIfNegative(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Interior::GetPattern() +{ + VARIANT result; + InvokeHelper(0x5f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Interior::SetPattern(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Interior::GetPatternColor() +{ + VARIANT result; + InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Interior::SetPatternColor(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Interior::GetPatternColorIndex() +{ + VARIANT result; + InvokeHelper(0x62, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Interior::SetPatternColorIndex(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x62, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartFillFormat properties + +///////////////////////////////////////////////////////////////////////////// +// ChartFillFormat operations + +LPDISPATCH ChartFillFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartFillFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ChartFillFormat::OneColorGradient(long Style, long Variant, float Degree) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_R4; + InvokeHelper(0x655, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Style, Variant, Degree); +} + +void ChartFillFormat::TwoColorGradient(long Style, long Variant) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x658, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Style, Variant); +} + +void ChartFillFormat::PresetTextured(long PresetTexture) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x659, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + PresetTexture); +} + +void ChartFillFormat::Solid() +{ + InvokeHelper(0x65b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ChartFillFormat::Patterned(long Pattern) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x65c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Pattern); +} + +void ChartFillFormat::UserPicture(const VARIANT& PictureFile, const VARIANT& PictureFormat, const VARIANT& PictureStackUnit, const VARIANT& PicturePlacement) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x65d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &PictureFile, &PictureFormat, &PictureStackUnit, &PicturePlacement); +} + +void ChartFillFormat::UserTextured(LPCTSTR TextureFile) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x662, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + TextureFile); +} + +void ChartFillFormat::PresetGradient(long Style, long Variant, long PresetGradientType) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x664, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Style, Variant, PresetGradientType); +} + +LPDISPATCH ChartFillFormat::GetBackColor() +{ + LPDISPATCH result; + InvokeHelper(0x666, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartFillFormat::GetForeColor() +{ + LPDISPATCH result; + InvokeHelper(0x667, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetGradientColorType() +{ + long result; + InvokeHelper(0x668, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float ChartFillFormat::GetGradientDegree() +{ + float result; + InvokeHelper(0x669, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetGradientStyle() +{ + long result; + InvokeHelper(0x66a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetGradientVariant() +{ + long result; + InvokeHelper(0x66b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetPattern() +{ + long result; + InvokeHelper(0x5f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetPresetGradientType() +{ + long result; + InvokeHelper(0x665, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetPresetTexture() +{ + long result; + InvokeHelper(0x65a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString ChartFillFormat::GetTextureName() +{ + CString result; + InvokeHelper(0x66c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetTextureType() +{ + long result; + InvokeHelper(0x66d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartFillFormat::GetVisible() +{ + long result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartFillFormat::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartColorFormat properties + +///////////////////////////////////////////////////////////////////////////// +// ChartColorFormat operations + +LPDISPATCH ChartColorFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartColorFormat::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartColorFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartColorFormat::GetSchemeColor() +{ + long result; + InvokeHelper(0x66e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartColorFormat::SetSchemeColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x66e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ChartColorFormat::GetRgb() +{ + long result; + InvokeHelper(0x41f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartColorFormat::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartColorFormat::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Axis properties + +///////////////////////////////////////////////////////////////////////////// +// Axis operations + +LPDISPATCH Axis::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Axis::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Axis::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Axis::GetAxisBetweenCategories() +{ + BOOL result; + InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetAxisBetweenCategories(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x2d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Axis::GetAxisGroup() +{ + long result; + InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Axis::GetAxisTitle() +{ + LPDISPATCH result; + InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Axis::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Axis::GetCategoryNames() +{ + VARIANT result; + InvokeHelper(0x9c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Axis::SetCategoryNames(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x9c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Axis::GetCrosses() +{ + long result; + InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetCrosses(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x2a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +double Axis::GetCrossesAt() +{ + double result; + InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Axis::SetCrossesAt(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x2b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT Axis::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL Axis::GetHasMajorGridlines() +{ + BOOL result; + InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetHasMajorGridlines(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Axis::GetHasMinorGridlines() +{ + BOOL result; + InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetHasMinorGridlines(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Axis::GetHasTitle() +{ + BOOL result; + InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetHasTitle(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x36, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Axis::GetMajorGridlines() +{ + LPDISPATCH result; + InvokeHelper(0x59, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Axis::GetMajorTickMark() +{ + long result; + InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetMajorTickMark(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +double Axis::GetMajorUnit() +{ + double result; + InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Axis::SetMajorUnit(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Axis::GetMajorUnitIsAuto() +{ + BOOL result; + InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetMajorUnitIsAuto(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Axis::GetMaximumScale() +{ + double result; + InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Axis::SetMaximumScale(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Axis::GetMaximumScaleIsAuto() +{ + BOOL result; + InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetMaximumScaleIsAuto(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double Axis::GetMinimumScale() +{ + double result; + InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Axis::SetMinimumScale(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Axis::GetMinimumScaleIsAuto() +{ + BOOL result; + InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetMinimumScaleIsAuto(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Axis::GetMinorGridlines() +{ + LPDISPATCH result; + InvokeHelper(0x5a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Axis::GetMinorTickMark() +{ + long result; + InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetMinorTickMark(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +double Axis::GetMinorUnit() +{ + double result; + InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Axis::SetMinorUnit(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x27, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Axis::GetMinorUnitIsAuto() +{ + BOOL result; + InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetMinorUnitIsAuto(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Axis::GetReversePlotOrder() +{ + BOOL result; + InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetReversePlotOrder(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x2c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Axis::GetScaleType() +{ + long result; + InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetScaleType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x29, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Axis::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Axis::GetTickLabelPosition() +{ + long result; + InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetTickLabelPosition(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Axis::GetTickLabels() +{ + LPDISPATCH result; + InvokeHelper(0x5b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Axis::GetTickLabelSpacing() +{ + long result; + InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetTickLabelSpacing(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Axis::GetTickMarkSpacing() +{ + long result; + InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetTickMarkSpacing(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Axis::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Axis::GetBaseUnit() +{ + long result; + InvokeHelper(0x66f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetBaseUnit(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x66f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Axis::GetBaseUnitIsAuto() +{ + BOOL result; + InvokeHelper(0x670, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetBaseUnitIsAuto(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x670, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Axis::GetMajorUnitScale() +{ + long result; + InvokeHelper(0x671, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetMajorUnitScale(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x671, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Axis::GetMinorUnitScale() +{ + long result; + InvokeHelper(0x672, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetMinorUnitScale(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x672, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Axis::GetCategoryType() +{ + long result; + InvokeHelper(0x673, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetCategoryType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x673, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +double Axis::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double Axis::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double Axis::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double Axis::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +long Axis::GetDisplayUnit() +{ + long result; + InvokeHelper(0x75e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Axis::SetDisplayUnit(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x75e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +double Axis::GetDisplayUnitCustom() +{ + double result; + InvokeHelper(0x75f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Axis::SetDisplayUnitCustom(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x75f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Axis::GetHasDisplayUnitLabel() +{ + BOOL result; + InvokeHelper(0x760, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Axis::SetHasDisplayUnitLabel(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x760, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Axis::GetDisplayUnitLabel() +{ + LPDISPATCH result; + InvokeHelper(0x761, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartTitle properties + +///////////////////////////////////////////////////////////////////////////// +// ChartTitle operations + +LPDISPATCH ChartTitle::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartTitle::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartTitle::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString ChartTitle::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT ChartTitle::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartTitle::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ChartTitle::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartTitle::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartTitle::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString ChartTitle::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH ChartTitle::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +LPDISPATCH ChartTitle::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ChartTitle::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +double ChartTitle::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT ChartTitle::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL ChartTitle::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString ChartTitle::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +double ChartTitle::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT ChartTitle::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long ChartTitle::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT ChartTitle::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ChartTitle::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// AxisTitle properties + +///////////////////////////////////////////////////////////////////////////// +// AxisTitle operations + +LPDISPATCH AxisTitle::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long AxisTitle::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH AxisTitle::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString AxisTitle::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT AxisTitle::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH AxisTitle::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT AxisTitle::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH AxisTitle::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH AxisTitle::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString AxisTitle::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH AxisTitle::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +LPDISPATCH AxisTitle::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT AxisTitle::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +double AxisTitle::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT AxisTitle::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL AxisTitle::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString AxisTitle::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +double AxisTitle::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT AxisTitle::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long AxisTitle::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT AxisTitle::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void AxisTitle::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartGroup properties + +///////////////////////////////////////////////////////////////////////////// +// ChartGroup operations + +LPDISPATCH ChartGroup::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartGroup::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartGroup::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartGroup::GetAxisGroup() +{ + long result; + InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetAxisGroup(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x2f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ChartGroup::GetDoughnutHoleSize() +{ + long result; + InvokeHelper(0x466, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetDoughnutHoleSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x466, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH ChartGroup::GetDownBars() +{ + LPDISPATCH result; + InvokeHelper(0x8d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartGroup::GetDropLines() +{ + LPDISPATCH result; + InvokeHelper(0x8e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartGroup::GetFirstSliceAngle() +{ + long result; + InvokeHelper(0x3f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetFirstSliceAngle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ChartGroup::GetGapWidth() +{ + long result; + InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetGapWidth(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x33, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ChartGroup::GetHasDropLines() +{ + BOOL result; + InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetHasDropLines(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ChartGroup::GetHasHiLoLines() +{ + BOOL result; + InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetHasHiLoLines(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ChartGroup::GetHasRadarAxisLabels() +{ + BOOL result; + InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetHasRadarAxisLabels(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x40, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ChartGroup::GetHasSeriesLines() +{ + BOOL result; + InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetHasSeriesLines(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x41, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ChartGroup::GetHasUpDownBars() +{ + BOOL result; + InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetHasUpDownBars(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH ChartGroup::GetHiLoLines() +{ + LPDISPATCH result; + InvokeHelper(0x8f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartGroup::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ChartGroup::GetOverlap() +{ + long result; + InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetOverlap(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x38, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH ChartGroup::GetRadarAxisLabels() +{ + LPDISPATCH result; + InvokeHelper(0x90, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartGroup::SeriesCollection(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x44, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH ChartGroup::GetSeriesLines() +{ + LPDISPATCH result; + InvokeHelper(0x91, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartGroup::GetUpBars() +{ + LPDISPATCH result; + InvokeHelper(0x8c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartGroup::GetVaryByCategories() +{ + BOOL result; + InvokeHelper(0x3c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetVaryByCategories(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x3c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ChartGroup::GetSizeRepresents() +{ + long result; + InvokeHelper(0x674, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetSizeRepresents(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x674, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ChartGroup::GetBubbleScale() +{ + long result; + InvokeHelper(0x675, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetBubbleScale(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x675, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ChartGroup::GetShowNegativeBubbles() +{ + BOOL result; + InvokeHelper(0x676, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetShowNegativeBubbles(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x676, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ChartGroup::GetSplitType() +{ + long result; + InvokeHelper(0x677, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetSplitType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x677, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT ChartGroup::GetSplitValue() +{ + VARIANT result; + InvokeHelper(0x678, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetSplitValue(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x678, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long ChartGroup::GetSecondPlotSize() +{ + long result; + InvokeHelper(0x679, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetSecondPlotSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x679, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ChartGroup::GetHas3DShading() +{ + BOOL result; + InvokeHelper(0x67a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartGroup::SetHas3DShading(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartGroups properties + +///////////////////////////////////////////////////////////////////////////// +// ChartGroups operations + +LPDISPATCH ChartGroups::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartGroups::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartGroups::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartGroups::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartGroups::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ChartGroups::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Axes properties + +///////////////////////////////////////////////////////////////////////////// +// Axes operations + +LPDISPATCH Axes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Axes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Axes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Axes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Axes::Item(long Type, long AxisGroup) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, AxisGroup); + return result; +} + +LPUNKNOWN Axes::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Points properties + +///////////////////////////////////////////////////////////////////////////// +// Points operations + +LPDISPATCH Points::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Points::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Points::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Points::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Points::Item(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN Points::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Point properties + +///////////////////////////////////////////////////////////////////////////// +// Point operations + +LPDISPATCH Point::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Point::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Point::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Point::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Point::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Point::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Point::GetDataLabel() +{ + LPDISPATCH result; + InvokeHelper(0x9e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Point::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Point::GetExplosion() +{ + long result; + InvokeHelper(0xb6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetExplosion(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xb6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Point::GetHasDataLabel() +{ + BOOL result; + InvokeHelper(0x4d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Point::SetHasDataLabel(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Point::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Point::GetInvertIfNegative() +{ + BOOL result; + InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Point::SetInvertIfNegative(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Point::GetMarkerBackgroundColor() +{ + long result; + InvokeHelper(0x49, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetMarkerBackgroundColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x49, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Point::GetMarkerBackgroundColorIndex() +{ + long result; + InvokeHelper(0x4a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetMarkerBackgroundColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Point::GetMarkerForegroundColor() +{ + long result; + InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetMarkerForegroundColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Point::GetMarkerForegroundColorIndex() +{ + long result; + InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetMarkerForegroundColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Point::GetMarkerSize() +{ + long result; + InvokeHelper(0xe7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetMarkerSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xe7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Point::GetMarkerStyle() +{ + long result; + InvokeHelper(0x48, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetMarkerStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x48, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Point::Paste() +{ + VARIANT result; + InvokeHelper(0xd3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Point::GetPictureType() +{ + long result; + InvokeHelper(0xa1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetPictureType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xa1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Point::GetPictureUnit() +{ + long result; + InvokeHelper(0xa2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Point::SetPictureUnit(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xa2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Point::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL Point::GetApplyPictToSides() +{ + BOOL result; + InvokeHelper(0x67b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Point::SetApplyPictToSides(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Point::GetApplyPictToFront() +{ + BOOL result; + InvokeHelper(0x67c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Point::SetApplyPictToFront(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Point::GetApplyPictToEnd() +{ + BOOL result; + InvokeHelper(0x67d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Point::SetApplyPictToEnd(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Point::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Point::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Point::GetSecondaryPlot() +{ + BOOL result; + InvokeHelper(0x67e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Point::SetSecondaryPlot(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Point::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Point::ApplyDataLabels(long Type, const VARIANT& LegendKey, const VARIANT& AutoText, const VARIANT& HasLeaderLines, const VARIANT& ShowSeriesName, const VARIANT& ShowCategoryName, const VARIANT& ShowValue, const VARIANT& ShowPercentage, + const VARIANT& ShowBubbleSize, const VARIANT& Separator) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x782, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Type, &LegendKey, &AutoText, &HasLeaderLines, &ShowSeriesName, &ShowCategoryName, &ShowValue, &ShowPercentage, &ShowBubbleSize, &Separator); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Series properties + +///////////////////////////////////////////////////////////////////////////// +// Series operations + +LPDISPATCH Series::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Series::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Series::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Series::GetAxisGroup() +{ + long result; + InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetAxisGroup(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x2f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Series::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Series::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Series::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Series::DataLabels(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x9d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +VARIANT Series::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT Series::ErrorBar(long Direction, long Include, long Type, const VARIANT& Amount, const VARIANT& MinusValues) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x98, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Direction, Include, Type, &Amount, &MinusValues); + return result; +} + +LPDISPATCH Series::GetErrorBars() +{ + LPDISPATCH result; + InvokeHelper(0x9f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Series::GetExplosion() +{ + long result; + InvokeHelper(0xb6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetExplosion(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xb6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString Series::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Series::SetFormula(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Series::GetFormulaLocal() +{ + CString result; + InvokeHelper(0x107, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Series::SetFormulaLocal(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x107, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Series::GetFormulaR1C1() +{ + CString result; + InvokeHelper(0x108, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Series::SetFormulaR1C1(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x108, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +CString Series::GetFormulaR1C1Local() +{ + CString result; + InvokeHelper(0x109, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Series::SetFormulaR1C1Local(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x109, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL Series::GetHasDataLabels() +{ + BOOL result; + InvokeHelper(0x4e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetHasDataLabels(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x4e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Series::GetHasErrorBars() +{ + BOOL result; + InvokeHelper(0xa0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetHasErrorBars(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xa0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Series::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Series::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Series::GetInvertIfNegative() +{ + BOOL result; + InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetInvertIfNegative(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Series::GetMarkerBackgroundColor() +{ + long result; + InvokeHelper(0x49, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetMarkerBackgroundColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x49, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Series::GetMarkerBackgroundColorIndex() +{ + long result; + InvokeHelper(0x4a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetMarkerBackgroundColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Series::GetMarkerForegroundColor() +{ + long result; + InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetMarkerForegroundColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Series::GetMarkerForegroundColorIndex() +{ + long result; + InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetMarkerForegroundColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Series::GetMarkerSize() +{ + long result; + InvokeHelper(0xe7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetMarkerSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xe7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Series::GetMarkerStyle() +{ + long result; + InvokeHelper(0x48, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetMarkerStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x48, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString Series::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Series::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT Series::Paste() +{ + VARIANT result; + InvokeHelper(0xd3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Series::GetPictureType() +{ + long result; + InvokeHelper(0xa1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetPictureType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xa1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Series::GetPictureUnit() +{ + long result; + InvokeHelper(0xa2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetPictureUnit(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xa2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Series::GetPlotOrder() +{ + long result; + InvokeHelper(0xe4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetPlotOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xe4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Series::Points(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x46, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +VARIANT Series::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL Series::GetSmooth() +{ + BOOL result; + InvokeHelper(0xa3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetSmooth(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xa3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Series::Trendlines(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x9a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long Series::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Series::GetChartType() +{ + long result; + InvokeHelper(0x578, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetChartType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x578, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void Series::ApplyCustomType(long ChartType) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x579, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ChartType); +} + +VARIANT Series::GetValues() +{ + VARIANT result; + InvokeHelper(0xa4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Series::SetValues(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xa4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Series::GetXValues() +{ + VARIANT result; + InvokeHelper(0x457, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Series::SetXValues(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x457, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT Series::GetBubbleSizes() +{ + VARIANT result; + InvokeHelper(0x680, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Series::SetBubbleSizes(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x680, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Series::GetBarShape() +{ + long result; + InvokeHelper(0x57b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Series::SetBarShape(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x57b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Series::GetApplyPictToSides() +{ + BOOL result; + InvokeHelper(0x67b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetApplyPictToSides(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Series::GetApplyPictToFront() +{ + BOOL result; + InvokeHelper(0x67c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetApplyPictToFront(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Series::GetApplyPictToEnd() +{ + BOOL result; + InvokeHelper(0x67d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetApplyPictToEnd(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Series::GetHas3DEffect() +{ + BOOL result; + InvokeHelper(0x681, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetHas3DEffect(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x681, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Series::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Series::GetHasLeaderLines() +{ + BOOL result; + InvokeHelper(0x572, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Series::SetHasLeaderLines(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x572, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Series::GetLeaderLines() +{ + LPDISPATCH result; + InvokeHelper(0x682, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Series::ApplyDataLabels(long Type, const VARIANT& LegendKey, const VARIANT& AutoText, const VARIANT& HasLeaderLines, const VARIANT& ShowSeriesName, const VARIANT& ShowCategoryName, const VARIANT& ShowValue, const VARIANT& ShowPercentage, + const VARIANT& ShowBubbleSize, const VARIANT& Separator) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x782, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Type, &LegendKey, &AutoText, &HasLeaderLines, &ShowSeriesName, &ShowCategoryName, &ShowValue, &ShowPercentage, &ShowBubbleSize, &Separator); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// SeriesCollection properties + +///////////////////////////////////////////////////////////////////////////// +// SeriesCollection operations + +LPDISPATCH SeriesCollection::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SeriesCollection::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SeriesCollection::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH SeriesCollection::Add(const VARIANT& Source, long Rowcol, const VARIANT& SeriesLabels, const VARIANT& CategoryLabels, const VARIANT& Replace) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Source, Rowcol, &SeriesLabels, &CategoryLabels, &Replace); + return result; +} + +long SeriesCollection::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT SeriesCollection::Extend(const VARIANT& Source, const VARIANT& Rowcol, const VARIANT& CategoryLabels) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xe3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Source, &Rowcol, &CategoryLabels); + return result; +} + +LPDISPATCH SeriesCollection::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN SeriesCollection::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +VARIANT SeriesCollection::Paste(long Rowcol, const VARIANT& SeriesLabels, const VARIANT& CategoryLabels, const VARIANT& Replace, const VARIANT& NewSeries) +{ + VARIANT result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xd3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + Rowcol, &SeriesLabels, &CategoryLabels, &Replace, &NewSeries); + return result; +} + +LPDISPATCH SeriesCollection::NewSeries() +{ + LPDISPATCH result; + InvokeHelper(0x45d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DataLabel properties + +///////////////////////////////////////////////////////////////////////////// +// DataLabel operations + +LPDISPATCH DataLabel::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DataLabel::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabel::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DataLabel::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT DataLabel::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabel::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DataLabel::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabel::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabel::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DataLabel::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DataLabel::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DataLabel::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +LPDISPATCH DataLabel::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DataLabel::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabel::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +double DataLabel::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DataLabel::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT DataLabel::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabel::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DataLabel::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString DataLabel::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DataLabel::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +double DataLabel::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DataLabel::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT DataLabel::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabel::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long DataLabel::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DataLabel::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT DataLabel::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabel::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DataLabel::GetAutoText() +{ + BOOL result; + InvokeHelper(0x87, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetAutoText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x87, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString DataLabel::GetNumberFormat() +{ + CString result; + InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DataLabel::SetNumberFormat(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL DataLabel::GetNumberFormatLinked() +{ + BOOL result; + InvokeHelper(0xc2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetNumberFormatLinked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xc2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DataLabel::GetNumberFormatLocal() +{ + VARIANT result; + InvokeHelper(0x449, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabel::SetNumberFormatLocal(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x449, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DataLabel::GetShowLegendKey() +{ + BOOL result; + InvokeHelper(0xab, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetShowLegendKey(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xab, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DataLabel::GetType() +{ + VARIANT result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabel::SetType(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long DataLabel::GetPosition() +{ + long result; + InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DataLabel::SetPosition(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL DataLabel::GetShowSeriesName() +{ + BOOL result; + InvokeHelper(0x7e6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetShowSeriesName(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataLabel::GetShowCategoryName() +{ + BOOL result; + InvokeHelper(0x7e7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetShowCategoryName(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataLabel::GetShowValue() +{ + BOOL result; + InvokeHelper(0x7e8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetShowValue(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataLabel::GetShowPercentage() +{ + BOOL result; + InvokeHelper(0x7e9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetShowPercentage(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataLabel::GetShowBubbleSize() +{ + BOOL result; + InvokeHelper(0x7ea, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabel::SetShowBubbleSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7ea, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DataLabel::GetSeparator() +{ + VARIANT result; + InvokeHelper(0x7eb, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabel::SetSeparator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x7eb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// DataLabels properties + +///////////////////////////////////////////////////////////////////////////// +// DataLabels operations + +LPDISPATCH DataLabels::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DataLabels::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabels::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DataLabels::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT DataLabels::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabels::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DataLabels::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabels::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabels::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabels::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DataLabels::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabels::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT DataLabels::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabels::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DataLabels::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DataLabels::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabels::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long DataLabels::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DataLabels::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT DataLabels::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabels::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DataLabels::GetAutoText() +{ + BOOL result; + InvokeHelper(0x87, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetAutoText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x87, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString DataLabels::GetNumberFormat() +{ + CString result; + InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DataLabels::SetNumberFormat(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL DataLabels::GetNumberFormatLinked() +{ + BOOL result; + InvokeHelper(0xc2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetNumberFormatLinked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xc2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DataLabels::GetNumberFormatLocal() +{ + VARIANT result; + InvokeHelper(0x449, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabels::SetNumberFormatLocal(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x449, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DataLabels::GetShowLegendKey() +{ + BOOL result; + InvokeHelper(0xab, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetShowLegendKey(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xab, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DataLabels::GetType() +{ + VARIANT result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabels::SetType(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long DataLabels::GetPosition() +{ + long result; + InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DataLabels::SetPosition(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL DataLabels::GetShowSeriesName() +{ + BOOL result; + InvokeHelper(0x7e6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetShowSeriesName(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataLabels::GetShowCategoryName() +{ + BOOL result; + InvokeHelper(0x7e7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetShowCategoryName(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataLabels::GetShowValue() +{ + BOOL result; + InvokeHelper(0x7e8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetShowValue(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataLabels::GetShowPercentage() +{ + BOOL result; + InvokeHelper(0x7e9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetShowPercentage(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataLabels::GetShowBubbleSize() +{ + BOOL result; + InvokeHelper(0x7ea, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataLabels::SetShowBubbleSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7ea, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT DataLabels::GetSeparator() +{ + VARIANT result; + InvokeHelper(0x7eb, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataLabels::SetSeparator(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x7eb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long DataLabels::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataLabels::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN DataLabels::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// LegendEntry properties + +///////////////////////////////////////////////////////////////////////////// +// LegendEntry operations + +LPDISPATCH LegendEntry::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long LegendEntry::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendEntry::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT LegendEntry::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendEntry::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long LegendEntry::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendEntry::GetLegendKey() +{ + LPDISPATCH result; + InvokeHelper(0xae, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT LegendEntry::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT LegendEntry::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void LegendEntry::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +double LegendEntry::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double LegendEntry::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double LegendEntry::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double LegendEntry::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// LegendEntries properties + +///////////////////////////////////////////////////////////////////////////// +// LegendEntries operations + +LPDISPATCH LegendEntries::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long LegendEntries::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendEntries::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long LegendEntries::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendEntries::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN LegendEntries::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// LegendKey properties + +///////////////////////////////////////////////////////////////////////////// +// LegendKey operations + +LPDISPATCH LegendKey::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long LegendKey::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendKey::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendKey::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT LegendKey::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT LegendKey::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendKey::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH LegendKey::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL LegendKey::GetInvertIfNegative() +{ + BOOL result; + InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void LegendKey::SetInvertIfNegative(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long LegendKey::GetMarkerBackgroundColor() +{ + long result; + InvokeHelper(0x49, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LegendKey::SetMarkerBackgroundColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x49, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LegendKey::GetMarkerBackgroundColorIndex() +{ + long result; + InvokeHelper(0x4a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LegendKey::SetMarkerBackgroundColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LegendKey::GetMarkerForegroundColor() +{ + long result; + InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LegendKey::SetMarkerForegroundColor(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LegendKey::GetMarkerForegroundColorIndex() +{ + long result; + InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LegendKey::SetMarkerForegroundColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x4c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LegendKey::GetMarkerSize() +{ + long result; + InvokeHelper(0xe7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LegendKey::SetMarkerSize(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xe7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LegendKey::GetMarkerStyle() +{ + long result; + InvokeHelper(0x48, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LegendKey::SetMarkerStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x48, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LegendKey::GetPictureType() +{ + long result; + InvokeHelper(0xa1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LegendKey::SetPictureType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xa1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long LegendKey::GetPictureUnit() +{ + long result; + InvokeHelper(0xa2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void LegendKey::SetPictureUnit(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xa2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT LegendKey::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL LegendKey::GetSmooth() +{ + BOOL result; + InvokeHelper(0xa3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void LegendKey::SetSmooth(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xa3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +double LegendKey::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double LegendKey::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double LegendKey::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double LegendKey::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +BOOL LegendKey::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void LegendKey::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Trendlines properties + +///////////////////////////////////////////////////////////////////////////// +// Trendlines operations + +LPDISPATCH Trendlines::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Trendlines::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Trendlines::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Trendlines::Add(long Type, const VARIANT& Order, const VARIANT& Period, const VARIANT& Forward, const VARIANT& Backward, const VARIANT& Intercept, const VARIANT& DisplayEquation, const VARIANT& DisplayRSquared, const VARIANT& Name) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, &Order, &Period, &Forward, &Backward, &Intercept, &DisplayEquation, &DisplayRSquared, &Name); + return result; +} + +long Trendlines::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Trendlines::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Trendlines::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Trendline properties + +///////////////////////////////////////////////////////////////////////////// +// Trendline operations + +LPDISPATCH Trendline::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Trendline::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Trendline::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Trendline::GetBackward() +{ + long result; + InvokeHelper(0xb9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Trendline::SetBackward(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xb9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Trendline::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Trendline::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Trendline::GetDataLabel() +{ + LPDISPATCH result; + InvokeHelper(0x9e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Trendline::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL Trendline::GetDisplayEquation() +{ + BOOL result; + InvokeHelper(0xbe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Trendline::SetDisplayEquation(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xbe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL Trendline::GetDisplayRSquared() +{ + BOOL result; + InvokeHelper(0xbd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Trendline::SetDisplayRSquared(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xbd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Trendline::GetForward() +{ + long result; + InvokeHelper(0xbf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Trendline::SetForward(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xbf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Trendline::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +double Trendline::GetIntercept() +{ + double result; + InvokeHelper(0xba, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Trendline::SetIntercept(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0xba, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +BOOL Trendline::GetInterceptIsAuto() +{ + BOOL result; + InvokeHelper(0xbb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Trendline::SetInterceptIsAuto(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xbb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString Trendline::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Trendline::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL Trendline::GetNameIsAuto() +{ + BOOL result; + InvokeHelper(0xbc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Trendline::SetNameIsAuto(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xbc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Trendline::GetOrder() +{ + long result; + InvokeHelper(0xc0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Trendline::SetOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xc0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Trendline::GetPeriod() +{ + long result; + InvokeHelper(0xb8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Trendline::SetPeriod(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xb8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT Trendline::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Trendline::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Trendline::SetType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Corners properties + +///////////////////////////////////////////////////////////////////////////// +// Corners operations + +LPDISPATCH Corners::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Corners::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Corners::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Corners::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT Corners::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// SeriesLines properties + +///////////////////////////////////////////////////////////////////////////// +// SeriesLines operations + +LPDISPATCH SeriesLines::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SeriesLines::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SeriesLines::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString SeriesLines::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT SeriesLines::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH SeriesLines::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT SeriesLines::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// HiLoLines properties + +///////////////////////////////////////////////////////////////////////////// +// HiLoLines operations + +LPDISPATCH HiLoLines::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long HiLoLines::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH HiLoLines::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString HiLoLines::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT HiLoLines::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH HiLoLines::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT HiLoLines::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Gridlines properties + +///////////////////////////////////////////////////////////////////////////// +// Gridlines operations + +LPDISPATCH Gridlines::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Gridlines::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Gridlines::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Gridlines::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT Gridlines::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Gridlines::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Gridlines::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DropLines properties + +///////////////////////////////////////////////////////////////////////////// +// DropLines operations + +LPDISPATCH DropLines::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DropLines::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropLines::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DropLines::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT DropLines::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DropLines::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DropLines::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// LeaderLines properties + +///////////////////////////////////////////////////////////////////////////// +// LeaderLines operations + +LPDISPATCH LeaderLines::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long LeaderLines::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH LeaderLines::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH LeaderLines::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void LeaderLines::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void LeaderLines::Select() +{ + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// UpBars properties + +///////////////////////////////////////////////////////////////////////////// +// UpBars operations + +LPDISPATCH UpBars::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long UpBars::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH UpBars::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString UpBars::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT UpBars::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH UpBars::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT UpBars::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH UpBars::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH UpBars::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DownBars properties + +///////////////////////////////////////////////////////////////////////////// +// DownBars operations + +LPDISPATCH DownBars::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DownBars::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DownBars::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DownBars::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT DownBars::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DownBars::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DownBars::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DownBars::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DownBars::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Floor properties + +///////////////////////////////////////////////////////////////////////////// +// Floor operations + +LPDISPATCH Floor::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Floor::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Floor::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Floor::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT Floor::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Floor::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Floor::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Floor::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Floor::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Floor::GetPictureType() +{ + VARIANT result; + InvokeHelper(0xa1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Floor::SetPictureType(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xa1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +void Floor::Paste() +{ + InvokeHelper(0xd3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// Walls properties + +///////////////////////////////////////////////////////////////////////////// +// Walls operations + +LPDISPATCH Walls::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Walls::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Walls::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Walls::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT Walls::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Walls::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Walls::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Walls::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Walls::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Walls::GetPictureType() +{ + VARIANT result; + InvokeHelper(0xa1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Walls::SetPictureType(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xa1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +void Walls::Paste() +{ + InvokeHelper(0xd3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +VARIANT Walls::GetPictureUnit() +{ + VARIANT result; + InvokeHelper(0xa2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Walls::SetPictureUnit(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xa2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// TickLabels properties + +///////////////////////////////////////////////////////////////////////////// +// TickLabels operations + +LPDISPATCH TickLabels::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long TickLabels::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TickLabels::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT TickLabels::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH TickLabels::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString TickLabels::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString TickLabels::GetNumberFormat() +{ + CString result; + InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void TickLabels::SetNumberFormat(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL TickLabels::GetNumberFormatLinked() +{ + BOOL result; + InvokeHelper(0xc2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TickLabels::SetNumberFormatLinked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xc2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT TickLabels::GetNumberFormatLocal() +{ + VARIANT result; + InvokeHelper(0x449, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TickLabels::SetNumberFormatLocal(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x449, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long TickLabels::GetOrientation() +{ + long result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TickLabels::SetOrientation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT TickLabels::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long TickLabels::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TickLabels::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT TickLabels::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void TickLabels::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long TickLabels::GetDepth() +{ + long result; + InvokeHelper(0x762, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long TickLabels::GetOffset() +{ + long result; + InvokeHelper(0xfe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TickLabels::SetOffset(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xfe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long TickLabels::GetAlignment() +{ + long result; + InvokeHelper(0x1c5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TickLabels::SetAlignment(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1c5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// PlotArea properties + +///////////////////////////////////////////////////////////////////////////// +// PlotArea operations + +LPDISPATCH PlotArea::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PlotArea::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PlotArea::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString PlotArea::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT PlotArea::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH PlotArea::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT PlotArea::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double PlotArea::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PlotArea::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH PlotArea::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PlotArea::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +double PlotArea::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PlotArea::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double PlotArea::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PlotArea::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double PlotArea::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void PlotArea::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double PlotArea::GetInsideLeft() +{ + double result; + InvokeHelper(0x683, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double PlotArea::GetInsideTop() +{ + double result; + InvokeHelper(0x684, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double PlotArea::GetInsideWidth() +{ + double result; + InvokeHelper(0x685, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +double PlotArea::GetInsideHeight() +{ + double result; + InvokeHelper(0x686, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ChartArea properties + +///////////////////////////////////////////////////////////////////////////// +// ChartArea operations + +LPDISPATCH ChartArea::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ChartArea::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartArea::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString ChartArea::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT ChartArea::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartArea::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ChartArea::Clear() +{ + VARIANT result; + InvokeHelper(0x6f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ChartArea::ClearContents() +{ + VARIANT result; + InvokeHelper(0x71, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ChartArea::Copy() +{ + VARIANT result; + InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartArea::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ChartArea::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ChartArea::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT ChartArea::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double ChartArea::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartArea::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH ChartArea::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ChartArea::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +double ChartArea::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartArea::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double ChartArea::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartArea::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double ChartArea::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void ChartArea::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT ChartArea::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void ChartArea::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Legend properties + +///////////////////////////////////////////////////////////////////////////// +// Legend operations + +LPDISPATCH Legend::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Legend::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Legend::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Legend::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT Legend::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Legend::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Legend::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH Legend::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Legend::LegendEntries(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xad, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long Legend::GetPosition() +{ + long result; + InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Legend::SetPosition(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Legend::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Legend::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +VARIANT Legend::Clear() +{ + VARIANT result; + InvokeHelper(0x6f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +double Legend::GetHeight() +{ + double result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Legend::SetHeight(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Legend::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Legend::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +double Legend::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Legend::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Legend::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Legend::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +double Legend::GetWidth() +{ + double result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void Legend::SetWidth(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT Legend::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Legend::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ErrorBars properties + +///////////////////////////////////////////////////////////////////////////// +// ErrorBars operations + +LPDISPATCH ErrorBars::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ErrorBars::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ErrorBars::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString ErrorBars::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT ErrorBars::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH ErrorBars::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT ErrorBars::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ErrorBars::ClearFormats() +{ + VARIANT result; + InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long ErrorBars::GetEndStyle() +{ + long result; + InvokeHelper(0x464, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ErrorBars::SetEndStyle(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x464, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// DataTable properties + +///////////////////////////////////////////////////////////////////////////// +// DataTable operations + +LPDISPATCH DataTable::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DataTable::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataTable::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL DataTable::GetShowLegendKey() +{ + BOOL result; + InvokeHelper(0xab, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataTable::SetShowLegendKey(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0xab, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataTable::GetHasBorderHorizontal() +{ + BOOL result; + InvokeHelper(0x687, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataTable::SetHasBorderHorizontal(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x687, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataTable::GetHasBorderVertical() +{ + BOOL result; + InvokeHelper(0x688, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataTable::SetHasBorderVertical(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x688, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL DataTable::GetHasBorderOutline() +{ + BOOL result; + InvokeHelper(0x689, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DataTable::SetHasBorderOutline(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x689, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH DataTable::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DataTable::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void DataTable::Select() +{ + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void DataTable::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +VARIANT DataTable::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DataTable::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Phonetic properties + +///////////////////////////////////////////////////////////////////////////// +// Phonetic operations + +LPDISPATCH Phonetic::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Phonetic::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Phonetic::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Phonetic::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Phonetic::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Phonetic::GetCharacterType() +{ + long result; + InvokeHelper(0x68a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Phonetic::SetCharacterType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x68a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Phonetic::GetAlignment() +{ + long result; + InvokeHelper(0x1c5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Phonetic::SetAlignment(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1c5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Phonetic::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString Phonetic::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Phonetic::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Shape properties + +///////////////////////////////////////////////////////////////////////////// +// Shape operations + +LPDISPATCH Shape::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Shape::Apply() +{ + InvokeHelper(0x68b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Shape::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Shape::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Shape::Flip(long FlipCmd) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x68c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + FlipCmd); +} + +void Shape::IncrementLeft(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x68e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void Shape::IncrementRotation(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x690, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void Shape::IncrementTop(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x691, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void Shape::PickUp() +{ + InvokeHelper(0x692, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Shape::RerouteConnections() +{ + InvokeHelper(0x693, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Shape::ScaleHeight(float Factor, long RelativeToOriginalSize, const VARIANT& Scale) +{ + static BYTE parms[] = + VTS_R4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x694, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Factor, RelativeToOriginalSize, &Scale); +} + +void Shape::ScaleWidth(float Factor, long RelativeToOriginalSize, const VARIANT& Scale) +{ + static BYTE parms[] = + VTS_R4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x698, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Factor, RelativeToOriginalSize, &Scale); +} + +void Shape::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +void Shape::SetShapesDefaultProperties() +{ + InvokeHelper(0x699, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Shape::Ungroup() +{ + LPDISPATCH result; + InvokeHelper(0xf4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Shape::ZOrder(long ZOrderCmd) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x26e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ZOrderCmd); +} + +LPDISPATCH Shape::GetAdjustments() +{ + LPDISPATCH result; + InvokeHelper(0x69b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetTextFrame() +{ + LPDISPATCH result; + InvokeHelper(0x69c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetAutoShapeType() +{ + long result; + InvokeHelper(0x69d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Shape::SetAutoShapeType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x69d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Shape::GetCallout() +{ + LPDISPATCH result; + InvokeHelper(0x69e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetConnectionSiteCount() +{ + long result; + InvokeHelper(0x69f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long Shape::GetConnector() +{ + long result; + InvokeHelper(0x6a0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetConnectorFormat() +{ + LPDISPATCH result; + InvokeHelper(0x6a1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetGroupItems() +{ + LPDISPATCH result; + InvokeHelper(0x6a2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +float Shape::GetHeight() +{ + float result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Shape::SetHeight(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Shape::GetHorizontalFlip() +{ + long result; + InvokeHelper(0x6a3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float Shape::GetLeft() +{ + float result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Shape::SetLeft(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Shape::GetLine() +{ + LPDISPATCH result; + InvokeHelper(0x331, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetLockAspectRatio() +{ + long result; + InvokeHelper(0x6a4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Shape::SetLockAspectRatio(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6a4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString Shape::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Shape::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Shape::GetNodes() +{ + LPDISPATCH result; + InvokeHelper(0x6a5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +float Shape::GetRotation() +{ + float result; + InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Shape::SetRotation(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x3b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH Shape::GetPictureFormat() +{ + LPDISPATCH result; + InvokeHelper(0x65f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetShadow() +{ + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetTextEffect() +{ + LPDISPATCH result; + InvokeHelper(0x6a6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetThreeD() +{ + LPDISPATCH result; + InvokeHelper(0x6a7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +float Shape::GetTop() +{ + float result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Shape::SetTop(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Shape::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long Shape::GetVerticalFlip() +{ + long result; + InvokeHelper(0x6a8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT Shape::GetVertices() +{ + VARIANT result; + InvokeHelper(0x26d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long Shape::GetVisible() +{ + long result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Shape::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float Shape::GetWidth() +{ + float result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Shape::SetWidth(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Shape::GetZOrderPosition() +{ + long result; + InvokeHelper(0x6a9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetHyperlink() +{ + LPDISPATCH result; + InvokeHelper(0x6aa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetBlackWhiteMode() +{ + long result; + InvokeHelper(0x6ab, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Shape::SetBlackWhiteMode(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6ab, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString Shape::GetOnAction() +{ + CString result; + InvokeHelper(0x254, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Shape::SetOnAction(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x254, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL Shape::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Shape::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +LPDISPATCH Shape::GetTopLeftCell() +{ + LPDISPATCH result; + InvokeHelper(0x26c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetBottomRightCell() +{ + LPDISPATCH result; + InvokeHelper(0x267, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetPlacement() +{ + long result; + InvokeHelper(0x269, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Shape::SetPlacement(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x269, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void Shape::Copy() +{ + InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Shape::Cut() +{ + InvokeHelper(0x235, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Shape::CopyPicture(const VARIANT& Appearance, const VARIANT& Format) +{ + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xd5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Appearance, &Format); +} + +LPDISPATCH Shape::GetControlFormat() +{ + LPDISPATCH result; + InvokeHelper(0x6ad, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetLinkFormat() +{ + LPDISPATCH result; + InvokeHelper(0x6ae, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetOLEFormat() +{ + LPDISPATCH result; + InvokeHelper(0x6af, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetFormControlType() +{ + long result; + InvokeHelper(0x6b0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString Shape::GetAlternativeText() +{ + CString result; + InvokeHelper(0x763, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Shape::SetAlternativeText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x763, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Shape::GetScript() +{ + LPDISPATCH result; + InvokeHelper(0x764, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetDiagramNode() +{ + LPDISPATCH result; + InvokeHelper(0x875, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetHasDiagramNode() +{ + long result; + InvokeHelper(0x876, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetDiagram() +{ + LPDISPATCH result; + InvokeHelper(0x877, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetHasDiagram() +{ + long result; + InvokeHelper(0x878, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long Shape::GetChild() +{ + long result; + InvokeHelper(0x879, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shape::GetParentGroup() +{ + LPDISPATCH result; + InvokeHelper(0x87a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shape::GetId() +{ + long result; + InvokeHelper(0x23a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Shapes properties + +///////////////////////////////////////////////////////////////////////////// +// Shapes operations + +LPDISPATCH Shapes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shapes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shapes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Shapes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shapes::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH Shapes::_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Shapes::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH Shapes::AddCallout(long Type, float Left, float Top, float Width, float Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0x6b1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, Left, Top, Width, Height); + return result; +} + +LPDISPATCH Shapes::AddConnector(long Type, float BeginX, float BeginY, float EndX, float EndY) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0x6b2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, BeginX, BeginY, EndX, EndY); + return result; +} + +LPDISPATCH Shapes::AddCurve(const VARIANT& SafeArrayOfPoints) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6b7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &SafeArrayOfPoints); + return result; +} + +LPDISPATCH Shapes::AddLabel(long Orientation, float Left, float Top, float Width, float Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0x6b9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Orientation, Left, Top, Width, Height); + return result; +} + +LPDISPATCH Shapes::AddLine(float BeginX, float BeginY, float EndX, float EndY) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0x6ba, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + BeginX, BeginY, EndX, EndY); + return result; +} + +LPDISPATCH Shapes::AddPicture(LPCTSTR Filename, long LinkToFile, long SaveWithDocument, float Left, float Top, float Width, float Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_I4 VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0x6bb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Filename, LinkToFile, SaveWithDocument, Left, Top, Width, Height); + return result; +} + +LPDISPATCH Shapes::AddPolyline(const VARIANT& SafeArrayOfPoints) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6be, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &SafeArrayOfPoints); + return result; +} + +LPDISPATCH Shapes::AddShape(long Type, float Left, float Top, float Width, float Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0x6bf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, Left, Top, Width, Height); + return result; +} + +LPDISPATCH Shapes::AddTextEffect(long PresetTextEffect, LPCTSTR Text, LPCTSTR FontName, float FontSize, long FontBold, long FontItalic, float Left, float Top) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_BSTR VTS_BSTR VTS_R4 VTS_I4 VTS_I4 VTS_R4 VTS_R4; + InvokeHelper(0x6c0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + PresetTextEffect, Text, FontName, FontSize, FontBold, FontItalic, Left, Top); + return result; +} + +LPDISPATCH Shapes::AddTextbox(long Orientation, float Left, float Top, float Width, float Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0x6c6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Orientation, Left, Top, Width, Height); + return result; +} + +LPDISPATCH Shapes::BuildFreeform(long EditingType, float X1, float Y1) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_R4 VTS_R4; + InvokeHelper(0x6c7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + EditingType, X1, Y1); + return result; +} + +LPDISPATCH Shapes::GetRange(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +void Shapes::SelectAll() +{ + InvokeHelper(0x6c9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH Shapes::AddFormControl(long Type, long Left, long Top, long Width, long Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4; + InvokeHelper(0x6ca, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, Left, Top, Width, Height); + return result; +} + +LPDISPATCH Shapes::AddOLEObject(const VARIANT& ClassType, const VARIANT& Filename, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel, const VARIANT& Left, + const VARIANT& Top, const VARIANT& Width, const VARIANT& Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6cb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &ClassType, &Filename, &Link, &DisplayAsIcon, &IconFileName, &IconIndex, &IconLabel, &Left, &Top, &Width, &Height); + return result; +} + +LPDISPATCH Shapes::AddDiagram(long Type, float Left, float Top, float Width, float Height) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4; + InvokeHelper(0x880, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Type, Left, Top, Width, Height); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ShapeRange properties + +///////////////////////////////////////////////////////////////////////////// +// ShapeRange operations + +LPDISPATCH ShapeRange::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH ShapeRange::_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ShapeRange::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void ShapeRange::Align(long AlignCmd, long RelativeTo) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x6cc, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + AlignCmd, RelativeTo); +} + +void ShapeRange::Apply() +{ + InvokeHelper(0x68b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ShapeRange::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ShapeRange::Distribute(long DistributeCmd, long RelativeTo) +{ + static BYTE parms[] = + VTS_I4 VTS_I4; + InvokeHelper(0x6ce, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + DistributeCmd, RelativeTo); +} + +LPDISPATCH ShapeRange::Duplicate() +{ + LPDISPATCH result; + InvokeHelper(0x40f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ShapeRange::Flip(long FlipCmd) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x68c, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + FlipCmd); +} + +void ShapeRange::IncrementLeft(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x68e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void ShapeRange::IncrementRotation(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x690, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +void ShapeRange::IncrementTop(float Increment) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x691, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Increment); +} + +LPDISPATCH ShapeRange::Group() +{ + LPDISPATCH result; + InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ShapeRange::PickUp() +{ + InvokeHelper(0x692, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ShapeRange::RerouteConnections() +{ + InvokeHelper(0x693, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH ShapeRange::Regroup() +{ + LPDISPATCH result; + InvokeHelper(0x6d0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ShapeRange::ScaleHeight(float Factor, long RelativeToOriginalSize, const VARIANT& Scale) +{ + static BYTE parms[] = + VTS_R4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x694, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Factor, RelativeToOriginalSize, &Scale); +} + +void ShapeRange::ScaleWidth(float Factor, long RelativeToOriginalSize, const VARIANT& Scale) +{ + static BYTE parms[] = + VTS_R4 VTS_I4 VTS_VARIANT; + InvokeHelper(0x698, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Factor, RelativeToOriginalSize, &Scale); +} + +void ShapeRange::Select(const VARIANT& Replace) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Replace); +} + +void ShapeRange::SetShapesDefaultProperties() +{ + InvokeHelper(0x699, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH ShapeRange::Ungroup() +{ + LPDISPATCH result; + InvokeHelper(0xf4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ShapeRange::ZOrder(long ZOrderCmd) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x26e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ZOrderCmd); +} + +LPDISPATCH ShapeRange::GetAdjustments() +{ + LPDISPATCH result; + InvokeHelper(0x69b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetTextFrame() +{ + LPDISPATCH result; + InvokeHelper(0x69c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetAutoShapeType() +{ + long result; + InvokeHelper(0x69d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetAutoShapeType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x69d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH ShapeRange::GetCallout() +{ + LPDISPATCH result; + InvokeHelper(0x69e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetConnectionSiteCount() +{ + long result; + InvokeHelper(0x69f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetConnector() +{ + long result; + InvokeHelper(0x6a0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetConnectorFormat() +{ + LPDISPATCH result; + InvokeHelper(0x6a1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetGroupItems() +{ + LPDISPATCH result; + InvokeHelper(0x6a2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +float ShapeRange::GetHeight() +{ + float result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetHeight(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ShapeRange::GetHorizontalFlip() +{ + long result; + InvokeHelper(0x6a3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +float ShapeRange::GetLeft() +{ + float result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetLeft(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH ShapeRange::GetLine() +{ + LPDISPATCH result; + InvokeHelper(0x331, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetLockAspectRatio() +{ + long result; + InvokeHelper(0x6a4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetLockAspectRatio(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6a4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString ShapeRange::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH ShapeRange::GetNodes() +{ + LPDISPATCH result; + InvokeHelper(0x6a5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +float ShapeRange::GetRotation() +{ + float result; + InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetRotation(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x3b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH ShapeRange::GetPictureFormat() +{ + LPDISPATCH result; + InvokeHelper(0x65f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetShadow() +{ + LPDISPATCH result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetTextEffect() +{ + LPDISPATCH result; + InvokeHelper(0x6a6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetThreeD() +{ + LPDISPATCH result; + InvokeHelper(0x6a7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +float ShapeRange::GetTop() +{ + float result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetTop(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ShapeRange::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetVerticalFlip() +{ + long result; + InvokeHelper(0x6a8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT ShapeRange::GetVertices() +{ + VARIANT result; + InvokeHelper(0x26d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetVisible() +{ + long result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetVisible(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float ShapeRange::GetWidth() +{ + float result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetWidth(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long ShapeRange::GetZOrderPosition() +{ + long result; + InvokeHelper(0x6a9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetBlackWhiteMode() +{ + long result; + InvokeHelper(0x6ab, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetBlackWhiteMode(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6ab, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString ShapeRange::GetAlternativeText() +{ + CString result; + InvokeHelper(0x763, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ShapeRange::SetAlternativeText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x763, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH ShapeRange::GetDiagramNode() +{ + LPDISPATCH result; + InvokeHelper(0x875, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetHasDiagramNode() +{ + long result; + InvokeHelper(0x876, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetDiagram() +{ + LPDISPATCH result; + InvokeHelper(0x877, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetHasDiagram() +{ + long result; + InvokeHelper(0x878, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetChild() +{ + long result; + InvokeHelper(0x879, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ShapeRange::GetParentGroup() +{ + LPDISPATCH result; + InvokeHelper(0x87a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ShapeRange::GetId() +{ + long result; + InvokeHelper(0x23a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// GroupShapes properties + +///////////////////////////////////////////////////////////////////////////// +// GroupShapes operations + +LPDISPATCH GroupShapes::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long GroupShapes::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupShapes::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long GroupShapes::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupShapes::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH GroupShapes::_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN GroupShapes::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH GroupShapes::GetRange(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// TextFrame properties + +///////////////////////////////////////////////////////////////////////////// +// TextFrame operations + +LPDISPATCH TextFrame::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long TextFrame::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH TextFrame::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +float TextFrame::GetMarginBottom() +{ + float result; + InvokeHelper(0x6d1, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void TextFrame::SetMarginBottom(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6d1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float TextFrame::GetMarginLeft() +{ + float result; + InvokeHelper(0x6d2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void TextFrame::SetMarginLeft(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6d2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float TextFrame::GetMarginRight() +{ + float result; + InvokeHelper(0x6d3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void TextFrame::SetMarginRight(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6d3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float TextFrame::GetMarginTop() +{ + float result; + InvokeHelper(0x6d4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void TextFrame::SetMarginTop(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x6d4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long TextFrame::GetOrientation() +{ + long result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextFrame::SetOrientation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH TextFrame::Characters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +long TextFrame::GetHorizontalAlignment() +{ + long result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextFrame::SetHorizontalAlignment(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long TextFrame::GetVerticalAlignment() +{ + long result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextFrame::SetVerticalAlignment(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL TextFrame::GetAutoSize() +{ + BOOL result; + InvokeHelper(0x266, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextFrame::SetAutoSize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long TextFrame::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void TextFrame::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL TextFrame::GetAutoMargins() +{ + BOOL result; + InvokeHelper(0x6d5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void TextFrame::SetAutoMargins(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x6d5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ConnectorFormat properties + +///////////////////////////////////////////////////////////////////////////// +// ConnectorFormat operations + +LPDISPATCH ConnectorFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ConnectorFormat::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ConnectorFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ConnectorFormat::BeginConnect(LPDISPATCH ConnectedShape, long ConnectionSite) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0x6d6, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ConnectedShape, ConnectionSite); +} + +void ConnectorFormat::BeginDisconnect() +{ + InvokeHelper(0x6d9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ConnectorFormat::EndConnect(LPDISPATCH ConnectedShape, long ConnectionSite) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_I4; + InvokeHelper(0x6da, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + ConnectedShape, ConnectionSite); +} + +void ConnectorFormat::EndDisconnect() +{ + InvokeHelper(0x6db, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long ConnectorFormat::GetBeginConnected() +{ + long result; + InvokeHelper(0x6dc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ConnectorFormat::GetBeginConnectedShape() +{ + LPDISPATCH result; + InvokeHelper(0x6dd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ConnectorFormat::GetBeginConnectionSite() +{ + long result; + InvokeHelper(0x6de, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ConnectorFormat::GetEndConnected() +{ + long result; + InvokeHelper(0x6df, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ConnectorFormat::GetEndConnectedShape() +{ + LPDISPATCH result; + InvokeHelper(0x6e0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ConnectorFormat::GetEndConnectionSite() +{ + long result; + InvokeHelper(0x6e1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ConnectorFormat::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ConnectorFormat::SetType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// FreeformBuilder properties + +///////////////////////////////////////////////////////////////////////////// +// FreeformBuilder operations + +LPDISPATCH FreeformBuilder::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long FreeformBuilder::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH FreeformBuilder::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void FreeformBuilder::AddNodes(long SegmentType, long EditingType, float X1, float Y1, const VARIANT& X2, const VARIANT& Y2, const VARIANT& X3, const VARIANT& Y3) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_R4 VTS_R4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x6e2, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + SegmentType, EditingType, X1, Y1, &X2, &Y2, &X3, &Y3); +} + +LPDISPATCH FreeformBuilder::ConvertToShape() +{ + LPDISPATCH result; + InvokeHelper(0x6e6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ControlFormat properties + +///////////////////////////////////////////////////////////////////////////// +// ControlFormat operations + +LPDISPATCH ControlFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ControlFormat::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ControlFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ControlFormat::AddItem(LPCTSTR Text, const VARIANT& Index) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x353, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Text, &Index); +} + +void ControlFormat::RemoveAllItems() +{ + InvokeHelper(0x355, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ControlFormat::RemoveItem(long Index, const VARIANT& Count) +{ + static BYTE parms[] = + VTS_I4 VTS_VARIANT; + InvokeHelper(0x354, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Index, &Count); +} + +long ControlFormat::GetDropDownLines() +{ + long result; + InvokeHelper(0x350, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetDropDownLines(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x350, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ControlFormat::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ControlFormat::GetLargeChange() +{ + long result; + InvokeHelper(0x34d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetLargeChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString ControlFormat::GetLinkedCell() +{ + CString result; + InvokeHelper(0x422, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetLinkedCell(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT ControlFormat::List(const VARIANT& Index) +{ + VARIANT result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x35d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, + &Index); + return result; +} + +long ControlFormat::GetListCount() +{ + long result; + InvokeHelper(0x351, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetListCount(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x351, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString ControlFormat::GetListFillRange() +{ + CString result; + InvokeHelper(0x34f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetListFillRange(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x34f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long ControlFormat::GetListIndex() +{ + long result; + InvokeHelper(0x352, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetListIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x352, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ControlFormat::GetLockedText() +{ + BOOL result; + InvokeHelper(0x268, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetLockedText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x268, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ControlFormat::GetMax() +{ + long result; + InvokeHelper(0x34a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetMax(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ControlFormat::GetMin() +{ + long result; + InvokeHelper(0x34b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetMin(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ControlFormat::GetMultiSelect() +{ + long result; + InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetMultiSelect(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ControlFormat::GetPrintObject() +{ + BOOL result; + InvokeHelper(0x26a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetPrintObject(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x26a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ControlFormat::GetSmallChange() +{ + long result; + InvokeHelper(0x34c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetSmallChange(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x34c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ControlFormat::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::Set_Default(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long ControlFormat::GetValue() +{ + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ControlFormat::SetValue(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// OLEFormat properties + +///////////////////////////////////////////////////////////////////////////// +// OLEFormat operations + +LPDISPATCH OLEFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OLEFormat::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void OLEFormat::Activate() +{ + InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH OLEFormat::GetObject() +{ + LPDISPATCH result; + InvokeHelper(0x419, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString OLEFormat::GetProgID() +{ + CString result; + InvokeHelper(0x5f3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void OLEFormat::Verb(const VARIANT& Verb) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x25e, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Verb); +} + + +///////////////////////////////////////////////////////////////////////////// +// LinkFormat properties + +///////////////////////////////////////////////////////////////////////////// +// LinkFormat operations + +LPDISPATCH LinkFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long LinkFormat::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH LinkFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL LinkFormat::GetAutoUpdate() +{ + BOOL result; + InvokeHelper(0x418, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void LinkFormat::SetAutoUpdate(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x418, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL LinkFormat::GetLocked() +{ + BOOL result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void LinkFormat::SetLocked(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void LinkFormat::Update() +{ + InvokeHelper(0x2a8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// PublishObjects properties + +///////////////////////////////////////////////////////////////////////////// +// PublishObjects operations + +LPDISPATCH PublishObjects::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PublishObjects::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PublishObjects::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PublishObjects::Add(long SourceType, LPCTSTR Filename, const VARIANT& Sheet, const VARIANT& Source, const VARIANT& HtmlType, const VARIANT& DivID, const VARIANT& Title) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + SourceType, Filename, &Sheet, &Source, &HtmlType, &DivID, &Title); + return result; +} + +long PublishObjects::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PublishObjects::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PublishObjects::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN PublishObjects::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void PublishObjects::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void PublishObjects::Publish() +{ + InvokeHelper(0x767, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// OLEDBError properties + +///////////////////////////////////////////////////////////////////////////// +// OLEDBError operations + +LPDISPATCH OLEDBError::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OLEDBError::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEDBError::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString OLEDBError::GetSqlState() +{ + CString result; + InvokeHelper(0x643, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString OLEDBError::GetErrorString() +{ + CString result; + InvokeHelper(0x5d2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long OLEDBError::GetNative() +{ + long result; + InvokeHelper(0x769, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long OLEDBError::GetNumber() +{ + long result; + InvokeHelper(0x1c3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long OLEDBError::GetStage() +{ + long result; + InvokeHelper(0x76a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// OLEDBErrors properties + +///////////////////////////////////////////////////////////////////////////// +// OLEDBErrors operations + +LPDISPATCH OLEDBErrors::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OLEDBErrors::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEDBErrors::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long OLEDBErrors::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH OLEDBErrors::Item(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPDISPATCH OLEDBErrors::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN OLEDBErrors::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Phonetics properties + +///////////////////////////////////////////////////////////////////////////// +// Phonetics operations + +LPDISPATCH Phonetics::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Phonetics::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Phonetics::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Phonetics::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long Phonetics::GetStart() +{ + long result; + InvokeHelper(0x260, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long Phonetics::GetLength() +{ + long result; + InvokeHelper(0x261, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL Phonetics::GetVisible() +{ + BOOL result; + InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Phonetics::SetVisible(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long Phonetics::GetCharacterType() +{ + long result; + InvokeHelper(0x68a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Phonetics::SetCharacterType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x68a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Phonetics::GetAlignment() +{ + long result; + InvokeHelper(0x1c5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Phonetics::SetAlignment(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x1c5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH Phonetics::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Phonetics::GetItem(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +void Phonetics::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void Phonetics::Add(long Start, long Length, LPCTSTR Text) +{ + static BYTE parms[] = + VTS_I4 VTS_I4 VTS_BSTR; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Start, Length, Text); +} + +CString Phonetics::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Phonetics::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH Phonetics::Get_Default(long Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + Index); + return result; +} + +LPUNKNOWN Phonetics::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotLayout properties + +///////////////////////////////////////////////////////////////////////////// +// PivotLayout operations + +LPDISPATCH PivotLayout::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotLayout::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotLayout::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotLayout::GetPivotTable() +{ + LPDISPATCH result; + InvokeHelper(0x2cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// DisplayUnitLabel properties + +///////////////////////////////////////////////////////////////////////////// +// DisplayUnitLabel operations + +LPDISPATCH DisplayUnitLabel::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long DisplayUnitLabel::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH DisplayUnitLabel::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DisplayUnitLabel::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +VARIANT DisplayUnitLabel::Select() +{ + VARIANT result; + InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DisplayUnitLabel::GetBorder() +{ + LPDISPATCH result; + InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DisplayUnitLabel::Delete() +{ + VARIANT result; + InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL); + return result; +} + +LPDISPATCH DisplayUnitLabel::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH DisplayUnitLabel::GetFill() +{ + LPDISPATCH result; + InvokeHelper(0x67f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString DisplayUnitLabel::GetCaption() +{ + CString result; + InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetCaption(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH DisplayUnitLabel::GetCharacters(const VARIANT& Start, const VARIANT& Length) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Start, &Length); + return result; +} + +LPDISPATCH DisplayUnitLabel::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT DisplayUnitLabel::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +double DisplayUnitLabel::GetLeft() +{ + double result; + InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetLeft(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT DisplayUnitLabel::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +BOOL DisplayUnitLabel::GetShadow() +{ + BOOL result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetShadow(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString DisplayUnitLabel::GetText() +{ + CString result; + InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +double DisplayUnitLabel::GetTop() +{ + double result; + InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetTop(double newValue) +{ + static BYTE parms[] = + VTS_R8; + InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT DisplayUnitLabel::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long DisplayUnitLabel::GetReadingOrder() +{ + long result; + InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetReadingOrder(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +VARIANT DisplayUnitLabel::GetAutoScaleFont() +{ + VARIANT result; + InvokeHelper(0x5f5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void DisplayUnitLabel::SetAutoScaleFont(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x5f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// CellFormat properties + +///////////////////////////////////////////////////////////////////////////// +// CellFormat operations + +LPDISPATCH CellFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CellFormat::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CellFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH CellFormat::GetBorders() +{ + LPDISPATCH result; + InvokeHelper(0x1b3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void CellFormat::SetRefBorders(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x1b3, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH CellFormat::GetFont() +{ + LPDISPATCH result; + InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void CellFormat::SetRefFont(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x92, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + +LPDISPATCH CellFormat::GetInterior() +{ + LPDISPATCH result; + InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void CellFormat::SetRefInterior(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x81, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + +VARIANT CellFormat::GetNumberFormat() +{ + VARIANT result; + InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetNumberFormat(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetNumberFormatLocal() +{ + VARIANT result; + InvokeHelper(0x449, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetNumberFormatLocal(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x449, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetAddIndent() +{ + VARIANT result; + InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetAddIndent(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetIndentLevel() +{ + VARIANT result; + InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetIndentLevel(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xc9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetHorizontalAlignment() +{ + VARIANT result; + InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetHorizontalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetVerticalAlignment() +{ + VARIANT result; + InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetVerticalAlignment(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetOrientation() +{ + VARIANT result; + InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetOrientation(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetShrinkToFit() +{ + VARIANT result; + InvokeHelper(0xd1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetShrinkToFit(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetWrapText() +{ + VARIANT result; + InvokeHelper(0x114, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetWrapText(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x114, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetLocked() +{ + VARIANT result; + InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetLocked(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetFormulaHidden() +{ + VARIANT result; + InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetFormulaHidden(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x106, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CellFormat::GetMergeCells() +{ + VARIANT result; + InvokeHelper(0xd0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CellFormat::SetMergeCells(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xd0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +void CellFormat::Clear() +{ + InvokeHelper(0x6f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// UsedObjects properties + +///////////////////////////////////////////////////////////////////////////// +// UsedObjects operations + +LPDISPATCH UsedObjects::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long UsedObjects::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH UsedObjects::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long UsedObjects::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPUNKNOWN UsedObjects::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH UsedObjects::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH UsedObjects::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// CustomProperties properties + +///////////////////////////////////////////////////////////////////////////// +// CustomProperties operations + +LPDISPATCH CustomProperties::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CustomProperties::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CustomProperties::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH CustomProperties::Add(LPCTSTR Name, const VARIANT& Value) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, &Value); + return result; +} + +long CustomProperties::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CustomProperties::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH CustomProperties::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN CustomProperties::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// CustomProperty properties + +///////////////////////////////////////////////////////////////////////////// +// CustomProperty operations + +LPDISPATCH CustomProperty::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CustomProperty::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CustomProperty::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString CustomProperty::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CustomProperty::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +VARIANT CustomProperty::GetValue() +{ + VARIANT result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CustomProperty::SetValue(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +VARIANT CustomProperty::Get_Default() +{ + VARIANT result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void CustomProperty::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// CalculatedMembers properties + +///////////////////////////////////////////////////////////////////////////// +// CalculatedMembers operations + +LPDISPATCH CalculatedMembers::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CalculatedMembers::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedMembers::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CalculatedMembers::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedMembers::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH CalculatedMembers::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN CalculatedMembers::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedMembers::Add(LPCTSTR Name, LPCTSTR Formula, const VARIANT& SolveOrder, const VARIANT& Type) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, Formula, &SolveOrder, &Type); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// CalculatedMember properties + +///////////////////////////////////////////////////////////////////////////// +// CalculatedMember operations + +LPDISPATCH CalculatedMember::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long CalculatedMember::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH CalculatedMember::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString CalculatedMember::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString CalculatedMember::GetFormula() +{ + CString result; + InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString CalculatedMember::GetSourceName() +{ + CString result; + InvokeHelper(0x2d1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long CalculatedMember::GetSolveOrder() +{ + long result; + InvokeHelper(0x88b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL CalculatedMember::GetIsValid() +{ + BOOL result; + InvokeHelper(0x88c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +CString CalculatedMember::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void CalculatedMember::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long CalculatedMember::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Watches properties + +///////////////////////////////////////////////////////////////////////////// +// Watches operations + +LPDISPATCH Watches::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Watches::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Watches::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Watches::Add(const VARIANT& Source) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Source); + return result; +} + +long Watches::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Watches::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH Watches::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN Watches::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void Watches::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// Watch properties + +///////////////////////////////////////////////////////////////////////////// +// Watch operations + +LPDISPATCH Watch::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Watch::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Watch::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void Watch::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +VARIANT Watch::GetSource() +{ + VARIANT result; + InvokeHelper(0xde, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotCell properties + +///////////////////////////////////////////////////////////////////////////// +// PivotCell operations + +LPDISPATCH PivotCell::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotCell::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCell::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotCell::GetPivotCellType() +{ + long result; + InvokeHelper(0x88d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCell::GetPivotTable() +{ + LPDISPATCH result; + InvokeHelper(0x2cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCell::GetDataField() +{ + LPDISPATCH result; + InvokeHelper(0x82b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCell::GetPivotField() +{ + LPDISPATCH result; + InvokeHelper(0x2db, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCell::GetPivotItem() +{ + LPDISPATCH result; + InvokeHelper(0x2e4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCell::GetRowItems() +{ + LPDISPATCH result; + InvokeHelper(0x88e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCell::GetColumnItems() +{ + LPDISPATCH result; + InvokeHelper(0x88f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotCell::GetRange() +{ + LPDISPATCH result; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotCell::GetCustomSubtotalFunction() +{ + long result; + InvokeHelper(0x891, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Graphic properties + +///////////////////////////////////////////////////////////////////////////// +// Graphic operations + +LPDISPATCH Graphic::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Graphic::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Graphic::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +float Graphic::GetBrightness() +{ + float result; + InvokeHelper(0x892, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Graphic::SetBrightness(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x892, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Graphic::GetColorType() +{ + long result; + InvokeHelper(0x893, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Graphic::SetColorType(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x893, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float Graphic::GetContrast() +{ + float result; + InvokeHelper(0x894, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Graphic::SetContrast(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x894, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float Graphic::GetCropBottom() +{ + float result; + InvokeHelper(0x895, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Graphic::SetCropBottom(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x895, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float Graphic::GetCropLeft() +{ + float result; + InvokeHelper(0x896, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Graphic::SetCropLeft(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x896, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float Graphic::GetCropRight() +{ + float result; + InvokeHelper(0x897, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Graphic::SetCropRight(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x897, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +float Graphic::GetCropTop() +{ + float result; + InvokeHelper(0x898, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Graphic::SetCropTop(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x898, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +CString Graphic::GetFilename() +{ + CString result; + InvokeHelper(0x587, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void Graphic::SetFilename(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x587, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +float Graphic::GetHeight() +{ + float result; + InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Graphic::SetHeight(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + +long Graphic::GetLockAspectRatio() +{ + long result; + InvokeHelper(0x6a4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Graphic::SetLockAspectRatio(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x6a4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +float Graphic::GetWidth() +{ + float result; + InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL); + return result; +} + +void Graphic::SetWidth(float newValue) +{ + static BYTE parms[] = + VTS_R4; + InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + newValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// AutoRecover properties + +///////////////////////////////////////////////////////////////////////////// +// AutoRecover operations + +LPDISPATCH AutoRecover::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long AutoRecover::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH AutoRecover::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL AutoRecover::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void AutoRecover::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long AutoRecover::GetTime() +{ + long result; + InvokeHelper(0x18a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void AutoRecover::SetTime(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x18a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString AutoRecover::GetPath() +{ + CString result; + InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void AutoRecover::SetPath(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x123, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// ErrorCheckingOptions properties + +///////////////////////////////////////////////////////////////////////////// +// ErrorCheckingOptions operations + +LPDISPATCH ErrorCheckingOptions::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ErrorCheckingOptions::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ErrorCheckingOptions::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ErrorCheckingOptions::GetBackgroundChecking() +{ + BOOL result; + InvokeHelper(0x899, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetBackgroundChecking(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x899, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ErrorCheckingOptions::GetIndicatorColorIndex() +{ + long result; + InvokeHelper(0x89a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetIndicatorColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x89a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL ErrorCheckingOptions::GetEvaluateToError() +{ + BOOL result; + InvokeHelper(0x89b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetEvaluateToError(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x89b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ErrorCheckingOptions::GetTextDate() +{ + BOOL result; + InvokeHelper(0x89c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetTextDate(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x89c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ErrorCheckingOptions::GetNumberAsText() +{ + BOOL result; + InvokeHelper(0x89d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetNumberAsText(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x89d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ErrorCheckingOptions::GetInconsistentFormula() +{ + BOOL result; + InvokeHelper(0x89e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetInconsistentFormula(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x89e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ErrorCheckingOptions::GetOmittedCells() +{ + BOOL result; + InvokeHelper(0x89f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetOmittedCells(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x89f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ErrorCheckingOptions::GetUnlockedFormulaCells() +{ + BOOL result; + InvokeHelper(0x8a0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetUnlockedFormulaCells(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8a0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ErrorCheckingOptions::GetEmptyCellReferences() +{ + BOOL result; + InvokeHelper(0x8a1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetEmptyCellReferences(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8a1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ErrorCheckingOptions::GetListDataValidation() +{ + BOOL result; + InvokeHelper(0x8f8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ErrorCheckingOptions::SetListDataValidation(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8f8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Errors properties + +///////////////////////////////////////////////////////////////////////////// +// Errors operations + +LPDISPATCH Errors::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Errors::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Errors::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Errors::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH Errors::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Error properties + +///////////////////////////////////////////////////////////////////////////// +// Error operations + +LPDISPATCH Error::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Error::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Error::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL Error::GetValue() +{ + BOOL result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Error::GetIgnore() +{ + BOOL result; + InvokeHelper(0x8a2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Error::SetIgnore(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// SmartTagAction properties + +///////////////////////////////////////////////////////////////////////////// +// SmartTagAction operations + +LPDISPATCH SmartTagAction::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTagAction::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTagAction::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString SmartTagAction::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void SmartTagAction::Execute() +{ + InvokeHelper(0x8a3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString SmartTagAction::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long SmartTagAction::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL SmartTagAction::GetPresentInPane() +{ + BOOL result; + InvokeHelper(0x8f9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL SmartTagAction::GetExpandHelp() +{ + BOOL result; + InvokeHelper(0x8fa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SmartTagAction::SetExpandHelp(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8fa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL SmartTagAction::GetCheckboxState() +{ + BOOL result; + InvokeHelper(0x8fb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SmartTagAction::SetCheckboxState(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8fb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString SmartTagAction::GetTextboxText() +{ + CString result; + InvokeHelper(0x8fc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void SmartTagAction::SetTextboxText(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8fc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +long SmartTagAction::GetListSelection() +{ + long result; + InvokeHelper(0x8fd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void SmartTagAction::SetListSelection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8fd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long SmartTagAction::GetRadioGroupSelection() +{ + long result; + InvokeHelper(0x8fe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void SmartTagAction::SetRadioGroupSelection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8fe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH SmartTagAction::GetActiveXControl() +{ + LPDISPATCH result; + InvokeHelper(0x8ff, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// SmartTagActions properties + +///////////////////////////////////////////////////////////////////////////// +// SmartTagActions operations + +LPDISPATCH SmartTagActions::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTagActions::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTagActions::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTagActions::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTagActions::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH SmartTagActions::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN SmartTagActions::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// SmartTag properties + +///////////////////////////////////////////////////////////////////////////// +// SmartTag operations + +LPDISPATCH SmartTag::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTag::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTag::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString SmartTag::GetDownloadURL() +{ + CString result; + InvokeHelper(0x8a4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString SmartTag::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString SmartTag::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString SmartTag::GetXml() +{ + CString result; + InvokeHelper(0x8a5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTag::GetRange() +{ + LPDISPATCH result; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void SmartTag::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH SmartTag::GetSmartTagActions() +{ + LPDISPATCH result; + InvokeHelper(0x8a6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTag::GetProperties() +{ + LPDISPATCH result; + InvokeHelper(0x857, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// SmartTags properties + +///////////////////////////////////////////////////////////////////////////// +// SmartTags operations + +LPDISPATCH SmartTags::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTags::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTags::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTags::Add(LPCTSTR SmartTagType) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + SmartTagType); + return result; +} + +long SmartTags::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTags::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN SmartTags::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// SmartTagRecognizer properties + +///////////////////////////////////////////////////////////////////////////// +// SmartTagRecognizer operations + +LPDISPATCH SmartTagRecognizer::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTagRecognizer::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTagRecognizer::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL SmartTagRecognizer::GetEnabled() +{ + BOOL result; + InvokeHelper(0x258, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SmartTagRecognizer::SetEnabled(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x258, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString SmartTagRecognizer::GetProgID() +{ + CString result; + InvokeHelper(0x8a8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString SmartTagRecognizer::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString SmartTagRecognizer::GetFullName() +{ + CString result; + InvokeHelper(0x121, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// SmartTagRecognizers properties + +///////////////////////////////////////////////////////////////////////////// +// SmartTagRecognizers operations + +LPDISPATCH SmartTagRecognizers::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTagRecognizers::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTagRecognizers::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTagRecognizers::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTagRecognizers::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH SmartTagRecognizers::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN SmartTagRecognizers::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +BOOL SmartTagRecognizers::GetRecognize() +{ + BOOL result; + InvokeHelper(0x8a9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SmartTagRecognizers::SetRecognize(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8a9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// SmartTagOptions properties + +///////////////////////////////////////////////////////////////////////////// +// SmartTagOptions operations + +LPDISPATCH SmartTagOptions::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTagOptions::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH SmartTagOptions::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long SmartTagOptions::GetDisplaySmartTags() +{ + long result; + InvokeHelper(0x8aa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void SmartTagOptions::SetDisplaySmartTags(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8aa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL SmartTagOptions::GetEmbedSmartTags() +{ + BOOL result; + InvokeHelper(0x8ab, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SmartTagOptions::SetEmbedSmartTags(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8ab, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// SpellingOptions properties + +///////////////////////////////////////////////////////////////////////////// +// SpellingOptions operations + +long SpellingOptions::GetDictLang() +{ + long result; + InvokeHelper(0x8ac, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetDictLang(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8ac, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +CString SpellingOptions::GetUserDict() +{ + CString result; + InvokeHelper(0x8ad, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetUserDict(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8ad, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL SpellingOptions::GetIgnoreCaps() +{ + BOOL result; + InvokeHelper(0x8ae, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetIgnoreCaps(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8ae, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL SpellingOptions::GetSuggestMainOnly() +{ + BOOL result; + InvokeHelper(0x8af, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetSuggestMainOnly(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8af, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL SpellingOptions::GetIgnoreMixedDigits() +{ + BOOL result; + InvokeHelper(0x8b0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetIgnoreMixedDigits(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8b0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL SpellingOptions::GetIgnoreFileNames() +{ + BOOL result; + InvokeHelper(0x8b1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetIgnoreFileNames(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8b1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL SpellingOptions::GetGermanPostReform() +{ + BOOL result; + InvokeHelper(0x8b2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetGermanPostReform(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8b2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL SpellingOptions::GetKoreanCombineAux() +{ + BOOL result; + InvokeHelper(0x8b3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetKoreanCombineAux(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8b3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL SpellingOptions::GetKoreanUseAutoChangeList() +{ + BOOL result; + InvokeHelper(0x8b4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetKoreanUseAutoChangeList(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8b4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL SpellingOptions::GetKoreanProcessCompound() +{ + BOOL result; + InvokeHelper(0x8b5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetKoreanProcessCompound(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8b5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long SpellingOptions::GetHebrewModes() +{ + long result; + InvokeHelper(0x8b6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetHebrewModes(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long SpellingOptions::GetArabicModes() +{ + long result; + InvokeHelper(0x8b7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void SpellingOptions::SetArabicModes(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8b7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Speech properties + +///////////////////////////////////////////////////////////////////////////// +// Speech operations + +void Speech::Speak(LPCTSTR Text, const VARIANT& SpeakAsync, const VARIANT& SpeakXML, const VARIANT& Purge) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x7e1, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Text, &SpeakAsync, &SpeakXML, &Purge); +} + +long Speech::GetDirection() +{ + long result; + InvokeHelper(0xa8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Speech::SetDirection(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0xa8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +BOOL Speech::GetSpeakCellOnEnter() +{ + BOOL result; + InvokeHelper(0x8bb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void Speech::SetSpeakCellOnEnter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x8bb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// Protection properties + +///////////////////////////////////////////////////////////////////////////// +// Protection operations + +BOOL Protection::GetAllowFormattingCells() +{ + BOOL result; + InvokeHelper(0x7f0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowFormattingColumns() +{ + BOOL result; + InvokeHelper(0x7f1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowFormattingRows() +{ + BOOL result; + InvokeHelper(0x7f2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowInsertingColumns() +{ + BOOL result; + InvokeHelper(0x7f3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowInsertingRows() +{ + BOOL result; + InvokeHelper(0x7f4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowInsertingHyperlinks() +{ + BOOL result; + InvokeHelper(0x7f5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowDeletingColumns() +{ + BOOL result; + InvokeHelper(0x7f6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowDeletingRows() +{ + BOOL result; + InvokeHelper(0x7f7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowSorting() +{ + BOOL result; + InvokeHelper(0x7f8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowFiltering() +{ + BOOL result; + InvokeHelper(0x7f9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL Protection::GetAllowUsingPivotTables() +{ + BOOL result; + InvokeHelper(0x7fa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH Protection::GetAllowEditRanges() +{ + LPDISPATCH result; + InvokeHelper(0x8bc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// PivotItemList properties + +///////////////////////////////////////////////////////////////////////////// +// PivotItemList operations + +LPDISPATCH PivotItemList::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotItemList::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotItemList::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long PivotItemList::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH PivotItemList::Item(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH PivotItemList::Get_Default(const VARIANT& Field) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Field); + return result; +} + +LPUNKNOWN PivotItemList::_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// Tab properties + +///////////////////////////////////////////////////////////////////////////// +// Tab operations + +LPDISPATCH Tab::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Tab::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Tab::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +VARIANT Tab::GetColor() +{ + VARIANT result; + InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +void Tab::SetColor(const VARIANT& newValue) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + &newValue); +} + +long Tab::GetColorIndex() +{ + long result; + InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Tab::SetColorIndex(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + + +///////////////////////////////////////////////////////////////////////////// +// AllowEditRanges properties + +///////////////////////////////////////////////////////////////////////////// +// AllowEditRanges operations + +long AllowEditRanges::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH AllowEditRanges::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH AllowEditRanges::Add(LPCTSTR Title, LPDISPATCH Range, const VARIANT& Password) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_DISPATCH VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Title, Range, &Password); + return result; +} + +LPDISPATCH AllowEditRanges::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN AllowEditRanges::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// AllowEditRange properties + +///////////////////////////////////////////////////////////////////////////// +// AllowEditRange operations + +CString AllowEditRange::GetTitle() +{ + CString result; + InvokeHelper(0xc7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void AllowEditRange::SetTitle(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0xc7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH AllowEditRange::GetRange() +{ + LPDISPATCH result; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void AllowEditRange::SetRefRange(LPDISPATCH newValue) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0xc5, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, + newValue); +} + +void AllowEditRange::ChangePassword(LPCTSTR Password) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x8bd, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Password); +} + +void AllowEditRange::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void AllowEditRange::Unprotect(const VARIANT& Password) +{ + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + &Password); +} + +LPDISPATCH AllowEditRange::GetUsers() +{ + LPDISPATCH result; + InvokeHelper(0x8be, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// UserAccessList properties + +///////////////////////////////////////////////////////////////////////////// +// UserAccessList operations + +long UserAccessList::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH UserAccessList::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH UserAccessList::Add(LPCTSTR Name, BOOL AllowEdit) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_BOOL; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Name, AllowEdit); + return result; +} + +void UserAccessList::DeleteAll() +{ + InvokeHelper(0x8bf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +LPDISPATCH UserAccessList::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN UserAccessList::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// UserAccess properties + +///////////////////////////////////////////////////////////////////////////// +// UserAccess operations + +CString UserAccess::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL UserAccess::GetAllowEdit() +{ + BOOL result; + InvokeHelper(0x7e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void UserAccess::SetAllowEdit(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x7e4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +void UserAccess::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// RTD properties + +///////////////////////////////////////////////////////////////////////////// +// RTD operations + +long RTD::GetThrottleInterval() +{ + long result; + InvokeHelper(0x8c0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void RTD::SetThrottleInterval(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8c0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void RTD::RefreshData() +{ + InvokeHelper(0x8c1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void RTD::RestartServers() +{ + InvokeHelper(0x8c2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// Diagram properties + +///////////////////////////////////////////////////////////////////////////// +// Diagram operations + +LPDISPATCH Diagram::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Diagram::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH Diagram::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH Diagram::GetNodes() +{ + LPDISPATCH result; + InvokeHelper(0x6a5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long Diagram::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long Diagram::GetAutoLayout() +{ + long result; + InvokeHelper(0x8c3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Diagram::SetAutoLayout(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8c3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Diagram::GetReverse() +{ + long result; + InvokeHelper(0x8c4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Diagram::SetReverse(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x8c4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +long Diagram::GetAutoFormat() +{ + long result; + InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void Diagram::SetAutoFormat(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +void Diagram::Convert(long Type) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x416, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Type); +} + +void Diagram::FitText() +{ + InvokeHelper(0x900, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + + +///////////////////////////////////////////////////////////////////////////// +// ListObjects properties + +///////////////////////////////////////////////////////////////////////////// +// ListObjects operations + +LPDISPATCH ListObjects::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListObjects::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObjects::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObjects::Add(long SourceType, const VARIANT& Source, const VARIANT& LinkSource, long XlListObjectHasHeaders, const VARIANT& Destination) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + SourceType, &Source, &LinkSource, XlListObjectHasHeaders, &Destination); + return result; +} + +LPDISPATCH ListObjects::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ListObjects::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObjects::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long ListObjects::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ListObject properties + +///////////////////////////////////////////////////////////////////////////// +// ListObject operations + +LPDISPATCH ListObject::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListObject::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ListObject::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString ListObject::Publish(const VARIANT& Target, BOOL LinkSource) +{ + CString result; + static BYTE parms[] = + VTS_VARIANT VTS_BOOL; + InvokeHelper(0x767, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms, + &Target, LinkSource); + return result; +} + +void ListObject::Refresh() +{ + InvokeHelper(0x589, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ListObject::Unlink() +{ + InvokeHelper(0x904, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ListObject::Unlist() +{ + InvokeHelper(0x905, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +void ListObject::UpdateChanges(long iConflictType) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x906, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + iConflictType); +} + +void ListObject::Resize(LPDISPATCH Range) +{ + static BYTE parms[] = + VTS_DISPATCH; + InvokeHelper(0x100, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Range); +} + +CString ListObject::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +BOOL ListObject::GetActive() +{ + BOOL result; + InvokeHelper(0x908, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetDataBodyRange() +{ + LPDISPATCH result; + InvokeHelper(0x2c1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ListObject::GetDisplayRightToLeft() +{ + BOOL result; + InvokeHelper(0x6ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetHeaderRowRange() +{ + LPDISPATCH result; + InvokeHelper(0x909, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetInsertRowRange() +{ + LPDISPATCH result; + InvokeHelper(0x90a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetListColumns() +{ + LPDISPATCH result; + InvokeHelper(0x90b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetListRows() +{ + LPDISPATCH result; + InvokeHelper(0x90c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString ListObject::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ListObject::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH ListObject::GetQueryTable() +{ + LPDISPATCH result; + InvokeHelper(0x56a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetRange() +{ + LPDISPATCH result; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +BOOL ListObject::GetShowAutoFilter() +{ + BOOL result; + InvokeHelper(0x90d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListObject::SetShowAutoFilter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x90d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL ListObject::GetShowTotals() +{ + BOOL result; + InvokeHelper(0x90e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void ListObject::SetShowTotals(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x90e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +long ListObject::GetSourceType() +{ + long result; + InvokeHelper(0x2ad, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetTotalsRowRange() +{ + LPDISPATCH result; + InvokeHelper(0x90f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString ListObject::GetSharePointURL() +{ + CString result; + InvokeHelper(0x910, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListObject::GetXmlMap() +{ + LPDISPATCH result; + InvokeHelper(0x8cd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ListColumns properties + +///////////////////////////////////////////////////////////////////////////// +// ListColumns operations + +LPDISPATCH ListColumns::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListColumns::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListColumns::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListColumns::Add(const VARIANT& Position) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Position); + return result; +} + +LPDISPATCH ListColumns::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ListColumns::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListColumns::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long ListColumns::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ListColumn properties + +///////////////////////////////////////////////////////////////////////////// +// ListColumn operations + +LPDISPATCH ListColumn::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListColumn::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListColumn::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ListColumn::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString ListColumn::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListColumn::GetListDataFormat() +{ + LPDISPATCH result; + InvokeHelper(0x911, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListColumn::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString ListColumn::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void ListColumn::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +LPDISPATCH ListColumn::GetRange() +{ + LPDISPATCH result; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListColumn::GetTotalsCalculation() +{ + long result; + InvokeHelper(0x912, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +void ListColumn::SetTotalsCalculation(long nNewValue) +{ + static BYTE parms[] = + VTS_I4; + InvokeHelper(0x912, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + nNewValue); +} + +LPDISPATCH ListColumn::GetXPath() +{ + LPDISPATCH result; + InvokeHelper(0x8d2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString ListColumn::GetSharePointFormula() +{ + CString result; + InvokeHelper(0x913, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ListRows properties + +///////////////////////////////////////////////////////////////////////////// +// ListRows operations + +LPDISPATCH ListRows::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListRows::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListRows::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListRows::Add(const VARIANT& Position) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + &Position); + return result; +} + +LPDISPATCH ListRows::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPUNKNOWN ListRows::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListRows::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long ListRows::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ListRow properties + +///////////////////////////////////////////////////////////////////////////// +// ListRow operations + +LPDISPATCH ListRow::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListRow::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListRow::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void ListRow::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long ListRow::GetIndex() +{ + long result; + InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL ListRow::GetInvalidData() +{ + BOOL result; + InvokeHelper(0x914, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListRow::GetRange() +{ + LPDISPATCH result; + InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// XmlNamespace properties + +///////////////////////////////////////////////////////////////////////////// +// XmlNamespace operations + +LPDISPATCH XmlNamespace::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long XmlNamespace::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlNamespace::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString XmlNamespace::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString XmlNamespace::GetUri() +{ + CString result; + InvokeHelper(0x915, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString XmlNamespace::GetPrefix() +{ + CString result; + InvokeHelper(0x916, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// XmlNamespaces properties + +///////////////////////////////////////////////////////////////////////////// +// XmlNamespaces operations + +LPDISPATCH XmlNamespaces::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long XmlNamespaces::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlNamespaces::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlNamespaces::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH XmlNamespaces::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long XmlNamespaces::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +CString XmlNamespaces::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPUNKNOWN XmlNamespaces::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + +void XmlNamespaces::InstallManifest(LPCTSTR Path, const VARIANT& InstallForAllUsers) +{ + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x917, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Path, &InstallForAllUsers); +} + + +///////////////////////////////////////////////////////////////////////////// +// XmlDataBinding properties + +///////////////////////////////////////////////////////////////////////////// +// XmlDataBinding operations + +LPDISPATCH XmlDataBinding::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long XmlDataBinding::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlDataBinding::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString XmlDataBinding::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +long XmlDataBinding::Refresh() +{ + long result; + InvokeHelper(0x589, DISPATCH_METHOD, VT_I4, (void*)&result, NULL); + return result; +} + +void XmlDataBinding::LoadSettings(LPCTSTR Url) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x919, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Url); +} + +void XmlDataBinding::ClearSettings() +{ + InvokeHelper(0x91a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +CString XmlDataBinding::GetSourceUrl() +{ + CString result; + InvokeHelper(0x91b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// XmlSchema properties + +///////////////////////////////////////////////////////////////////////////// +// XmlSchema operations + +LPDISPATCH XmlSchema::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long XmlSchema::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlSchema::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlSchema::GetNamespace() +{ + LPDISPATCH result; + InvokeHelper(0x91c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString XmlSchema::GetXml() +{ + CString result; + InvokeHelper(0x91d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString XmlSchema::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// XmlSchemas properties + +///////////////////////////////////////////////////////////////////////////// +// XmlSchemas operations + +LPDISPATCH XmlSchemas::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long XmlSchemas::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlSchemas::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlSchemas::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH XmlSchemas::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long XmlSchemas::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPUNKNOWN XmlSchemas::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// XmlMap properties + +///////////////////////////////////////////////////////////////////////////// +// XmlMap operations + +LPDISPATCH XmlMap::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long XmlMap::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlMap::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString XmlMap::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString XmlMap::GetName() +{ + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +void XmlMap::SetName(LPCTSTR lpszNewValue) +{ + static BYTE parms[] = + VTS_BSTR; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + lpszNewValue); +} + +BOOL XmlMap::GetIsExportable() +{ + BOOL result; + InvokeHelper(0x91e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL XmlMap::GetShowImportExportValidationErrors() +{ + BOOL result; + InvokeHelper(0x91f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void XmlMap::SetShowImportExportValidationErrors(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x91f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL XmlMap::GetSaveDataSourceDefinition() +{ + BOOL result; + InvokeHelper(0x920, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void XmlMap::SetSaveDataSourceDefinition(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x920, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL XmlMap::GetAdjustColumnWidth() +{ + BOOL result; + InvokeHelper(0x74c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void XmlMap::SetAdjustColumnWidth(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x74c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL XmlMap::GetPreserveColumnFilter() +{ + BOOL result; + InvokeHelper(0x921, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void XmlMap::SetPreserveColumnFilter(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x921, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL XmlMap::GetPreserveNumberFormatting() +{ + BOOL result; + InvokeHelper(0x922, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void XmlMap::SetPreserveNumberFormatting(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x922, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +BOOL XmlMap::GetAppendOnImport() +{ + BOOL result; + InvokeHelper(0x923, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +void XmlMap::SetAppendOnImport(BOOL bNewValue) +{ + static BYTE parms[] = + VTS_BOOL; + InvokeHelper(0x923, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, + bNewValue); +} + +CString XmlMap::GetRootElementName() +{ + CString result; + InvokeHelper(0x924, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlMap::GetRootElementNamespace() +{ + LPDISPATCH result; + InvokeHelper(0x925, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlMap::GetSchemas() +{ + LPDISPATCH result; + InvokeHelper(0x926, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlMap::GetDataBinding() +{ + LPDISPATCH result; + InvokeHelper(0x927, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void XmlMap::Delete() +{ + InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +long XmlMap::Import(LPCTSTR Url, const VARIANT& Overwrite) +{ + long result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x395, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + Url, &Overwrite); + return result; +} + +long XmlMap::ImportXml(LPCTSTR XmlData, const VARIANT& Overwrite) +{ + long result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x928, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + XmlData, &Overwrite); + return result; +} + +long XmlMap::Export(LPCTSTR Url, const VARIANT& Overwrite) +{ + long result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0x586, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + Url, &Overwrite); + return result; +} + +long XmlMap::ExportXml(BSTR* Data) +{ + long result; + static BYTE parms[] = + VTS_PBSTR; + InvokeHelper(0x92a, DISPATCH_METHOD, VT_I4, (void*)&result, parms, + Data); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// XmlMaps properties + +///////////////////////////////////////////////////////////////////////////// +// XmlMaps operations + +LPDISPATCH XmlMaps::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long XmlMaps::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlMaps::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +LPDISPATCH XmlMaps::Add(LPCTSTR Schema, const VARIANT& RootElementName) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_BSTR VTS_VARIANT; + InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, + Schema, &RootElementName); + return result; +} + +LPDISPATCH XmlMaps::Get_Default(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +LPDISPATCH XmlMaps::GetItem(const VARIANT& Index) +{ + LPDISPATCH result; + static BYTE parms[] = + VTS_VARIANT; + InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, + &Index); + return result; +} + +long XmlMaps::GetCount() +{ + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPUNKNOWN XmlMaps::Get_NewEnum() +{ + LPUNKNOWN result; + InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// ListDataFormat properties + +///////////////////////////////////////////////////////////////////////////// +// ListDataFormat operations + +LPDISPATCH ListDataFormat::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListDataFormat::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH ListDataFormat::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long ListDataFormat::Get_Default() +{ + long result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT ListDataFormat::GetChoices() +{ + VARIANT result; + InvokeHelper(0x92c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +long ListDataFormat::GetDecimalPlaces() +{ + long result; + InvokeHelper(0x92d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT ListDataFormat::GetDefaultValue() +{ + VARIANT result; + InvokeHelper(0x92e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL ListDataFormat::GetIsPercent() +{ + BOOL result; + InvokeHelper(0x92f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long ListDataFormat::GetLcid() +{ + long result; + InvokeHelper(0x930, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +long ListDataFormat::GetMaxCharacters() +{ + long result; + InvokeHelper(0x931, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +VARIANT ListDataFormat::GetMaxNumber() +{ + VARIANT result; + InvokeHelper(0x932, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +VARIANT ListDataFormat::GetMinNumber() +{ + VARIANT result; + InvokeHelper(0x933, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL); + return result; +} + +BOOL ListDataFormat::GetRequired() +{ + BOOL result; + InvokeHelper(0x934, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +long ListDataFormat::GetType() +{ + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +BOOL ListDataFormat::GetReadOnly() +{ + BOOL result; + InvokeHelper(0x128, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + +BOOL ListDataFormat::GetAllowFillIn() +{ + BOOL result; + InvokeHelper(0x935, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} + + +///////////////////////////////////////////////////////////////////////////// +// XPath properties + +///////////////////////////////////////////////////////////////////////////// +// XPath operations + +LPDISPATCH XPath::GetApplication() +{ + LPDISPATCH result; + InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +long XPath::GetCreator() +{ + long result; + InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; +} + +LPDISPATCH XPath::GetParent() +{ + LPDISPATCH result; + InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +CString XPath::Get_Default() +{ + CString result; + InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +CString XPath::GetValue() +{ + CString result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; +} + +LPDISPATCH XPath::GetMap() +{ + LPDISPATCH result; + InvokeHelper(0x8d6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; +} + +void XPath::SetValue(LPDISPATCH Map, LPCTSTR XPath, const VARIANT& SelectionNamespace, const VARIANT& Repeating) +{ + static BYTE parms[] = + VTS_DISPATCH VTS_BSTR VTS_VARIANT VTS_VARIANT; + InvokeHelper(0x936, DISPATCH_METHOD, VT_EMPTY, NULL, parms, + Map, XPath, &SelectionNamespace, &Repeating); +} + +void XPath::Clear() +{ + InvokeHelper(0x6f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); +} + +BOOL XPath::GetRepeating() +{ + BOOL result; + InvokeHelper(0x938, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; +} diff --git a/LaipuDrawing/excel.h b/LaipuDrawing/excel.h new file mode 100644 index 0000000..2ee0f20 --- /dev/null +++ b/LaipuDrawing/excel.h @@ -0,0 +1,11505 @@ +// Machine generated IDispatch wrapper class(es) created with ClassWizard +///////////////////////////////////////////////////////////////////////////// +// Adjustments wrapper class + + + +//´ +#if !defined _HEAD_FILE_EXCEL_ +#define _HEAD_FILE_EXCEL_ + +class Adjustments : public COleDispatchDriver +{ +public: + Adjustments() {} // Calls COleDispatchDriver default constructor + Adjustments(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Adjustments(const Adjustments& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + float GetItem(long Index); + void SetItem(long Index, float newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// CalloutFormat wrapper class + +class CalloutFormat : public COleDispatchDriver +{ +public: + CalloutFormat() {} // Calls COleDispatchDriver default constructor + CalloutFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CalloutFormat(const CalloutFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void AutomaticLength(); + void CustomDrop(float Drop); + void CustomLength(float Length); + void PresetDrop(long DropType); + long GetAccent(); + void SetAccent(long nNewValue); + long GetAngle(); + void SetAngle(long nNewValue); + long GetAutoAttach(); + void SetAutoAttach(long nNewValue); + long GetAutoLength(); + long GetBorder(); + void SetBorder(long nNewValue); + float GetDrop(); + long GetDropType(); + float GetGap(); + void SetGap(float newValue); + float GetLength(); + long GetType(); + void SetType(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ColorFormat wrapper class + +class ColorFormat : public COleDispatchDriver +{ +public: + ColorFormat() {} // Calls COleDispatchDriver default constructor + ColorFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ColorFormat(const ColorFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetRgb(); + void SetRgb(long nNewValue); + long GetSchemeColor(); + void SetSchemeColor(long nNewValue); + long GetType(); + float GetTintAndShade(); + void SetTintAndShade(float newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// LineFormat wrapper class + +class LineFormat : public COleDispatchDriver +{ +public: + LineFormat() {} // Calls COleDispatchDriver default constructor + LineFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + LineFormat(const LineFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBackColor(); + void SetBackColor(LPDISPATCH newValue); + long GetBeginArrowheadLength(); + void SetBeginArrowheadLength(long nNewValue); + long GetBeginArrowheadStyle(); + void SetBeginArrowheadStyle(long nNewValue); + long GetBeginArrowheadWidth(); + void SetBeginArrowheadWidth(long nNewValue); + long GetDashStyle(); + void SetDashStyle(long nNewValue); + long GetEndArrowheadLength(); + void SetEndArrowheadLength(long nNewValue); + long GetEndArrowheadStyle(); + void SetEndArrowheadStyle(long nNewValue); + long GetEndArrowheadWidth(); + void SetEndArrowheadWidth(long nNewValue); + LPDISPATCH GetForeColor(); + void SetForeColor(LPDISPATCH newValue); + long GetPattern(); + void SetPattern(long nNewValue); + long GetStyle(); + void SetStyle(long nNewValue); + float GetTransparency(); + void SetTransparency(float newValue); + long GetVisible(); + void SetVisible(long nNewValue); + float GetWeight(); + void SetWeight(float newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ShapeNode wrapper class + +class ShapeNode : public COleDispatchDriver +{ +public: + ShapeNode() {} // Calls COleDispatchDriver default constructor + ShapeNode(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ShapeNode(const ShapeNode& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetEditingType(); + VARIANT GetPoints(); + long GetSegmentType(); +}; +///////////////////////////////////////////////////////////////////////////// +// ShapeNodes wrapper class + +class ShapeNodes : public COleDispatchDriver +{ +public: + ShapeNodes() {} // Calls COleDispatchDriver default constructor + ShapeNodes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ShapeNodes(const ShapeNodes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + void Delete(long Index); + void Insert(long Index, long SegmentType, long EditingType, float X1, float Y1, float X2, float Y2, float X3, float Y3); + void SetEditingType(long Index, long EditingType); + void SetPosition(long Index, float X1, float Y1); + void SetSegmentType(long Index, long SegmentType); +}; +///////////////////////////////////////////////////////////////////////////// +// PictureFormat wrapper class + +class PictureFormat : public COleDispatchDriver +{ +public: + PictureFormat() {} // Calls COleDispatchDriver default constructor + PictureFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PictureFormat(const PictureFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void IncrementBrightness(float Increment); + void IncrementContrast(float Increment); + float GetBrightness(); + void SetBrightness(float newValue); + long GetColorType(); + void SetColorType(long nNewValue); + float GetContrast(); + void SetContrast(float newValue); + float GetCropBottom(); + void SetCropBottom(float newValue); + float GetCropLeft(); + void SetCropLeft(float newValue); + float GetCropRight(); + void SetCropRight(float newValue); + float GetCropTop(); + void SetCropTop(float newValue); + long GetTransparencyColor(); + void SetTransparencyColor(long nNewValue); + long GetTransparentBackground(); + void SetTransparentBackground(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ShadowFormat wrapper class + +class ShadowFormat : public COleDispatchDriver +{ +public: + ShadowFormat() {} // Calls COleDispatchDriver default constructor + ShadowFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ShadowFormat(const ShadowFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void IncrementOffsetX(float Increment); + void IncrementOffsetY(float Increment); + LPDISPATCH GetForeColor(); + void SetForeColor(LPDISPATCH newValue); + long GetObscured(); + void SetObscured(long nNewValue); + float GetOffsetX(); + void SetOffsetX(float newValue); + float GetOffsetY(); + void SetOffsetY(float newValue); + float GetTransparency(); + void SetTransparency(float newValue); + long GetType(); + void SetType(long nNewValue); + long GetVisible(); + void SetVisible(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// TextEffectFormat wrapper class + +class TextEffectFormat : public COleDispatchDriver +{ +public: + TextEffectFormat() {} // Calls COleDispatchDriver default constructor + TextEffectFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + TextEffectFormat(const TextEffectFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void ToggleVerticalText(); + long GetAlignment(); + void SetAlignment(long nNewValue); + long GetFontBold(); + void SetFontBold(long nNewValue); + long GetFontItalic(); + void SetFontItalic(long nNewValue); + CString GetFontName(); + void SetFontName(LPCTSTR lpszNewValue); + float GetFontSize(); + void SetFontSize(float newValue); + long GetKernedPairs(); + void SetKernedPairs(long nNewValue); + long GetNormalizedHeight(); + void SetNormalizedHeight(long nNewValue); + long GetPresetShape(); + void SetPresetShape(long nNewValue); + long GetPresetTextEffect(); + void SetPresetTextEffect(long nNewValue); + long GetRotatedChars(); + void SetRotatedChars(long nNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + float GetTracking(); + void SetTracking(float newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ThreeDFormat wrapper class + +class ThreeDFormat : public COleDispatchDriver +{ +public: + ThreeDFormat() {} // Calls COleDispatchDriver default constructor + ThreeDFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ThreeDFormat(const ThreeDFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void IncrementRotationX(float Increment); + void IncrementRotationY(float Increment); + void ResetRotation(); + void SetThreeDFormat(long PresetThreeDFormat); + void SetExtrusionDirection(long PresetExtrusionDirection); + float GetDepth(); + void SetDepth(float newValue); + LPDISPATCH GetExtrusionColor(); + long GetExtrusionColorType(); + void SetExtrusionColorType(long nNewValue); + long GetPerspective(); + void SetPerspective(long nNewValue); + long GetPresetExtrusionDirection(); + long GetPresetLightingDirection(); + void SetPresetLightingDirection(long nNewValue); + long GetPresetLightingSoftness(); + void SetPresetLightingSoftness(long nNewValue); + long GetPresetMaterial(); + void SetPresetMaterial(long nNewValue); + long GetPresetThreeDFormat(); + float GetRotationX(); + void SetRotationX(float newValue); + float GetRotationY(); + void SetRotationY(float newValue); + long GetVisible(); + void SetVisible(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// FillFormat wrapper class + +class FillFormat : public COleDispatchDriver +{ +public: + FillFormat() {} // Calls COleDispatchDriver default constructor + FillFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + FillFormat(const FillFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void OneColorGradient(long Style, long Variant, float Degree); + void Patterned(long Pattern); + void PresetGradient(long Style, long Variant, long PresetGradientType); + void PresetTextured(long PresetTexture); + void Solid(); + void TwoColorGradient(long Style, long Variant); + void UserPicture(LPCTSTR PictureFile); + void UserTextured(LPCTSTR TextureFile); + LPDISPATCH GetBackColor(); + void SetBackColor(LPDISPATCH newValue); + LPDISPATCH GetForeColor(); + void SetForeColor(LPDISPATCH newValue); + long GetGradientColorType(); + float GetGradientDegree(); + long GetGradientStyle(); + long GetGradientVariant(); + long GetPattern(); + long GetPresetGradientType(); + long GetPresetTexture(); + CString GetTextureName(); + long GetTextureType(); + float GetTransparency(); + void SetTransparency(float newValue); + long GetType(); + long GetVisible(); + void SetVisible(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// DiagramNodes wrapper class + +class DiagramNodes : public COleDispatchDriver +{ +public: + DiagramNodes() {} // Calls COleDispatchDriver default constructor + DiagramNodes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DiagramNodes(const DiagramNodes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Item(const VARIANT& Index); + void SelectAll(); + LPDISPATCH GetParent(); + long GetCount(); +}; +///////////////////////////////////////////////////////////////////////////// +// DiagramNodeChildren wrapper class + +class DiagramNodeChildren : public COleDispatchDriver +{ +public: + DiagramNodeChildren() {} // Calls COleDispatchDriver default constructor + DiagramNodeChildren(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DiagramNodeChildren(const DiagramNodeChildren& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH AddNode(const VARIANT& Index, long nodeType); + void SelectAll(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetFirstChild(); + LPDISPATCH GetLastChild(); +}; +///////////////////////////////////////////////////////////////////////////// +// DiagramNode wrapper class + +class DiagramNode : public COleDispatchDriver +{ +public: + DiagramNode() {} // Calls COleDispatchDriver default constructor + DiagramNode(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DiagramNode(const DiagramNode& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH AddNode(long pos, long nodeType); + void Delete(); + void MoveNode(LPDISPATCH pTargetNode, long pos); + void ReplaceNode(LPDISPATCH pTargetNode); + void SwapNode(LPDISPATCH pTargetNode, BOOL swapChildren); + LPDISPATCH CloneNode(BOOL copyChildren, LPDISPATCH pTargetNode, long pos); + void TransferChildren(LPDISPATCH pReceivingNode); + LPDISPATCH NextNode(); + LPDISPATCH PrevNode(); + LPDISPATCH GetParent(); + LPDISPATCH GetChildren(); + LPDISPATCH GetShape(); + LPDISPATCH GetRoot(); + LPDISPATCH GetDiagram(); + long GetLayout(); + void SetLayout(long nNewValue); + LPDISPATCH GetTextShape(); +}; +///////////////////////////////////////////////////////////////////////////// +// IRTDUpdateEvent wrapper class + +class IRTDUpdateEvent : public COleDispatchDriver +{ +public: + IRTDUpdateEvent() {} // Calls COleDispatchDriver default constructor + IRTDUpdateEvent(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + IRTDUpdateEvent(const IRTDUpdateEvent& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + void UpdateNotify(); + long GetHeartbeatInterval(); + void SetHeartbeatInterval(long nNewValue); + void Disconnect(); +}; +///////////////////////////////////////////////////////////////////////////// +// IRtdServer wrapper class + +class IRtdServer : public COleDispatchDriver +{ +public: + IRtdServer() {} // Calls COleDispatchDriver default constructor + IRtdServer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + IRtdServer(const IRtdServer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + long ServerStart(LPDISPATCH CallbackObject); + // method 'ConnectData' not emitted because of invalid return type or parameter type + // method 'RefreshData' not emitted because of invalid return type or parameter type + void DisconnectData(long TopicID); + long Heartbeat(); + void ServerTerminate(); +}; +///////////////////////////////////////////////////////////////////////////// +// _Application wrapper class + +class _Application : public COleDispatchDriver +{ +public: + _Application() {} // Calls COleDispatchDriver default constructor + _Application(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + _Application(const _Application& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetActiveCell(); + LPDISPATCH GetActiveChart(); + CString GetActivePrinter(); + void SetActivePrinter(LPCTSTR lpszNewValue); + LPDISPATCH GetActiveSheet(); + LPDISPATCH GetActiveWindow(); + LPDISPATCH GetActiveWorkbook(); + LPDISPATCH GetAddIns(); + LPDISPATCH GetAssistant(); + void Calculate(); + LPDISPATCH GetCells(); + LPDISPATCH GetCharts(); + LPDISPATCH GetColumns(); + LPDISPATCH GetCommandBars(); + long GetDDEAppReturnCode(); + void DDEExecute(long Channel, LPCTSTR String); + long DDEInitiate(LPCTSTR App, LPCTSTR Topic); + void DDEPoke(long Channel, const VARIANT& Item, const VARIANT& Data); + VARIANT DDERequest(long Channel, LPCTSTR Item); + void DDETerminate(long Channel); + VARIANT Evaluate(const VARIANT& Name); + VARIANT _Evaluate(const VARIANT& Name); + VARIANT ExecuteExcel4Macro(LPCTSTR String); + LPDISPATCH Intersect(LPDISPATCH Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + LPDISPATCH GetNames(); + LPDISPATCH GetRange(const VARIANT& Cell1, const VARIANT& Cell2); + LPDISPATCH GetRows(); + VARIANT Run(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, + const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, + const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, + const VARIANT& Arg30); + VARIANT _Run2(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, + const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, + const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, + const VARIANT& Arg30); + LPDISPATCH GetSelection(); + void SendKeys(const VARIANT& Keys, const VARIANT& Wait); + LPDISPATCH GetSheets(); + LPDISPATCH GetThisWorkbook(); + LPDISPATCH Union(LPDISPATCH Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + LPDISPATCH GetWindows(); + LPDISPATCH GetWorkbooks(); + LPDISPATCH GetWorksheetFunction(); + LPDISPATCH GetWorksheets(); + LPDISPATCH GetExcel4IntlMacroSheets(); + LPDISPATCH GetExcel4MacroSheets(); + void ActivateMicrosoftApp(long Index); + void AddChartAutoFormat(const VARIANT& Chart, LPCTSTR Name, const VARIANT& Description); + void AddCustomList(const VARIANT& ListArray, const VARIANT& ByRow); + BOOL GetAlertBeforeOverwriting(); + void SetAlertBeforeOverwriting(BOOL bNewValue); + CString GetAltStartupPath(); + void SetAltStartupPath(LPCTSTR lpszNewValue); + BOOL GetAskToUpdateLinks(); + void SetAskToUpdateLinks(BOOL bNewValue); + BOOL GetEnableAnimations(); + void SetEnableAnimations(BOOL bNewValue); + LPDISPATCH GetAutoCorrect(); + long GetBuild(); + BOOL GetCalculateBeforeSave(); + void SetCalculateBeforeSave(BOOL bNewValue); + long GetCalculation(); + void SetCalculation(long nNewValue); + VARIANT GetCaller(const VARIANT& Index); + BOOL GetCanPlaySounds(); + BOOL GetCanRecordSounds(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + BOOL GetCellDragAndDrop(); + void SetCellDragAndDrop(BOOL bNewValue); + double CentimetersToPoints(double Centimeters); + BOOL CheckSpelling(LPCTSTR Word, const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase); + VARIANT GetClipboardFormats(const VARIANT& Index); + BOOL GetDisplayClipboardWindow(); + void SetDisplayClipboardWindow(BOOL bNewValue); + long GetCommandUnderlines(); + void SetCommandUnderlines(long nNewValue); + BOOL GetConstrainNumeric(); + void SetConstrainNumeric(BOOL bNewValue); + VARIANT ConvertFormula(const VARIANT& Formula, long FromReferenceStyle, const VARIANT& ToReferenceStyle, const VARIANT& ToAbsolute, const VARIANT& RelativeTo); + BOOL GetCopyObjectsWithCells(); + void SetCopyObjectsWithCells(BOOL bNewValue); + long GetCursor(); + void SetCursor(long nNewValue); + long GetCustomListCount(); + long GetCutCopyMode(); + void SetCutCopyMode(long nNewValue); + long GetDataEntryMode(); + void SetDataEntryMode(long nNewValue); + CString Get_Default(); + CString GetDefaultFilePath(); + void SetDefaultFilePath(LPCTSTR lpszNewValue); + void DeleteChartAutoFormat(LPCTSTR Name); + void DeleteCustomList(long ListNum); + LPDISPATCH GetDialogs(); + BOOL GetDisplayAlerts(); + void SetDisplayAlerts(BOOL bNewValue); + BOOL GetDisplayFormulaBar(); + void SetDisplayFormulaBar(BOOL bNewValue); + BOOL GetDisplayFullScreen(); + void SetDisplayFullScreen(BOOL bNewValue); + BOOL GetDisplayNoteIndicator(); + void SetDisplayNoteIndicator(BOOL bNewValue); + long GetDisplayCommentIndicator(); + void SetDisplayCommentIndicator(long nNewValue); + BOOL GetDisplayExcel4Menus(); + void SetDisplayExcel4Menus(BOOL bNewValue); + BOOL GetDisplayRecentFiles(); + void SetDisplayRecentFiles(BOOL bNewValue); + BOOL GetDisplayScrollBars(); + void SetDisplayScrollBars(BOOL bNewValue); + BOOL GetDisplayStatusBar(); + void SetDisplayStatusBar(BOOL bNewValue); + void DoubleClick(); + BOOL GetEditDirectlyInCell(); + void SetEditDirectlyInCell(BOOL bNewValue); + BOOL GetEnableAutoComplete(); + void SetEnableAutoComplete(BOOL bNewValue); + long GetEnableCancelKey(); + void SetEnableCancelKey(long nNewValue); + BOOL GetEnableSound(); + void SetEnableSound(BOOL bNewValue); + VARIANT GetFileConverters(const VARIANT& Index1, const VARIANT& Index2); + LPDISPATCH GetFileSearch(); + LPDISPATCH GetFileFind(); + BOOL GetFixedDecimal(); + void SetFixedDecimal(BOOL bNewValue); + long GetFixedDecimalPlaces(); + void SetFixedDecimalPlaces(long nNewValue); + VARIANT GetCustomListContents(long ListNum); + long GetCustomListNum(const VARIANT& ListArray); + VARIANT GetOpenFilename(const VARIANT& FileFilter, const VARIANT& FilterIndex, const VARIANT& Title, const VARIANT& ButtonText, const VARIANT& MultiSelect); + VARIANT GetSaveAsFilename(const VARIANT& InitialFilename, const VARIANT& FileFilter, const VARIANT& FilterIndex, const VARIANT& Title, const VARIANT& ButtonText); + void Goto(const VARIANT& Reference, const VARIANT& Scroll); + double GetHeight(); + void SetHeight(double newValue); + void Help(const VARIANT& HelpFile, const VARIANT& HelpContextID); + BOOL GetIgnoreRemoteRequests(); + void SetIgnoreRemoteRequests(BOOL bNewValue); + double InchesToPoints(double Inches); + VARIANT InputBox(LPCTSTR Prompt, const VARIANT& Title, const VARIANT& Default, const VARIANT& Left, const VARIANT& Top, const VARIANT& HelpFile, const VARIANT& HelpContextID, const VARIANT& Type); + BOOL GetInteractive(); + void SetInteractive(BOOL bNewValue); + VARIANT GetInternational(const VARIANT& Index); + BOOL GetIteration(); + void SetIteration(BOOL bNewValue); + double GetLeft(); + void SetLeft(double newValue); + CString GetLibraryPath(); + void MacroOptions(const VARIANT& Macro, const VARIANT& Description, const VARIANT& HasMenu, const VARIANT& MenuText, const VARIANT& HasShortcutKey, const VARIANT& ShortcutKey, const VARIANT& Category, const VARIANT& StatusBar, + const VARIANT& HelpContextID, const VARIANT& HelpFile); + void MailLogoff(); + void MailLogon(const VARIANT& Name, const VARIANT& Password, const VARIANT& DownloadNewMail); + VARIANT GetMailSession(); + long GetMailSystem(); + BOOL GetMathCoprocessorAvailable(); + double GetMaxChange(); + void SetMaxChange(double newValue); + long GetMaxIterations(); + void SetMaxIterations(long nNewValue); + BOOL GetMouseAvailable(); + BOOL GetMoveAfterReturn(); + void SetMoveAfterReturn(BOOL bNewValue); + long GetMoveAfterReturnDirection(); + void SetMoveAfterReturnDirection(long nNewValue); + LPDISPATCH GetRecentFiles(); + CString GetName(); + LPDISPATCH NextLetter(); + CString GetNetworkTemplatesPath(); + LPDISPATCH GetODBCErrors(); + long GetODBCTimeout(); + void SetODBCTimeout(long nNewValue); + void OnKey(LPCTSTR Key, const VARIANT& Procedure); + void OnRepeat(LPCTSTR Text, LPCTSTR Procedure); + void OnTime(const VARIANT& EarliestTime, LPCTSTR Procedure, const VARIANT& LatestTime, const VARIANT& Schedule); + void OnUndo(LPCTSTR Text, LPCTSTR Procedure); + CString GetOnWindow(); + void SetOnWindow(LPCTSTR lpszNewValue); + CString GetOperatingSystem(); + CString GetOrganizationName(); + CString GetPath(); + CString GetPathSeparator(); + VARIANT GetPreviousSelections(const VARIANT& Index); + BOOL GetPivotTableSelection(); + void SetPivotTableSelection(BOOL bNewValue); + BOOL GetPromptForSummaryInfo(); + void SetPromptForSummaryInfo(BOOL bNewValue); + void Quit(); + void RecordMacro(const VARIANT& BasicCode, const VARIANT& XlmCode); + BOOL GetRecordRelative(); + long GetReferenceStyle(); + void SetReferenceStyle(long nNewValue); + VARIANT GetRegisteredFunctions(const VARIANT& Index1, const VARIANT& Index2); + BOOL RegisterXLL(LPCTSTR Filename); + void Repeat(); + BOOL GetRollZoom(); + void SetRollZoom(BOOL bNewValue); + void SaveWorkspace(const VARIANT& Filename); + BOOL GetScreenUpdating(); + void SetScreenUpdating(BOOL bNewValue); + void SetDefaultChart(const VARIANT& FormatName, const VARIANT& Gallery); + long GetSheetsInNewWorkbook(); + void SetSheetsInNewWorkbook(long nNewValue); + BOOL GetShowChartTipNames(); + void SetShowChartTipNames(BOOL bNewValue); + BOOL GetShowChartTipValues(); + void SetShowChartTipValues(BOOL bNewValue); + CString GetStandardFont(); + void SetStandardFont(LPCTSTR lpszNewValue); + double GetStandardFontSize(); + void SetStandardFontSize(double newValue); + CString GetStartupPath(); + VARIANT GetStatusBar(); + void SetStatusBar(const VARIANT& newValue); + CString GetTemplatesPath(); + BOOL GetShowToolTips(); + void SetShowToolTips(BOOL bNewValue); + double GetTop(); + void SetTop(double newValue); + long GetDefaultSaveFormat(); + void SetDefaultSaveFormat(long nNewValue); + CString GetTransitionMenuKey(); + void SetTransitionMenuKey(LPCTSTR lpszNewValue); + long GetTransitionMenuKeyAction(); + void SetTransitionMenuKeyAction(long nNewValue); + BOOL GetTransitionNavigKeys(); + void SetTransitionNavigKeys(BOOL bNewValue); + void Undo(); + double GetUsableHeight(); + double GetUsableWidth(); + BOOL GetUserControl(); + void SetUserControl(BOOL bNewValue); + CString GetUserName_(); + void SetUserName(LPCTSTR lpszNewValue); + CString GetValue(); + LPDISPATCH GetVbe(); + CString GetVersion(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + void Volatile(const VARIANT& Volatile); + double GetWidth(); + void SetWidth(double newValue); + BOOL GetWindowsForPens(); + long GetWindowState(); + void SetWindowState(long nNewValue); + long GetDefaultSheetDirection(); + void SetDefaultSheetDirection(long nNewValue); + long GetCursorMovement(); + void SetCursorMovement(long nNewValue); + BOOL GetControlCharacters(); + void SetControlCharacters(BOOL bNewValue); + BOOL GetEnableEvents(); + void SetEnableEvents(BOOL bNewValue); + BOOL Wait(const VARIANT& Time); + BOOL GetExtendList(); + void SetExtendList(BOOL bNewValue); + LPDISPATCH GetOLEDBErrors(); + CString GetPhonetic(const VARIANT& Text); + LPDISPATCH GetCOMAddIns(); + LPDISPATCH GetDefaultWebOptions(); + CString GetProductCode(); + CString GetUserLibraryPath(); + BOOL GetAutoPercentEntry(); + void SetAutoPercentEntry(BOOL bNewValue); + LPDISPATCH GetLanguageSettings(); + LPDISPATCH GetAnswerWizard(); + void CalculateFull(); + BOOL FindFile(); + long GetCalculationVersion(); + BOOL GetShowWindowsInTaskbar(); + void SetShowWindowsInTaskbar(BOOL bNewValue); + long GetFeatureInstall(); + void SetFeatureInstall(long nNewValue); + BOOL GetReady(); + LPDISPATCH GetFindFormat(); + void SetRefFindFormat(LPDISPATCH newValue); + LPDISPATCH GetReplaceFormat(); + void SetRefReplaceFormat(LPDISPATCH newValue); + LPDISPATCH GetUsedObjects(); + long GetCalculationState(); + long GetCalculationInterruptKey(); + void SetCalculationInterruptKey(long nNewValue); + LPDISPATCH GetWatches(); + BOOL GetDisplayFunctionToolTips(); + void SetDisplayFunctionToolTips(BOOL bNewValue); + long GetAutomationSecurity(); + void SetAutomationSecurity(long nNewValue); + LPDISPATCH GetFileDialog(long fileDialogType); + void CalculateFullRebuild(); + BOOL GetDisplayPasteOptions(); + void SetDisplayPasteOptions(BOOL bNewValue); + BOOL GetDisplayInsertOptions(); + void SetDisplayInsertOptions(BOOL bNewValue); + BOOL GetGenerateGetPivotData(); + void SetGenerateGetPivotData(BOOL bNewValue); + LPDISPATCH GetAutoRecover(); + long GetHwnd(); + long GetHinstance(); + void CheckAbort(const VARIANT& KeepAbort); + LPDISPATCH GetErrorCheckingOptions(); + BOOL GetAutoFormatAsYouTypeReplaceHyperlinks(); + void SetAutoFormatAsYouTypeReplaceHyperlinks(BOOL bNewValue); + LPDISPATCH GetSmartTagRecognizers(); + LPDISPATCH GetNewWorkbook(); + LPDISPATCH GetSpellingOptions(); + LPDISPATCH GetSpeech(); + BOOL GetMapPaperSize(); + void SetMapPaperSize(BOOL bNewValue); + BOOL GetShowStartupDialog(); + void SetShowStartupDialog(BOOL bNewValue); + CString GetDecimalSeparator(); + void SetDecimalSeparator(LPCTSTR lpszNewValue); + CString GetThousandsSeparator(); + void SetThousandsSeparator(LPCTSTR lpszNewValue); + BOOL GetUseSystemSeparators(); + void SetUseSystemSeparators(BOOL bNewValue); + LPDISPATCH GetThisCell(); + LPDISPATCH GetRtd(); + BOOL GetDisplayDocumentActionTaskPane(); + void SetDisplayDocumentActionTaskPane(BOOL bNewValue); + void DisplayXMLSourcePane(const VARIANT& XmlMap); + BOOL GetArbitraryXMLSupportAvailable(); +}; +///////////////////////////////////////////////////////////////////////////// +// _Chart wrapper class + +class _Chart : public COleDispatchDriver +{ +public: + _Chart() {} // Calls COleDispatchDriver default constructor + _Chart(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + _Chart(const _Chart& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Activate(); + void Copy(const VARIANT& Before, const VARIANT& After); + void Delete(); + CString GetCodeName(); + CString Get_CodeName(); + void Set_CodeName(LPCTSTR lpszNewValue); + long GetIndex(); + void Move(const VARIANT& Before, const VARIANT& After); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetNext(); + LPDISPATCH GetPageSetup(); + LPDISPATCH GetPrevious(); + void PrintPreview(const VARIANT& EnableChanges); + BOOL GetProtectContents(); + BOOL GetProtectDrawingObjects(); + BOOL GetProtectionMode(); + void Select(const VARIANT& Replace); + void Unprotect(const VARIANT& Password); + long GetVisible(); + void SetVisible(long nNewValue); + LPDISPATCH GetShapes(); + LPDISPATCH GetArea3DGroup(); + LPDISPATCH AreaGroups(const VARIANT& Index); + BOOL GetAutoScaling(); + void SetAutoScaling(BOOL bNewValue); + LPDISPATCH Axes(const VARIANT& Type, long AxisGroup); + void SetBackgroundPicture(LPCTSTR Filename); + LPDISPATCH GetBar3DGroup(); + LPDISPATCH BarGroups(const VARIANT& Index); + LPDISPATCH GetChartArea(); + LPDISPATCH ChartGroups(const VARIANT& Index); + LPDISPATCH ChartObjects(const VARIANT& Index); + LPDISPATCH GetChartTitle(); + void ChartWizard(const VARIANT& Source, const VARIANT& Gallery, const VARIANT& Format, const VARIANT& PlotBy, const VARIANT& CategoryLabels, const VARIANT& SeriesLabels, const VARIANT& HasLegend, const VARIANT& Title, + const VARIANT& CategoryTitle, const VARIANT& ValueTitle, const VARIANT& ExtraTitle); + void CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetColumn3DGroup(); + LPDISPATCH ColumnGroups(const VARIANT& Index); + void CopyPicture(long Appearance, long Format, long Size); + LPDISPATCH GetCorners(); + void CreatePublisher(const VARIANT& Edition, long Appearance, long Size, const VARIANT& ContainsPICT, const VARIANT& ContainsBIFF, const VARIANT& ContainsRTF, const VARIANT& ContainsVALU); + LPDISPATCH GetDataTable(); + long GetDepthPercent(); + void SetDepthPercent(long nNewValue); + void Deselect(); + long GetDisplayBlanksAs(); + void SetDisplayBlanksAs(long nNewValue); + LPDISPATCH DoughnutGroups(const VARIANT& Index); + long GetElevation(); + void SetElevation(long nNewValue); + VARIANT Evaluate(const VARIANT& Name); + VARIANT _Evaluate(const VARIANT& Name); + LPDISPATCH GetFloor(); + long GetGapDepth(); + void SetGapDepth(long nNewValue); + VARIANT GetHasAxis(const VARIANT& Index1, const VARIANT& Index2); + void SetHasAxis(const VARIANT& Index1, const VARIANT& Index2, const VARIANT& newValue); + BOOL GetHasDataTable(); + void SetHasDataTable(BOOL bNewValue); + BOOL GetHasLegend(); + void SetHasLegend(BOOL bNewValue); + BOOL GetHasTitle(); + void SetHasTitle(BOOL bNewValue); + long GetHeightPercent(); + void SetHeightPercent(long nNewValue); + LPDISPATCH GetHyperlinks(); + LPDISPATCH GetLegend(); + LPDISPATCH GetLine3DGroup(); + LPDISPATCH LineGroups(const VARIANT& Index); + LPDISPATCH Location(long Where, const VARIANT& Name); + LPDISPATCH OLEObjects(const VARIANT& Index); + void Paste(const VARIANT& Type); + long GetPerspective(); + void SetPerspective(long nNewValue); + LPDISPATCH GetPie3DGroup(); + LPDISPATCH PieGroups(const VARIANT& Index); + LPDISPATCH GetPlotArea(); + BOOL GetPlotVisibleOnly(); + void SetPlotVisibleOnly(BOOL bNewValue); + LPDISPATCH RadarGroups(const VARIANT& Index); + VARIANT GetRightAngleAxes(); + void SetRightAngleAxes(const VARIANT& newValue); + VARIANT GetRotation(); + void SetRotation(const VARIANT& newValue); + LPDISPATCH SeriesCollection(const VARIANT& Index); + BOOL GetSizeWithWindow(); + void SetSizeWithWindow(BOOL bNewValue); + BOOL GetShowWindow(); + void SetShowWindow(BOOL bNewValue); + LPDISPATCH GetSurfaceGroup(); + long GetChartType(); + void SetChartType(long nNewValue); + void ApplyCustomType(long ChartType, const VARIANT& TypeName); + LPDISPATCH GetWalls(); + BOOL GetWallsAndGridlines2D(); + void SetWallsAndGridlines2D(BOOL bNewValue); + LPDISPATCH XYGroups(const VARIANT& Index); + long GetBarShape(); + void SetBarShape(long nNewValue); + long GetPlotBy(); + void SetPlotBy(long nNewValue); + BOOL GetProtectFormatting(); + void SetProtectFormatting(BOOL bNewValue); + BOOL GetProtectData(); + void SetProtectData(BOOL bNewValue); + BOOL GetProtectGoalSeek(); + void SetProtectGoalSeek(BOOL bNewValue); + BOOL GetProtectSelection(); + void SetProtectSelection(BOOL bNewValue); + void GetChartElement(long x, long y, long* ElementID, long* Arg1, long* Arg2); + void SetSourceData(LPDISPATCH Source, const VARIANT& PlotBy); + BOOL Export(LPCTSTR Filename, const VARIANT& FilterName, const VARIANT& Interactive); + void Refresh(); + LPDISPATCH GetPivotLayout(); + BOOL GetHasPivotFields(); + void SetHasPivotFields(BOOL bNewValue); + LPDISPATCH GetScripts(); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); + LPDISPATCH GetTab(); + LPDISPATCH GetMailEnvelope(); + void ApplyDataLabels(long Type, const VARIANT& LegendKey, const VARIANT& AutoText, const VARIANT& HasLeaderLines, const VARIANT& ShowSeriesName, const VARIANT& ShowCategoryName, const VARIANT& ShowValue, const VARIANT& ShowPercentage, + const VARIANT& ShowBubbleSize, const VARIANT& Separator); + void SaveAs(LPCTSTR Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AddToMru, const VARIANT& TextCodepage, + const VARIANT& TextVisualLayout, const VARIANT& Local); + void Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly); +}; +///////////////////////////////////////////////////////////////////////////// +// Sheets wrapper class + +class Sheets : public COleDispatchDriver +{ +public: + Sheets() {} // Calls COleDispatchDriver default constructor + Sheets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Sheets(const Sheets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count, const VARIANT& Type); + void Copy(const VARIANT& Before, const VARIANT& After); + long GetCount(); + void Delete(); + void FillAcrossSheets(LPDISPATCH Range, long Type); + LPDISPATCH GetItem(const VARIANT& Index); + void Move(const VARIANT& Before, const VARIANT& After); + LPUNKNOWN Get_NewEnum(); + void PrintPreview(const VARIANT& EnableChanges); + void Select(const VARIANT& Replace); + LPDISPATCH GetHPageBreaks(); + LPDISPATCH GetVPageBreaks(); + VARIANT GetVisible(); + void SetVisible(const VARIANT& newValue); + LPDISPATCH Get_Default(const VARIANT& Index); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); +}; +///////////////////////////////////////////////////////////////////////////// +// _Worksheet wrapper class + +class _Worksheet : public COleDispatchDriver +{ +public: + _Worksheet() {} // Calls COleDispatchDriver default constructor + _Worksheet(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + _Worksheet(const _Worksheet& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Activate(); + void Copy(const VARIANT& Before, const VARIANT& After); + void Delete(); + CString GetCodeName(); + CString Get_CodeName(); + void Set_CodeName(LPCTSTR lpszNewValue); + long GetIndex(); + void Move(const VARIANT& Before, const VARIANT& After); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetNext(); + LPDISPATCH GetPageSetup(); + LPDISPATCH GetPrevious(); + void PrintPreview(const VARIANT& EnableChanges); + BOOL GetProtectContents(); + BOOL GetProtectDrawingObjects(); + BOOL GetProtectionMode(); + BOOL GetProtectScenarios(); + void Select(const VARIANT& Replace); + void Unprotect(const VARIANT& Password); + long GetVisible(); + void SetVisible(long nNewValue); + LPDISPATCH GetShapes(); + BOOL GetTransitionExpEval(); + void SetTransitionExpEval(BOOL bNewValue); + BOOL GetAutoFilterMode(); + void SetAutoFilterMode(BOOL bNewValue); + void SetBackgroundPicture(LPCTSTR Filename); + void Calculate(); + BOOL GetEnableCalculation(); + void SetEnableCalculation(BOOL bNewValue); + LPDISPATCH GetCells(); + LPDISPATCH ChartObjects(const VARIANT& Index); + void CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetCircularReference(); + void ClearArrows(); + LPDISPATCH GetColumns(); + long GetConsolidationFunction(); + VARIANT GetConsolidationOptions(); + VARIANT GetConsolidationSources(); + BOOL GetEnableAutoFilter(); + void SetEnableAutoFilter(BOOL bNewValue); + long GetEnableSelection(); + void SetEnableSelection(long nNewValue); + BOOL GetEnableOutlining(); + void SetEnableOutlining(BOOL bNewValue); + BOOL GetEnablePivotTable(); + void SetEnablePivotTable(BOOL bNewValue); + VARIANT Evaluate(const VARIANT& Name); + VARIANT _Evaluate(const VARIANT& Name); + BOOL GetFilterMode(); + void ResetAllPageBreaks(); + LPDISPATCH GetNames(); + LPDISPATCH OLEObjects(const VARIANT& Index); + LPDISPATCH GetOutline(); + void Paste(const VARIANT& Destination, const VARIANT& Link); + LPDISPATCH PivotTables(const VARIANT& Index); + LPDISPATCH PivotTableWizard(const VARIANT& SourceType, const VARIANT& SourceData, const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& RowGrand, const VARIANT& ColumnGrand, const VARIANT& SaveData, + const VARIANT& HasAutoFormat, const VARIANT& AutoPage, const VARIANT& Reserved, const VARIANT& BackgroundQuery, const VARIANT& OptimizeCache, const VARIANT& PageFieldOrder, const VARIANT& PageFieldWrapCount, const VARIANT& ReadData, + const VARIANT& Connection); + LPDISPATCH GetRange(const VARIANT& Cell1, const VARIANT& Cell2); + LPDISPATCH GetRows(); + LPDISPATCH Scenarios(const VARIANT& Index); + CString GetScrollArea(); + void SetScrollArea(LPCTSTR lpszNewValue); + void ShowAllData(); + void ShowDataForm(); + double GetStandardHeight(); + double GetStandardWidth(); + void SetStandardWidth(double newValue); + BOOL GetTransitionFormEntry(); + void SetTransitionFormEntry(BOOL bNewValue); + long GetType(); + LPDISPATCH GetUsedRange(); + LPDISPATCH GetHPageBreaks(); + LPDISPATCH GetVPageBreaks(); + LPDISPATCH GetQueryTables(); + BOOL GetDisplayPageBreaks(); + void SetDisplayPageBreaks(BOOL bNewValue); + LPDISPATCH GetComments(); + LPDISPATCH GetHyperlinks(); + void ClearCircles(); + void CircleInvalid(); + LPDISPATCH GetAutoFilter(); + BOOL GetDisplayRightToLeft(); + void SetDisplayRightToLeft(BOOL bNewValue); + LPDISPATCH GetScripts(); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); + LPDISPATCH GetTab(); + LPDISPATCH GetMailEnvelope(); + void SaveAs(LPCTSTR Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AddToMru, const VARIANT& TextCodepage, + const VARIANT& TextVisualLayout, const VARIANT& Local); + LPDISPATCH GetCustomProperties(); + LPDISPATCH GetSmartTags(); + LPDISPATCH GetProtection(); + void PasteSpecial(const VARIANT& Format, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel, const VARIANT& NoHTMLFormatting); + void Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly, const VARIANT& AllowFormattingCells, const VARIANT& AllowFormattingColumns, + const VARIANT& AllowFormattingRows, const VARIANT& AllowInsertingColumns, const VARIANT& AllowInsertingRows, const VARIANT& AllowInsertingHyperlinks, const VARIANT& AllowDeletingColumns, const VARIANT& AllowDeletingRows, + const VARIANT& AllowSorting, const VARIANT& AllowFiltering, const VARIANT& AllowUsingPivotTables); + LPDISPATCH GetListObjects(); + LPDISPATCH XmlDataQuery(LPCTSTR XPath, const VARIANT& SelectionNamespaces, const VARIANT& Map); + LPDISPATCH XmlMapQuery(LPCTSTR XPath, const VARIANT& SelectionNamespaces, const VARIANT& Map); +}; +///////////////////////////////////////////////////////////////////////////// +// _Global wrapper class + +class _Global : public COleDispatchDriver +{ +public: + _Global() {} // Calls COleDispatchDriver default constructor + _Global(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + _Global(const _Global& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetActiveCell(); + LPDISPATCH GetActiveChart(); + CString GetActivePrinter(); + void SetActivePrinter(LPCTSTR lpszNewValue); + LPDISPATCH GetActiveSheet(); + LPDISPATCH GetActiveWindow(); + LPDISPATCH GetActiveWorkbook(); + LPDISPATCH GetAddIns(); + LPDISPATCH GetAssistant(); + void Calculate(); + LPDISPATCH GetCells(); + LPDISPATCH GetCharts(); + LPDISPATCH GetColumns(); + LPDISPATCH GetCommandBars(); + long GetDDEAppReturnCode(); + void DDEExecute(long Channel, LPCTSTR String); + long DDEInitiate(LPCTSTR App, LPCTSTR Topic); + void DDEPoke(long Channel, const VARIANT& Item, const VARIANT& Data); + VARIANT DDERequest(long Channel, LPCTSTR Item); + void DDETerminate(long Channel); + VARIANT Evaluate(const VARIANT& Name); + VARIANT _Evaluate(const VARIANT& Name); + VARIANT ExecuteExcel4Macro(LPCTSTR String); + LPDISPATCH Intersect(LPDISPATCH Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + LPDISPATCH GetNames(); + LPDISPATCH GetRange(const VARIANT& Cell1, const VARIANT& Cell2); + LPDISPATCH GetRows(); + VARIANT Run(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, + const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, + const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, + const VARIANT& Arg30); + VARIANT _Run2(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, + const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, + const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, + const VARIANT& Arg30); + LPDISPATCH GetSelection(); + void SendKeys(const VARIANT& Keys, const VARIANT& Wait); + LPDISPATCH GetSheets(); + LPDISPATCH GetThisWorkbook(); + LPDISPATCH Union(LPDISPATCH Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + LPDISPATCH GetWindows(); + LPDISPATCH GetWorkbooks(); + LPDISPATCH GetWorksheetFunction(); + LPDISPATCH GetWorksheets(); + LPDISPATCH GetExcel4IntlMacroSheets(); + LPDISPATCH GetExcel4MacroSheets(); +}; +///////////////////////////////////////////////////////////////////////////// +// _Workbook wrapper class + +class _Workbook : public COleDispatchDriver +{ +public: + _Workbook() {} // Calls COleDispatchDriver default constructor + _Workbook(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + _Workbook(const _Workbook& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetAcceptLabelsInFormulas(); + void SetAcceptLabelsInFormulas(BOOL bNewValue); + void Activate(); + LPDISPATCH GetActiveChart(); + LPDISPATCH GetActiveSheet(); + long GetAutoUpdateFrequency(); + void SetAutoUpdateFrequency(long nNewValue); + BOOL GetAutoUpdateSaveChanges(); + void SetAutoUpdateSaveChanges(BOOL bNewValue); + long GetChangeHistoryDuration(); + void SetChangeHistoryDuration(long nNewValue); + LPDISPATCH GetBuiltinDocumentProperties(); + void ChangeFileAccess(long Mode, const VARIANT& WritePassword, const VARIANT& Notify); + void ChangeLink(LPCTSTR Name, LPCTSTR NewName, long Type); + LPDISPATCH GetCharts(); + void Close(const VARIANT& SaveChanges, const VARIANT& Filename, const VARIANT& RouteWorkbook); + CString GetCodeName(); + CString Get_CodeName(); + void Set_CodeName(LPCTSTR lpszNewValue); + VARIANT GetColors(const VARIANT& Index); + void SetColors(const VARIANT& Index, const VARIANT& newValue); + LPDISPATCH GetCommandBars(); + long GetConflictResolution(); + void SetConflictResolution(long nNewValue); + LPDISPATCH GetContainer(); + BOOL GetCreateBackup(); + LPDISPATCH GetCustomDocumentProperties(); + BOOL GetDate1904(); + void SetDate1904(BOOL bNewValue); + void DeleteNumberFormat(LPCTSTR NumberFormat); + long GetDisplayDrawingObjects(); + void SetDisplayDrawingObjects(long nNewValue); + BOOL ExclusiveAccess(); + long GetFileFormat(); + void ForwardMailer(); + CString GetFullName(); + BOOL GetHasPassword(); + BOOL GetHasRoutingSlip(); + void SetHasRoutingSlip(BOOL bNewValue); + BOOL GetIsAddin(); + void SetIsAddin(BOOL bNewValue); + VARIANT LinkInfo(LPCTSTR Name, long LinkInfo, const VARIANT& Type, const VARIANT& EditionRef); + VARIANT LinkSources(const VARIANT& Type); + LPDISPATCH GetMailer(); + void MergeWorkbook(const VARIANT& Filename); + BOOL GetMultiUserEditing(); + CString GetName(); + LPDISPATCH GetNames(); + LPDISPATCH NewWindow(); + void OpenLinks(LPCTSTR Name, const VARIANT& ReadOnly, const VARIANT& Type); + CString GetPath(); + BOOL GetPersonalViewListSettings(); + void SetPersonalViewListSettings(BOOL bNewValue); + BOOL GetPersonalViewPrintSettings(); + void SetPersonalViewPrintSettings(BOOL bNewValue); + LPDISPATCH PivotCaches(); + void Post(const VARIANT& DestName); + BOOL GetPrecisionAsDisplayed(); + void SetPrecisionAsDisplayed(BOOL bNewValue); + void PrintPreview(const VARIANT& EnableChanges); + void ProtectSharing(const VARIANT& Filename, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& SharingPassword); + BOOL GetProtectStructure(); + BOOL GetProtectWindows(); + BOOL GetReadOnly(); + void RefreshAll(); + void Reply(); + void ReplyAll(); + void RemoveUser(long Index); + long GetRevisionNumber(); + void Route(); + BOOL GetRouted(); + LPDISPATCH GetRoutingSlip(); + void RunAutoMacros(long Which); + void Save(); + void SaveCopyAs(const VARIANT& Filename); + BOOL GetSaved(); + void SetSaved(BOOL bNewValue); + BOOL GetSaveLinkValues(); + void SetSaveLinkValues(BOOL bNewValue); + void SendMail(const VARIANT& Recipients, const VARIANT& Subject, const VARIANT& ReturnReceipt); + void SendMailer(const VARIANT& FileFormat, long Priority); + void SetLinkOnData(LPCTSTR Name, const VARIANT& Procedure); + LPDISPATCH GetSheets(); + BOOL GetShowConflictHistory(); + void SetShowConflictHistory(BOOL bNewValue); + LPDISPATCH GetStyles(); + void Unprotect(const VARIANT& Password); + void UnprotectSharing(const VARIANT& SharingPassword); + void UpdateFromFile(); + void UpdateLink(const VARIANT& Name, const VARIANT& Type); + BOOL GetUpdateRemoteReferences(); + void SetUpdateRemoteReferences(BOOL bNewValue); + VARIANT GetUserStatus(); + LPDISPATCH GetCustomViews(); + LPDISPATCH GetWindows(); + LPDISPATCH GetWorksheets(); + BOOL GetWriteReserved(); + CString GetWriteReservedBy(); + LPDISPATCH GetExcel4IntlMacroSheets(); + LPDISPATCH GetExcel4MacroSheets(); + BOOL GetTemplateRemoveExtData(); + void SetTemplateRemoveExtData(BOOL bNewValue); + void HighlightChangesOptions(const VARIANT& When, const VARIANT& Who, const VARIANT& Where); + BOOL GetHighlightChangesOnScreen(); + void SetHighlightChangesOnScreen(BOOL bNewValue); + BOOL GetKeepChangeHistory(); + void SetKeepChangeHistory(BOOL bNewValue); + BOOL GetListChangesOnNewSheet(); + void SetListChangesOnNewSheet(BOOL bNewValue); + void PurgeChangeHistoryNow(long Days, const VARIANT& SharingPassword); + void AcceptAllChanges(const VARIANT& When, const VARIANT& Who, const VARIANT& Where); + void RejectAllChanges(const VARIANT& When, const VARIANT& Who, const VARIANT& Where); + void ResetColors(); + LPDISPATCH GetVBProject(); + void FollowHyperlink(LPCTSTR Address, const VARIANT& SubAddress, const VARIANT& NewWindow, const VARIANT& AddHistory, const VARIANT& ExtraInfo, const VARIANT& Method, const VARIANT& HeaderInfo); + void AddToFavorites(); + BOOL GetIsInplace(); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); + void WebPagePreview(); + LPDISPATCH GetPublishObjects(); + LPDISPATCH GetWebOptions(); + void ReloadAs(long Encoding); + LPDISPATCH GetHTMLProject(); + BOOL GetEnvelopeVisible(); + void SetEnvelopeVisible(BOOL bNewValue); + long GetCalculationVersion(); + BOOL GetVBASigned(); + BOOL GetShowPivotTableFieldList(); + void SetShowPivotTableFieldList(BOOL bNewValue); + long GetUpdateLinks(); + void SetUpdateLinks(long nNewValue); + void BreakLink(LPCTSTR Name, long Type); + void SaveAs(const VARIANT& Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, long AccessMode, const VARIANT& ConflictResolution, + const VARIANT& AddToMru, const VARIANT& TextCodepage, const VARIANT& TextVisualLayout, const VARIANT& Local); + BOOL GetEnableAutoRecover(); + void SetEnableAutoRecover(BOOL bNewValue); + BOOL GetRemovePersonalInformation(); + void SetRemovePersonalInformation(BOOL bNewValue); + CString GetFullNameURLEncoded(); + void CheckIn(const VARIANT& SaveChanges, const VARIANT& Comments, const VARIANT& MakePublic); + BOOL CanCheckIn(); + void SendForReview(const VARIANT& Recipients, const VARIANT& Subject, const VARIANT& ShowMessage, const VARIANT& IncludeAttachment); + void ReplyWithChanges(const VARIANT& ShowMessage); + void EndReview(); + CString GetPassword(); + void SetPassword(LPCTSTR lpszNewValue); + CString GetWritePassword(); + void SetWritePassword(LPCTSTR lpszNewValue); + CString GetPasswordEncryptionProvider(); + CString GetPasswordEncryptionAlgorithm(); + long GetPasswordEncryptionKeyLength(); + void SetPasswordEncryptionOptions(const VARIANT& PasswordEncryptionProvider, const VARIANT& PasswordEncryptionAlgorithm, const VARIANT& PasswordEncryptionKeyLength, const VARIANT& PasswordEncryptionFileProperties); + BOOL GetPasswordEncryptionFileProperties(); + BOOL GetReadOnlyRecommended(); + void SetReadOnlyRecommended(BOOL bNewValue); + void Protect(const VARIANT& Password, const VARIANT& Structure, const VARIANT& Windows); + LPDISPATCH GetSmartTagOptions(); + void RecheckSmartTags(); + LPDISPATCH GetPermission(); + LPDISPATCH GetSharedWorkspace(); + LPDISPATCH GetSync(); + void SendFaxOverInternet(const VARIANT& Recipients, const VARIANT& Subject, const VARIANT& ShowMessage); + LPDISPATCH GetXmlNamespaces(); + LPDISPATCH GetXmlMaps(); + long XmlImport(LPCTSTR Url, LPDISPATCH* ImportMap, const VARIANT& Overwrite, const VARIANT& Destination); + LPDISPATCH GetSmartDocument(); + LPDISPATCH GetDocumentLibraryVersions(); + BOOL GetInactiveListBorderVisible(); + void SetInactiveListBorderVisible(BOOL bNewValue); + BOOL GetDisplayInkComments(); + void SetDisplayInkComments(BOOL bNewValue); + long XmlImportXml(LPCTSTR Data, LPDISPATCH* ImportMap, const VARIANT& Overwrite, const VARIANT& Destination); + void SaveAsXMLData(LPCTSTR Filename, LPDISPATCH Map); + void ToggleFormsDesign(); +}; +///////////////////////////////////////////////////////////////////////////// +// Workbooks wrapper class + +class Workbooks : public COleDispatchDriver +{ +public: + Workbooks() {} // Calls COleDispatchDriver default constructor + Workbooks(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Workbooks(const Workbooks& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Template); + void Close(); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH Open(LPCTSTR Filename, const VARIANT& UpdateLinks, const VARIANT& ReadOnly, const VARIANT& Format, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& IgnoreReadOnlyRecommended, const VARIANT& Origin, + const VARIANT& Delimiter, const VARIANT& Editable, const VARIANT& Notify, const VARIANT& Converter, const VARIANT& AddToMru, const VARIANT& Local, const VARIANT& CorruptLoad); + void OpenText(LPCTSTR Filename, const VARIANT& Origin, const VARIANT& StartRow, const VARIANT& DataType, long TextQualifier, const VARIANT& ConsecutiveDelimiter, const VARIANT& Tab, const VARIANT& Semicolon, const VARIANT& Comma, + const VARIANT& Space, const VARIANT& Other, const VARIANT& OtherChar, const VARIANT& FieldInfo, const VARIANT& TextVisualLayout, const VARIANT& DecimalSeparator, const VARIANT& ThousandsSeparator, const VARIANT& TrailingMinusNumbers, + const VARIANT& Local); + LPDISPATCH OpenDatabase(LPCTSTR Filename, const VARIANT& CommandText, const VARIANT& CommandType, const VARIANT& BackgroundQuery, const VARIANT& ImportDataAs); + void CheckOut(LPCTSTR Filename); + BOOL CanCheckOut(LPCTSTR Filename); + LPDISPATCH OpenXML(LPCTSTR Filename, const VARIANT& Stylesheets, const VARIANT& LoadOption); +}; +///////////////////////////////////////////////////////////////////////////// +// PublishObject wrapper class + +class PublishObject : public COleDispatchDriver +{ +public: + PublishObject() {} // Calls COleDispatchDriver default constructor + PublishObject(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PublishObject(const PublishObject& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Delete(); + void Publish(const VARIANT& Create); + CString GetDivID(); + CString GetSheet(); + long GetSourceType(); + CString GetSource(); + long GetHtmlType(); + void SetHtmlType(long nNewValue); + CString GetTitle(); + void SetTitle(LPCTSTR lpszNewValue); + CString GetFilename(); + void SetFilename(LPCTSTR lpszNewValue); + BOOL GetAutoRepublish(); + void SetAutoRepublish(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// DefaultWebOptions wrapper class + +class DefaultWebOptions : public COleDispatchDriver +{ +public: + DefaultWebOptions() {} // Calls COleDispatchDriver default constructor + DefaultWebOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DefaultWebOptions(const DefaultWebOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetRelyOnCSS(); + void SetRelyOnCSS(BOOL bNewValue); + BOOL GetSaveHiddenData(); + void SetSaveHiddenData(BOOL bNewValue); + BOOL GetLoadPictures(); + void SetLoadPictures(BOOL bNewValue); + BOOL GetOrganizeInFolder(); + void SetOrganizeInFolder(BOOL bNewValue); + BOOL GetUpdateLinksOnSave(); + void SetUpdateLinksOnSave(BOOL bNewValue); + BOOL GetUseLongFileNames(); + void SetUseLongFileNames(BOOL bNewValue); + BOOL GetCheckIfOfficeIsHTMLEditor(); + void SetCheckIfOfficeIsHTMLEditor(BOOL bNewValue); + BOOL GetDownloadComponents(); + void SetDownloadComponents(BOOL bNewValue); + BOOL GetRelyOnVML(); + void SetRelyOnVML(BOOL bNewValue); + BOOL GetAllowPNG(); + void SetAllowPNG(BOOL bNewValue); + long GetScreenSize(); + void SetScreenSize(long nNewValue); + long GetPixelsPerInch(); + void SetPixelsPerInch(long nNewValue); + CString GetLocationOfComponents(); + void SetLocationOfComponents(LPCTSTR lpszNewValue); + long GetEncoding(); + void SetEncoding(long nNewValue); + BOOL GetAlwaysSaveInDefaultEncoding(); + void SetAlwaysSaveInDefaultEncoding(BOOL bNewValue); + LPDISPATCH GetFonts(); + CString GetFolderSuffix(); + long GetTargetBrowser(); + void SetTargetBrowser(long nNewValue); + BOOL GetSaveNewWebPagesAsWebArchives(); + void SetSaveNewWebPagesAsWebArchives(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// WebOptions wrapper class + +class WebOptions : public COleDispatchDriver +{ +public: + WebOptions() {} // Calls COleDispatchDriver default constructor + WebOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + WebOptions(const WebOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetRelyOnCSS(); + void SetRelyOnCSS(BOOL bNewValue); + BOOL GetOrganizeInFolder(); + void SetOrganizeInFolder(BOOL bNewValue); + BOOL GetUseLongFileNames(); + void SetUseLongFileNames(BOOL bNewValue); + BOOL GetDownloadComponents(); + void SetDownloadComponents(BOOL bNewValue); + BOOL GetRelyOnVML(); + void SetRelyOnVML(BOOL bNewValue); + BOOL GetAllowPNG(); + void SetAllowPNG(BOOL bNewValue); + long GetScreenSize(); + void SetScreenSize(long nNewValue); + long GetPixelsPerInch(); + void SetPixelsPerInch(long nNewValue); + CString GetLocationOfComponents(); + void SetLocationOfComponents(LPCTSTR lpszNewValue); + long GetEncoding(); + void SetEncoding(long nNewValue); + CString GetFolderSuffix(); + void UseDefaultFolderSuffix(); + long GetTargetBrowser(); + void SetTargetBrowser(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// TreeviewControl wrapper class + +class TreeviewControl : public COleDispatchDriver +{ +public: + TreeviewControl() {} // Calls COleDispatchDriver default constructor + TreeviewControl(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + TreeviewControl(const TreeviewControl& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT GetHidden(); + void SetHidden(const VARIANT& newValue); + VARIANT GetDrilled(); + void SetDrilled(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// CubeField wrapper class + +class CubeField : public COleDispatchDriver +{ +public: + CubeField() {} // Calls COleDispatchDriver default constructor + CubeField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CubeField(const CubeField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCubeFieldType(); + CString GetCaption(); + CString GetName(); + CString GetValue(); + long GetOrientation(); + void SetOrientation(long nNewValue); + long GetPosition(); + void SetPosition(long nNewValue); + LPDISPATCH GetTreeviewControl(); + BOOL GetDragToColumn(); + void SetDragToColumn(BOOL bNewValue); + BOOL GetDragToHide(); + void SetDragToHide(BOOL bNewValue); + BOOL GetDragToPage(); + void SetDragToPage(BOOL bNewValue); + BOOL GetDragToRow(); + void SetDragToRow(BOOL bNewValue); + BOOL GetDragToData(); + void SetDragToData(BOOL bNewValue); + long GetHiddenLevels(); + void SetHiddenLevels(long nNewValue); + BOOL GetHasMemberProperties(); + long GetLayoutForm(); + void SetLayoutForm(long nNewValue); + LPDISPATCH GetPivotFields(); + void AddMemberPropertyField(LPCTSTR Property_, const VARIANT& PropertyOrder); + BOOL GetEnableMultiplePageItems(); + void SetEnableMultiplePageItems(BOOL bNewValue); + long GetLayoutSubtotalLocation(); + void SetLayoutSubtotalLocation(long nNewValue); + BOOL GetShowInFieldList(); + void SetShowInFieldList(BOOL bNewValue); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// CubeFields wrapper class + +class CubeFields : public COleDispatchDriver +{ +public: + CubeFields() {} // Calls COleDispatchDriver default constructor + CubeFields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CubeFields(const CubeFields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH AddSet(LPCTSTR Name, LPCTSTR Caption); +}; +///////////////////////////////////////////////////////////////////////////// +// MyFont wrapper class + +class MyFont : public COleDispatchDriver +{ +public: + MyFont() {} // Calls COleDispatchDriver default constructor + MyFont(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + MyFont(const MyFont& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT GetBackground(); + void SetBackground(const VARIANT& newValue); + VARIANT GetBold(); + void SetBold(const VARIANT& newValue); + VARIANT GetColor(); + void SetColor(const VARIANT& newValue); + VARIANT GetColorIndex(); + void SetColorIndex(const VARIANT& newValue); + VARIANT GetFontStyle(); + void SetFontStyle(const VARIANT& newValue); + VARIANT GetItalic(); + void SetItalic(const VARIANT& newValue); + VARIANT GetName(); + void SetName(const VARIANT& newValue); + VARIANT GetOutlineFont(); + void SetOutlineFont(const VARIANT& newValue); + VARIANT GetShadow(); + void SetShadow(const VARIANT& newValue); + VARIANT GetSize(); + void SetSize(const VARIANT& newValue); + VARIANT GetStrikethrough(); + void SetStrikethrough(const VARIANT& newValue); + VARIANT GetSubscript(); + void SetSubscript(const VARIANT& newValue); + VARIANT GetSuperscript(); + void SetSuperscript(const VARIANT& newValue); + VARIANT GetUnderline(); + void SetUnderline(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Window wrapper class + +class Window : public COleDispatchDriver +{ +public: + Window() {} // Calls COleDispatchDriver default constructor + Window(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Window(const Window& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT Activate(); + VARIANT ActivateNext(); + VARIANT ActivatePrevious(); + LPDISPATCH GetActiveCell(); + LPDISPATCH GetActiveChart(); + LPDISPATCH GetActivePane(); + LPDISPATCH GetActiveSheet(); + VARIANT GetCaption(); + void SetCaption(const VARIANT& newValue); + BOOL Close(const VARIANT& SaveChanges, const VARIANT& Filename, const VARIANT& RouteWorkbook); + BOOL GetDisplayFormulas(); + void SetDisplayFormulas(BOOL bNewValue); + BOOL GetDisplayGridlines(); + void SetDisplayGridlines(BOOL bNewValue); + BOOL GetDisplayHeadings(); + void SetDisplayHeadings(BOOL bNewValue); + BOOL GetDisplayHorizontalScrollBar(); + void SetDisplayHorizontalScrollBar(BOOL bNewValue); + BOOL GetDisplayOutline(); + void SetDisplayOutline(BOOL bNewValue); + BOOL GetDisplayVerticalScrollBar(); + void SetDisplayVerticalScrollBar(BOOL bNewValue); + BOOL GetDisplayWorkbookTabs(); + void SetDisplayWorkbookTabs(BOOL bNewValue); + BOOL GetDisplayZeros(); + void SetDisplayZeros(BOOL bNewValue); + BOOL GetEnableResize(); + void SetEnableResize(BOOL bNewValue); + BOOL GetFreezePanes(); + void SetFreezePanes(BOOL bNewValue); + long GetGridlineColor(); + void SetGridlineColor(long nNewValue); + long GetGridlineColorIndex(); + void SetGridlineColorIndex(long nNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + VARIANT LargeScroll(const VARIANT& Down, const VARIANT& Up, const VARIANT& ToRight, const VARIANT& ToLeft); + double GetLeft(); + void SetLeft(double newValue); + LPDISPATCH NewWindow(); + CString GetOnWindow(); + void SetOnWindow(LPCTSTR lpszNewValue); + LPDISPATCH GetPanes(); + VARIANT PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); + VARIANT PrintPreview(const VARIANT& EnableChanges); + LPDISPATCH GetRangeSelection(); + long GetScrollColumn(); + void SetScrollColumn(long nNewValue); + long GetScrollRow(); + void SetScrollRow(long nNewValue); + VARIANT ScrollWorkbookTabs(const VARIANT& Sheets, const VARIANT& Position); + LPDISPATCH GetSelectedSheets(); + LPDISPATCH GetSelection(); + VARIANT SmallScroll(const VARIANT& Down, const VARIANT& Up, const VARIANT& ToRight, const VARIANT& ToLeft); + BOOL GetSplit(); + void SetSplit(BOOL bNewValue); + long GetSplitColumn(); + void SetSplitColumn(long nNewValue); + double GetSplitHorizontal(); + void SetSplitHorizontal(double newValue); + long GetSplitRow(); + void SetSplitRow(long nNewValue); + double GetSplitVertical(); + void SetSplitVertical(double newValue); + double GetTabRatio(); + void SetTabRatio(double newValue); + double GetTop(); + void SetTop(double newValue); + long GetType(); + double GetUsableHeight(); + double GetUsableWidth(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + LPDISPATCH GetVisibleRange(); + double GetWidth(); + void SetWidth(double newValue); + long GetWindowNumber(); + long GetWindowState(); + void SetWindowState(long nNewValue); + VARIANT GetZoom(); + void SetZoom(const VARIANT& newValue); + long GetView(); + void SetView(long nNewValue); + BOOL GetDisplayRightToLeft(); + void SetDisplayRightToLeft(BOOL bNewValue); + long PointsToScreenPixelsX(long Points); + long PointsToScreenPixelsY(long Points); + LPDISPATCH RangeFromPoint(long x, long y); + void ScrollIntoView(long Left, long Top, long Width, long Height, const VARIANT& Start); +}; +///////////////////////////////////////////////////////////////////////////// +// Windows wrapper class + +class Windows : public COleDispatchDriver +{ +public: + Windows() {} // Calls COleDispatchDriver default constructor + Windows(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Windows(const Windows& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT Arrange(long ArrangeStyle, const VARIANT& ActiveWorkbook, const VARIANT& SyncHorizontal, const VARIANT& SyncVertical); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Get_Default(const VARIANT& Index); + BOOL CompareSideBySideWith(const VARIANT& WindowName); + BOOL BreakSideBySide(); + BOOL GetSyncScrollingSideBySide(); + void SetSyncScrollingSideBySide(BOOL bNewValue); + void ResetPositionsSideBySide(); +}; +///////////////////////////////////////////////////////////////////////////// +// AppEvents wrapper class + +class AppEvents : public COleDispatchDriver +{ +public: + AppEvents() {} // Calls COleDispatchDriver default constructor + AppEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AppEvents(const AppEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + void NewWorkbook(LPDISPATCH Wb); + void SheetSelectionChange(LPDISPATCH Sh, LPDISPATCH Target); + void SheetBeforeDoubleClick(LPDISPATCH Sh, LPDISPATCH Target, BOOL* Cancel); + void SheetBeforeRightClick(LPDISPATCH Sh, LPDISPATCH Target, BOOL* Cancel); + void SheetActivate(LPDISPATCH Sh); + void SheetDeactivate(LPDISPATCH Sh); + void SheetCalculate(LPDISPATCH Sh); + void SheetChange(LPDISPATCH Sh, LPDISPATCH Target); + void WorkbookOpen(LPDISPATCH Wb); + void WorkbookActivate(LPDISPATCH Wb); + void WorkbookDeactivate(LPDISPATCH Wb); + void WorkbookBeforeClose(LPDISPATCH Wb, BOOL* Cancel); + void WorkbookBeforeSave(LPDISPATCH Wb, BOOL SaveAsUI, BOOL* Cancel); + void WorkbookBeforePrint(LPDISPATCH Wb, BOOL* Cancel); + void WorkbookNewSheet(LPDISPATCH Wb, LPDISPATCH Sh); + void WorkbookAddinInstall(LPDISPATCH Wb); + void WorkbookAddinUninstall(LPDISPATCH Wb); + void WindowResize(LPDISPATCH Wb, LPDISPATCH Wn); + void WindowActivate(LPDISPATCH Wb, LPDISPATCH Wn); + void WindowDeactivate(LPDISPATCH Wb, LPDISPATCH Wn); + void SheetFollowHyperlink(LPDISPATCH Sh, LPDISPATCH Target); + void SheetPivotTableUpdate(LPDISPATCH Sh, LPDISPATCH Target); + void WorkbookPivotTableCloseConnection(LPDISPATCH Wb, LPDISPATCH Target); + void WorkbookPivotTableOpenConnection(LPDISPATCH Wb, LPDISPATCH Target); + void WorkbookSync(LPDISPATCH Wb, long SyncEventType); + void WorkbookBeforeXmlImport(LPDISPATCH Wb, LPDISPATCH Map, LPCTSTR Url, BOOL IsRefresh, BOOL* Cancel); + void WorkbookAfterXmlImport(LPDISPATCH Wb, LPDISPATCH Map, BOOL IsRefresh, long Result); + void WorkbookBeforeXmlExport(LPDISPATCH Wb, LPDISPATCH Map, LPCTSTR Url, BOOL* Cancel); + void WorkbookAfterXmlExport(LPDISPATCH Wb, LPDISPATCH Map, LPCTSTR Url, long Result); +}; +///////////////////////////////////////////////////////////////////////////// +// WorksheetFunction wrapper class + +class WorksheetFunction : public COleDispatchDriver +{ +public: + WorksheetFunction() {} // Calls COleDispatchDriver default constructor + WorksheetFunction(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + WorksheetFunction(const WorksheetFunction& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + double Count(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + BOOL IsNA(const VARIANT& Arg1); + BOOL IsError(const VARIANT& Arg1); + double Sum(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Average(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Min(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Max(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Npv(double Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double StDev(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + CString Dollar(double Arg1, const VARIANT& Arg2); + CString Fixed(double Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double Pi(); + double Ln(double Arg1); + double Log10(double Arg1); + double Round(double Arg1, double Arg2); + VARIANT Lookup(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + VARIANT Index(const VARIANT& Arg1, double Arg2, const VARIANT& Arg3, const VARIANT& Arg4); + CString Rept(LPCTSTR Arg1, double Arg2); + BOOL And(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + BOOL Or(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double DCount(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double DSum(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double DAverage(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double DMin(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double DMax(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double DStDev(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double Var(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double DVar(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + CString Text(const VARIANT& Arg1, LPCTSTR Arg2); + VARIANT LinEst(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4); + VARIANT Trend(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4); + VARIANT LogEst(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4); + VARIANT Growth(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4); + double Pv(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5); + double Fv(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5); + double NPer(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5); + double Pmt(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5); + double Rate(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6); + double MIrr(const VARIANT& Arg1, double Arg2, double Arg3); + double Irr(const VARIANT& Arg1, const VARIANT& Arg2); + double Match(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double Weekday(const VARIANT& Arg1, const VARIANT& Arg2); + double Search(LPCTSTR Arg1, LPCTSTR Arg2, const VARIANT& Arg3); + VARIANT Transpose(const VARIANT& Arg1); + double Atan2(double Arg1, double Arg2); + double Asin(double Arg1); + double Acos(double Arg1); + VARIANT Choose(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + VARIANT HLookup(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4); + VARIANT VLookup(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4); + double Log(double Arg1, const VARIANT& Arg2); + CString Proper(LPCTSTR Arg1); + CString Trim(LPCTSTR Arg1); + CString Replace(LPCTSTR Arg1, double Arg2, double Arg3, LPCTSTR Arg4); + CString Substitute(LPCTSTR Arg1, LPCTSTR Arg2, LPCTSTR Arg3, const VARIANT& Arg4); + double Find(LPCTSTR Arg1, LPCTSTR Arg2, const VARIANT& Arg3); + BOOL IsErr(const VARIANT& Arg1); + BOOL IsText(const VARIANT& Arg1); + BOOL IsNumber(const VARIANT& Arg1); + double Sln(double Arg1, double Arg2, double Arg3); + double Syd(double Arg1, double Arg2, double Arg3, double Arg4); + double Ddb(double Arg1, double Arg2, double Arg3, double Arg4, const VARIANT& Arg5); + CString Clean(LPCTSTR Arg1); + double MDeterm(const VARIANT& Arg1); + VARIANT MInverse(const VARIANT& Arg1); + VARIANT MMult(const VARIANT& Arg1, const VARIANT& Arg2); + double Ipmt(double Arg1, double Arg2, double Arg3, double Arg4, const VARIANT& Arg5, const VARIANT& Arg6); + double Ppmt(double Arg1, double Arg2, double Arg3, double Arg4, const VARIANT& Arg5, const VARIANT& Arg6); + double CountA(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Product(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Fact(double Arg1); + double DProduct(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + BOOL IsNonText(const VARIANT& Arg1); + double StDevP(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double VarP(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double DStDevP(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double DVarP(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + BOOL IsLogical(const VARIANT& Arg1); + double DCountA(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + CString USDollar(double Arg1, double Arg2); + double FindB(LPCTSTR Arg1, LPCTSTR Arg2, const VARIANT& Arg3); + double SearchB(LPCTSTR Arg1, LPCTSTR Arg2, const VARIANT& Arg3); + CString ReplaceB(LPCTSTR Arg1, double Arg2, double Arg3, LPCTSTR Arg4); + double RoundUp(double Arg1, double Arg2); + double RoundDown(double Arg1, double Arg2); + double Rank(double Arg1, LPDISPATCH Arg2, const VARIANT& Arg3); + double Days360(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double Vdb(double Arg1, double Arg2, double Arg3, double Arg4, double Arg5, const VARIANT& Arg6, const VARIANT& Arg7); + double Median(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double SumProduct(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Sinh(double Arg1); + double Cosh(double Arg1); + double Tanh(double Arg1); + double Asinh(double Arg1); + double Acosh(double Arg1); + double Atanh(double Arg1); + VARIANT DGet(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double Db(double Arg1, double Arg2, double Arg3, double Arg4, const VARIANT& Arg5); + VARIANT Frequency(const VARIANT& Arg1, const VARIANT& Arg2); + double AveDev(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double BetaDist(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5); + double GammaLn(double Arg1); + double BetaInv(double Arg1, double Arg2, double Arg3, const VARIANT& Arg4, const VARIANT& Arg5); + double BinomDist(double Arg1, double Arg2, double Arg3, BOOL Arg4); + double ChiDist(double Arg1, double Arg2); + double ChiInv(double Arg1, double Arg2); + double Combin(double Arg1, double Arg2); + double Confidence(double Arg1, double Arg2, double Arg3); + double CritBinom(double Arg1, double Arg2, double Arg3); + double Even(double Arg1); + double ExponDist(double Arg1, double Arg2, BOOL Arg3); + double FDist(double Arg1, double Arg2, double Arg3); + double FInv(double Arg1, double Arg2, double Arg3); + double Fisher(double Arg1); + double FisherInv(double Arg1); + double Floor(double Arg1, double Arg2); + double GammaDist(double Arg1, double Arg2, double Arg3, BOOL Arg4); + double GammaInv(double Arg1, double Arg2, double Arg3); + double Ceiling(double Arg1, double Arg2); + double HypGeomDist(double Arg1, double Arg2, double Arg3, double Arg4); + double LogNormDist(double Arg1, double Arg2, double Arg3); + double LogInv(double Arg1, double Arg2, double Arg3); + double NegBinomDist(double Arg1, double Arg2, double Arg3); + double NormDist(double Arg1, double Arg2, double Arg3, BOOL Arg4); + double NormSDist(double Arg1); + double NormInv(double Arg1, double Arg2, double Arg3); + double NormSInv(double Arg1); + double Standardize(double Arg1, double Arg2, double Arg3); + double Odd(double Arg1); + double Permut(double Arg1, double Arg2); + double Poisson(double Arg1, double Arg2, BOOL Arg3); + double TDist(double Arg1, double Arg2, double Arg3); + double Weibull(double Arg1, double Arg2, double Arg3, BOOL Arg4); + double SumXMY2(const VARIANT& Arg1, const VARIANT& Arg2); + double SumX2MY2(const VARIANT& Arg1, const VARIANT& Arg2); + double SumX2PY2(const VARIANT& Arg1, const VARIANT& Arg2); + double ChiTest(const VARIANT& Arg1, const VARIANT& Arg2); + double Correl(const VARIANT& Arg1, const VARIANT& Arg2); + double Covar(const VARIANT& Arg1, const VARIANT& Arg2); + double Forecast(double Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double FTest(const VARIANT& Arg1, const VARIANT& Arg2); + double Intercept(const VARIANT& Arg1, const VARIANT& Arg2); + double Pearson(const VARIANT& Arg1, const VARIANT& Arg2); + double RSq(const VARIANT& Arg1, const VARIANT& Arg2); + double StEyx(const VARIANT& Arg1, const VARIANT& Arg2); + double Slope(const VARIANT& Arg1, const VARIANT& Arg2); + double TTest(const VARIANT& Arg1, const VARIANT& Arg2, double Arg3, double Arg4); + double Prob(const VARIANT& Arg1, const VARIANT& Arg2, double Arg3, const VARIANT& Arg4); + double DevSq(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double GeoMean(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double HarMean(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double SumSq(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Kurt(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double Skew(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double ZTest(const VARIANT& Arg1, double Arg2, const VARIANT& Arg3); + double Large(const VARIANT& Arg1, double Arg2); + double Small(const VARIANT& Arg1, double Arg2); + double Quartile(const VARIANT& Arg1, double Arg2); + double Percentile(const VARIANT& Arg1, double Arg2); + double PercentRank(const VARIANT& Arg1, double Arg2, const VARIANT& Arg3); + double Mode(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double TrimMean(const VARIANT& Arg1, double Arg2); + double TInv(double Arg1, double Arg2); + double Power(double Arg1, double Arg2); + double Radians(double Arg1); + double Degrees(double Arg1); + double Subtotal(double Arg1, LPDISPATCH Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + double SumIf(LPDISPATCH Arg1, const VARIANT& Arg2, const VARIANT& Arg3); + double CountIf(LPDISPATCH Arg1, const VARIANT& Arg2); + double CountBlank(LPDISPATCH Arg1); + double Ispmt(double Arg1, double Arg2, double Arg3, double Arg4); + CString Roman(double Arg1, const VARIANT& Arg2); + CString Asc(LPCTSTR Arg1); + CString Dbcs(LPCTSTR Arg1); + CString Phonetic(LPDISPATCH Arg1); + CString BahtText(double Arg1); + VARIANT RTD(const VARIANT& progID, const VARIANT& server, const VARIANT& topic1, const VARIANT& topic2, const VARIANT& topic3, const VARIANT& topic4, const VARIANT& topic5, const VARIANT& topic6, const VARIANT& topic7, const VARIANT& topic8, + const VARIANT& topic9, const VARIANT& topic10, const VARIANT& topic11, const VARIANT& topic12, const VARIANT& topic13, const VARIANT& topic14, const VARIANT& topic15, const VARIANT& topic16, const VARIANT& topic17, const VARIANT& topic18, + const VARIANT& topic19, const VARIANT& topic20, const VARIANT& topic21, const VARIANT& topic22, const VARIANT& topic23, const VARIANT& topic24, const VARIANT& topic25, const VARIANT& topic26, const VARIANT& topic27, + const VARIANT& topic28); +}; +///////////////////////////////////////////////////////////////////////////// +// Range wrapper class + +class Range : public COleDispatchDriver +{ +public: + Range() {} // Calls COleDispatchDriver default constructor + Range(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Range(const Range& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT Activate(); + VARIANT GetAddIndent(); + void SetAddIndent(const VARIANT& newValue); + CString GetAddress(const VARIANT& RowAbsolute, const VARIANT& ColumnAbsolute, long ReferenceStyle, const VARIANT& External, const VARIANT& RelativeTo); + CString GetAddressLocal(const VARIANT& RowAbsolute, const VARIANT& ColumnAbsolute, long ReferenceStyle, const VARIANT& External, const VARIANT& RelativeTo); + VARIANT AdvancedFilter(long Action, const VARIANT& CriteriaRange, const VARIANT& CopyToRange, const VARIANT& Unique); + VARIANT ApplyNames(const VARIANT& Names, const VARIANT& IgnoreRelativeAbsolute, const VARIANT& UseRowColumnNames, const VARIANT& OmitColumn, const VARIANT& OmitRow, long Order, const VARIANT& AppendLast); + VARIANT ApplyOutlineStyles(); + LPDISPATCH GetAreas(); + CString AutoComplete(LPCTSTR String); + VARIANT AutoFill(LPDISPATCH Destination, long Type); + VARIANT AutoFilter(const VARIANT& Field, const VARIANT& Criteria1, long Operator, const VARIANT& Criteria2, const VARIANT& VisibleDropDown); + VARIANT AutoFit(); + VARIANT AutoFormat(long Format, const VARIANT& Number, const VARIANT& MyFont, const VARIANT& Alignment, const VARIANT& Border, const VARIANT& Pattern, const VARIANT& Width); + VARIANT AutoOutline(); + VARIANT BorderAround(const VARIANT& LineStyle, long Weight, long ColorIndex, const VARIANT& Color); + LPDISPATCH GetBorders(); + VARIANT Calculate(); + LPDISPATCH GetCells(); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + VARIANT Clear(); + VARIANT ClearContents(); + VARIANT ClearFormats(); + VARIANT ClearNotes(); + VARIANT ClearOutline(); + long GetColumn(); + LPDISPATCH ColumnDifferences(const VARIANT& Comparison); + LPDISPATCH GetColumns(); + VARIANT GetColumnWidth(); + void SetColumnWidth(const VARIANT& newValue); + VARIANT Consolidate(const VARIANT& Sources, const VARIANT& Function, const VARIANT& TopRow, const VARIANT& LeftColumn, const VARIANT& CreateLinks); + VARIANT Copy(const VARIANT& Destination); + long CopyFromRecordset(LPUNKNOWN Data, const VARIANT& MaxRows, const VARIANT& MaxColumns); + VARIANT CopyPicture(long Appearance, long Format); + long GetCount(); + VARIANT CreateNames(const VARIANT& Top, const VARIANT& Left, const VARIANT& Bottom, const VARIANT& Right); + VARIANT CreatePublisher(const VARIANT& Edition, long Appearance, const VARIANT& ContainsPICT, const VARIANT& ContainsBIFF, const VARIANT& ContainsRTF, const VARIANT& ContainsVALU); + LPDISPATCH GetCurrentArray(); + LPDISPATCH GetCurrentRegion(); + VARIANT Cut(const VARIANT& Destination); + VARIANT DataSeries(const VARIANT& Rowcol, long Type, long Date, const VARIANT& Step, const VARIANT& Stop, const VARIANT& Trend); + VARIANT Get_Default(const VARIANT& RowIndex, const VARIANT& ColumnIndex); + void Set_Default(const VARIANT& RowIndex, const VARIANT& ColumnIndex, const VARIANT& newValue); + VARIANT Delete(const VARIANT& Shift); + LPDISPATCH GetDependents(); + VARIANT DialogBox_(); + LPDISPATCH GetDirectDependents(); + LPDISPATCH GetDirectPrecedents(); + VARIANT EditionOptions(long Type, long Option, const VARIANT& Name, const VARIANT& Reference, long Appearance, long ChartSize, const VARIANT& Format); + LPDISPATCH GetEnd(long Direction); + LPDISPATCH GetEntireColumn(); + LPDISPATCH GetEntireRow(); + VARIANT FillDown(); + VARIANT FillLeft(); + VARIANT FillRight(); + VARIANT FillUp(); + LPDISPATCH Find(const VARIANT& What, const VARIANT& After, const VARIANT& LookIn, const VARIANT& LookAt, const VARIANT& SearchOrder, long SearchDirection, const VARIANT& MatchCase, const VARIANT& MatchByte, const VARIANT& SearchFormat); + LPDISPATCH FindNext(const VARIANT& After); + LPDISPATCH FindPrevious(const VARIANT& After); + LPDISPATCH GetFont(); + VARIANT GetFormula(); + void SetFormula(const VARIANT& newValue); + VARIANT GetFormulaArray(); + void SetFormulaArray(const VARIANT& newValue); + long GetFormulaLabel(); + void SetFormulaLabel(long nNewValue); + VARIANT GetFormulaHidden(); + void SetFormulaHidden(const VARIANT& newValue); + VARIANT GetFormulaLocal(); + void SetFormulaLocal(const VARIANT& newValue); + VARIANT GetFormulaR1C1(); + void SetFormulaR1C1(const VARIANT& newValue); + VARIANT GetFormulaR1C1Local(); + void SetFormulaR1C1Local(const VARIANT& newValue); + VARIANT FunctionWizard(); + BOOL GoalSeek(const VARIANT& Goal, LPDISPATCH ChangingCell); + VARIANT Group(const VARIANT& Start, const VARIANT& End, const VARIANT& By, const VARIANT& Periods); + VARIANT GetHasArray(); + VARIANT GetHasFormula(); + VARIANT GetHeight(); + VARIANT GetHidden(); + void SetHidden(const VARIANT& newValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + VARIANT GetIndentLevel(); + void SetIndentLevel(const VARIANT& newValue); + void InsertIndent(long InsertAmount); + VARIANT Insert(const VARIANT& Shift, const VARIANT& CopyOrigin); + LPDISPATCH GetInterior(); + VARIANT GetItem(const VARIANT& RowIndex, const VARIANT& ColumnIndex); + void SetItem(const VARIANT& RowIndex, const VARIANT& ColumnIndex, const VARIANT& newValue); + VARIANT Justify(); + VARIANT GetLeft(); + long GetListHeaderRows(); + VARIANT ListNames(); + long GetLocationInTable(); + VARIANT GetLocked(); + void SetLocked(const VARIANT& newValue); + void Merge(const VARIANT& Across); + void UnMerge(); + LPDISPATCH GetMergeArea(); + VARIANT GetMergeCells(); + void SetMergeCells(const VARIANT& newValue); + VARIANT GetName(); + void SetName(const VARIANT& newValue); + VARIANT NavigateArrow(const VARIANT& TowardPrecedent, const VARIANT& ArrowNumber, const VARIANT& LinkNumber); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH GetNext(); + CString NoteText(const VARIANT& Text, const VARIANT& Start, const VARIANT& Length); + VARIANT GetNumberFormat(); + void SetNumberFormat(const VARIANT& newValue); + VARIANT GetNumberFormatLocal(); + void SetNumberFormatLocal(const VARIANT& newValue); + LPDISPATCH GetOffset(const VARIANT& RowOffset, const VARIANT& ColumnOffset); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + VARIANT GetOutlineLevel(); + void SetOutlineLevel(const VARIANT& newValue); + long GetPageBreak(); + void SetPageBreak(long nNewValue); + VARIANT Parse(const VARIANT& ParseLine, const VARIANT& Destination); + LPDISPATCH GetPivotField(); + LPDISPATCH GetPivotItem(); + LPDISPATCH GetPivotTable(); + LPDISPATCH GetPrecedents(); + VARIANT GetPrefixCharacter(); + LPDISPATCH GetPrevious(); + VARIANT _PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate); + VARIANT PrintPreview(const VARIANT& EnableChanges); + LPDISPATCH GetQueryTable(); + LPDISPATCH GetRange(const VARIANT& Cell1, const VARIANT& Cell2); + VARIANT RemoveSubtotal(); + BOOL Replace(const VARIANT& What, const VARIANT& Replacement, const VARIANT& LookAt, const VARIANT& SearchOrder, const VARIANT& MatchCase, const VARIANT& MatchByte, const VARIANT& SearchFormat, const VARIANT& ReplaceFormat); + LPDISPATCH GetResize(const VARIANT& RowSize, const VARIANT& ColumnSize); + long GetRow(); + LPDISPATCH RowDifferences(const VARIANT& Comparison); + VARIANT GetRowHeight(); + void SetRowHeight(const VARIANT& newValue); + LPDISPATCH GetRows(); + VARIANT Run(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, + const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, + const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); + VARIANT Select(); + VARIANT Show(); + VARIANT ShowDependents(const VARIANT& Remove); + VARIANT GetShowDetail(); + void SetShowDetail(const VARIANT& newValue); + VARIANT ShowErrors(); + VARIANT ShowPrecedents(const VARIANT& Remove); + VARIANT GetShrinkToFit(); + void SetShrinkToFit(const VARIANT& newValue); + VARIANT Sort(const VARIANT& Key1, long Order1, const VARIANT& Key2, const VARIANT& Type, long Order2, const VARIANT& Key3, long Order3, long Header, const VARIANT& OrderCustom, const VARIANT& MatchCase, long Orientation, long SortMethod, + long DataOption1, long DataOption2, long DataOption3); + VARIANT SortSpecial(long SortMethod, const VARIANT& Key1, long Order1, const VARIANT& Type, const VARIANT& Key2, long Order2, const VARIANT& Key3, long Order3, long Header, const VARIANT& OrderCustom, const VARIANT& MatchCase, + long Orientation, long DataOption1, long DataOption2, long DataOption3); + LPDISPATCH GetSoundNote(); + LPDISPATCH SpecialCells(long Type, const VARIANT& Value); + VARIANT GetStyle(); + void SetStyle(const VARIANT& newValue); + VARIANT SubscribeTo(LPCTSTR Edition, long Format); + VARIANT Subtotal(long GroupBy, long Function, const VARIANT& TotalList, const VARIANT& Replace, const VARIANT& PageBreaks, long SummaryBelowData); + VARIANT GetSummary(); + VARIANT Table(const VARIANT& RowInput, const VARIANT& ColumnInput); + VARIANT GetText(); + VARIANT TextToColumns(const VARIANT& Destination, long DataType, long TextQualifier, const VARIANT& ConsecutiveDelimiter, const VARIANT& Tab, const VARIANT& Semicolon, const VARIANT& Comma, const VARIANT& Space, const VARIANT& Other, + const VARIANT& OtherChar, const VARIANT& FieldInfo, const VARIANT& DecimalSeparator, const VARIANT& ThousandsSeparator, const VARIANT& TrailingMinusNumbers); + VARIANT GetTop(); + VARIANT Ungroup(); + VARIANT GetUseStandardHeight(); + void SetUseStandardHeight(const VARIANT& newValue); + VARIANT GetUseStandardWidth(); + void SetUseStandardWidth(const VARIANT& newValue); + LPDISPATCH GetValidation(); + VARIANT GetValue(const VARIANT& RangeValueDataType); + void SetValue(const VARIANT& RangeValueDataType, const VARIANT& newValue); + VARIANT GetValue2(); + void SetValue2(const VARIANT& newValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + VARIANT GetWidth(); + LPDISPATCH GetWorksheet(); + VARIANT GetWrapText(); + void SetWrapText(const VARIANT& newValue); + LPDISPATCH AddComment(const VARIANT& Text); + LPDISPATCH GetComment(); + void ClearComments(); + LPDISPATCH GetPhonetic(); + LPDISPATCH GetFormatConditions(); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetHyperlinks(); + LPDISPATCH GetPhonetics(); + void SetPhonetic(); + CString GetId(); + void SetId(LPCTSTR lpszNewValue); + VARIANT PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); + LPDISPATCH GetPivotCell(); + void Dirty(); + LPDISPATCH GetErrors(); + LPDISPATCH GetSmartTags(); + void Speak(const VARIANT& SpeakDirection, const VARIANT& SpeakFormulas); + VARIANT PasteSpecial(long Paste, long Operation, const VARIANT& SkipBlanks, const VARIANT& Transpose); + BOOL GetAllowEdit(); + LPDISPATCH GetListObject(); + LPDISPATCH GetXPath(); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartEvents wrapper class + +class ChartEvents : public COleDispatchDriver +{ +public: + ChartEvents() {} // Calls COleDispatchDriver default constructor + ChartEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartEvents(const ChartEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + void Activate(); + void Deactivate(); + void Resize(); + void MouseDown(long Button, long Shift, long x, long y); + void MouseUp(long Button, long Shift, long x, long y); + void MouseMove(long Button, long Shift, long x, long y); + void BeforeRightClick(BOOL* Cancel); + void DragPlot(); + void DragOver(); + void BeforeDoubleClick(long ElementID, long Arg1, long Arg2, BOOL* Cancel); + void Select(long ElementID, long Arg1, long Arg2); + void SeriesChange(long SeriesIndex, long PointIndex); + void Calculate(); +}; +///////////////////////////////////////////////////////////////////////////// +// VPageBreak wrapper class + +class VPageBreak : public COleDispatchDriver +{ +public: + VPageBreak() {} // Calls COleDispatchDriver default constructor + VPageBreak(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + VPageBreak(const VPageBreak& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Delete(); + void DragOff(long Direction, long RegionIndex); + long GetType(); + void SetType(long nNewValue); + long GetExtent(); + LPDISPATCH GetLocation(); + void SetRefLocation(LPDISPATCH newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// HPageBreak wrapper class + +class HPageBreak : public COleDispatchDriver +{ +public: + HPageBreak() {} // Calls COleDispatchDriver default constructor + HPageBreak(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + HPageBreak(const HPageBreak& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Delete(); + void DragOff(long Direction, long RegionIndex); + long GetType(); + void SetType(long nNewValue); + long GetExtent(); + LPDISPATCH GetLocation(); + void SetRefLocation(LPDISPATCH newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// HPageBreaks wrapper class + +class HPageBreaks : public COleDispatchDriver +{ +public: + HPageBreaks() {} // Calls COleDispatchDriver default constructor + HPageBreaks(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + HPageBreaks(const HPageBreaks& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetItem(long Index); + LPDISPATCH Get_Default(long Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Add(LPDISPATCH Before); +}; +///////////////////////////////////////////////////////////////////////////// +// VPageBreaks wrapper class + +class VPageBreaks : public COleDispatchDriver +{ +public: + VPageBreaks() {} // Calls COleDispatchDriver default constructor + VPageBreaks(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + VPageBreaks(const VPageBreaks& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetItem(long Index); + LPDISPATCH Get_Default(long Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Add(LPDISPATCH Before); +}; +///////////////////////////////////////////////////////////////////////////// +// RecentFile wrapper class + +class RecentFile : public COleDispatchDriver +{ +public: + RecentFile() {} // Calls COleDispatchDriver default constructor + RecentFile(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + RecentFile(const RecentFile& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + CString GetPath(); + long GetIndex(); + LPDISPATCH Open(); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// RecentFiles wrapper class + +class RecentFiles : public COleDispatchDriver +{ +public: + RecentFiles() {} // Calls COleDispatchDriver default constructor + RecentFiles(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + RecentFiles(const RecentFiles& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetMaximum(); + void SetMaximum(long nNewValue); + long GetCount(); + LPDISPATCH GetItem(long Index); + LPDISPATCH Get_Default(long Index); + LPDISPATCH Add(LPCTSTR Name); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// DocEvents wrapper class + +class DocEvents : public COleDispatchDriver +{ +public: + DocEvents() {} // Calls COleDispatchDriver default constructor + DocEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DocEvents(const DocEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + void SelectionChange(LPDISPATCH Target); + void BeforeDoubleClick(LPDISPATCH Target, BOOL* Cancel); + void BeforeRightClick(LPDISPATCH Target, BOOL* Cancel); + void Activate(); + void Deactivate(); + void Calculate(); + void Change(LPDISPATCH Target); + void FollowHyperlink(LPDISPATCH Target); + void PivotTableUpdate(LPDISPATCH Target); +}; +///////////////////////////////////////////////////////////////////////////// +// Style wrapper class + +class Style : public COleDispatchDriver +{ +public: + Style() {} // Calls COleDispatchDriver default constructor + Style(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Style(const Style& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + BOOL GetBuiltIn(); + LPDISPATCH GetBorders(); + VARIANT Delete(); + LPDISPATCH GetFont(); + BOOL GetFormulaHidden(); + void SetFormulaHidden(BOOL bNewValue); + long GetHorizontalAlignment(); + void SetHorizontalAlignment(long nNewValue); + BOOL GetIncludeAlignment(); + void SetIncludeAlignment(BOOL bNewValue); + BOOL GetIncludeBorder(); + void SetIncludeBorder(BOOL bNewValue); + BOOL GetIncludeFont(); + void SetIncludeFont(BOOL bNewValue); + BOOL GetIncludeNumber(); + void SetIncludeNumber(BOOL bNewValue); + BOOL GetIncludePatterns(); + void SetIncludePatterns(BOOL bNewValue); + BOOL GetIncludeProtection(); + void SetIncludeProtection(BOOL bNewValue); + long GetIndentLevel(); + void SetIndentLevel(long nNewValue); + LPDISPATCH GetInterior(); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetMergeCells(); + void SetMergeCells(const VARIANT& newValue); + CString GetName(); + CString GetNameLocal(); + CString GetNumberFormat(); + void SetNumberFormat(LPCTSTR lpszNewValue); + CString GetNumberFormatLocal(); + void SetNumberFormatLocal(LPCTSTR lpszNewValue); + long GetOrientation(); + void SetOrientation(long nNewValue); + BOOL GetShrinkToFit(); + void SetShrinkToFit(BOOL bNewValue); + CString GetValue(); + long GetVerticalAlignment(); + void SetVerticalAlignment(long nNewValue); + BOOL GetWrapText(); + void SetWrapText(BOOL bNewValue); + CString Get_Default(); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Styles wrapper class + +class Styles : public COleDispatchDriver +{ +public: + Styles() {} // Calls COleDispatchDriver default constructor + Styles(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Styles(const Styles& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR Name, const VARIANT& BasedOn); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + VARIANT Merge(const VARIANT& Workbook); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Get_Default(const VARIANT& Index); +}; +///////////////////////////////////////////////////////////////////////////// +// Borders wrapper class + +class Borders : public COleDispatchDriver +{ +public: + Borders() {} // Calls COleDispatchDriver default constructor + Borders(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Borders(const Borders& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT GetColor(); + void SetColor(const VARIANT& newValue); + VARIANT GetColorIndex(); + void SetColorIndex(const VARIANT& newValue); + long GetCount(); + LPDISPATCH GetItem(long Index); + VARIANT GetLineStyle(); + void SetLineStyle(const VARIANT& newValue); + LPUNKNOWN Get_NewEnum(); + VARIANT GetValue(); + void SetValue(const VARIANT& newValue); + VARIANT GetWeight(); + void SetWeight(const VARIANT& newValue); + LPDISPATCH Get_Default(long Index); +}; +///////////////////////////////////////////////////////////////////////////// +// AddIn wrapper class + +class AddIn : public COleDispatchDriver +{ +public: + AddIn() {} // Calls COleDispatchDriver default constructor + AddIn(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AddIn(const AddIn& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetFullName(); + BOOL GetInstalled(); + void SetInstalled(BOOL bNewValue); + CString GetName(); + CString GetPath(); + CString GetProgID(); + CString GetClsid(); +}; +///////////////////////////////////////////////////////////////////////////// +// AddIns wrapper class + +class AddIns : public COleDispatchDriver +{ +public: + AddIns() {} // Calls COleDispatchDriver default constructor + AddIns(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AddIns(const AddIns& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR Filename, const VARIANT& CopyFile); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Get_Default(const VARIANT& Index); +}; +///////////////////////////////////////////////////////////////////////////// +// Toolbar wrapper class + +class Toolbar : public COleDispatchDriver +{ +public: + Toolbar() {} // Calls COleDispatchDriver default constructor + Toolbar(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Toolbar(const Toolbar& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetBuiltIn(); + void Delete(); + long GetHeight(); + void SetHeight(long nNewValue); + long GetLeft(); + void SetLeft(long nNewValue); + CString GetName(); + long GetPosition(); + void SetPosition(long nNewValue); + long GetProtection(); + void SetProtection(long nNewValue); + void Reset(); + LPDISPATCH GetToolbarButtons(); + long GetTop(); + void SetTop(long nNewValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + long GetWidth(); + void SetWidth(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Toolbars wrapper class + +class Toolbars : public COleDispatchDriver +{ +public: + Toolbars() {} // Calls COleDispatchDriver default constructor + Toolbars(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Toolbars(const Toolbars& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Name); + long GetCount(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// ToolbarButton wrapper class + +class ToolbarButton : public COleDispatchDriver +{ +public: + ToolbarButton() {} // Calls COleDispatchDriver default constructor + ToolbarButton(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ToolbarButton(const ToolbarButton& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetBuiltIn(); + BOOL GetBuiltInFace(); + void SetBuiltInFace(BOOL bNewValue); + void Copy(LPDISPATCH Toolbar, long Before); + void CopyFace(); + void Delete(); + void Edit(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + long GetHelpContextID(); + void SetHelpContextID(long nNewValue); + CString GetHelpFile(); + void SetHelpFile(LPCTSTR lpszNewValue); + long GetId(); + BOOL GetIsGap(); + void Move(LPDISPATCH Toolbar, long Before); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + CString GetOnAction(); + void SetOnAction(LPCTSTR lpszNewValue); + void PasteFace(); + BOOL GetPushed(); + void SetPushed(BOOL bNewValue); + void Reset(); + CString GetStatusBar(); + void SetStatusBar(LPCTSTR lpszNewValue); + long GetWidth(); + void SetWidth(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ToolbarButtons wrapper class + +class ToolbarButtons : public COleDispatchDriver +{ +public: + ToolbarButtons() {} // Calls COleDispatchDriver default constructor + ToolbarButtons(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ToolbarButtons(const ToolbarButtons& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Button, const VARIANT& Before, const VARIANT& OnAction, const VARIANT& Pushed, const VARIANT& Enabled, const VARIANT& StatusBar, const VARIANT& HelpFile, const VARIANT& HelpContextID); + long GetCount(); + LPDISPATCH GetItem(long Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Get_Default(long Index); +}; +///////////////////////////////////////////////////////////////////////////// +// Areas wrapper class + +class Areas : public COleDispatchDriver +{ +public: + Areas() {} // Calls COleDispatchDriver default constructor + Areas(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Areas(const Areas& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetItem(long Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Get_Default(long Index); +}; +///////////////////////////////////////////////////////////////////////////// +// WorkbookEvents wrapper class + +class WorkbookEvents : public COleDispatchDriver +{ +public: + WorkbookEvents() {} // Calls COleDispatchDriver default constructor + WorkbookEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + WorkbookEvents(const WorkbookEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + void Open(); + void Activate(); + void Deactivate(); + void BeforeClose(BOOL* Cancel); + void BeforeSave(BOOL SaveAsUI, BOOL* Cancel); + void BeforePrint(BOOL* Cancel); + void NewSheet(LPDISPATCH Sh); + void AddinInstall(); + void AddinUninstall(); + void WindowResize(LPDISPATCH Wn); + void WindowActivate(LPDISPATCH Wn); + void WindowDeactivate(LPDISPATCH Wn); + void SheetSelectionChange(LPDISPATCH Sh, LPDISPATCH Target); + void SheetBeforeDoubleClick(LPDISPATCH Sh, LPDISPATCH Target, BOOL* Cancel); + void SheetBeforeRightClick(LPDISPATCH Sh, LPDISPATCH Target, BOOL* Cancel); + void SheetActivate(LPDISPATCH Sh); + void SheetDeactivate(LPDISPATCH Sh); + void SheetCalculate(LPDISPATCH Sh); + void SheetChange(LPDISPATCH Sh, LPDISPATCH Target); + void SheetFollowHyperlink(LPDISPATCH Sh, LPDISPATCH Target); + void SheetPivotTableUpdate(LPDISPATCH Sh, LPDISPATCH Target); + void PivotTableCloseConnection(LPDISPATCH Target); + void PivotTableOpenConnection(LPDISPATCH Target); + void Sync(long SyncEventType); + void BeforeXmlImport(LPDISPATCH Map, LPCTSTR Url, BOOL IsRefresh, BOOL* Cancel); + void AfterXmlImport(LPDISPATCH Map, BOOL IsRefresh, long Result); + void BeforeXmlExport(LPDISPATCH Map, LPCTSTR Url, BOOL* Cancel); + void AfterXmlExport(LPDISPATCH Map, LPCTSTR Url, long Result); +}; +///////////////////////////////////////////////////////////////////////////// +// MenuBars wrapper class + +class MenuBars : public COleDispatchDriver +{ +public: + MenuBars() {} // Calls COleDispatchDriver default constructor + MenuBars(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + MenuBars(const MenuBars& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Name); + long GetCount(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// MenuBar wrapper class + +class MenuBar : public COleDispatchDriver +{ +public: + MenuBar() {} // Calls COleDispatchDriver default constructor + MenuBar(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + MenuBar(const MenuBar& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Activate(); + BOOL GetBuiltIn(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + void Delete(); + long GetIndex(); + LPDISPATCH GetMenus(); + void Reset(); +}; +///////////////////////////////////////////////////////////////////////////// +// Menus wrapper class + +class Menus : public COleDispatchDriver +{ +public: + Menus() {} // Calls COleDispatchDriver default constructor + Menus(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Menus(const Menus& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR Caption, const VARIANT& Before, const VARIANT& Restore); + long GetCount(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Menu wrapper class + +class Menu : public COleDispatchDriver +{ +public: + Menu() {} // Calls COleDispatchDriver default constructor + Menu(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Menu(const Menu& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + void Delete(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + long GetIndex(); + LPDISPATCH GetMenuItems(); +}; +///////////////////////////////////////////////////////////////////////////// +// MenuItems wrapper class + +class MenuItems : public COleDispatchDriver +{ +public: + MenuItems() {} // Calls COleDispatchDriver default constructor + MenuItems(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + MenuItems(const MenuItems& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR Caption, const VARIANT& OnAction, const VARIANT& ShortcutKey, const VARIANT& Before, const VARIANT& Restore, const VARIANT& StatusBar, const VARIANT& HelpFile, const VARIANT& HelpContextID); + LPDISPATCH AddMenu(LPCTSTR Caption, const VARIANT& Before, const VARIANT& Restore); + long GetCount(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// MenuItem wrapper class + +class MenuItem : public COleDispatchDriver +{ +public: + MenuItem() {} // Calls COleDispatchDriver default constructor + MenuItem(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + MenuItem(const MenuItem& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + BOOL GetChecked(); + void SetChecked(BOOL bNewValue); + void Delete(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + long GetHelpContextID(); + void SetHelpContextID(long nNewValue); + CString GetHelpFile(); + void SetHelpFile(LPCTSTR lpszNewValue); + long GetIndex(); + CString GetOnAction(); + void SetOnAction(LPCTSTR lpszNewValue); + CString GetStatusBar(); + void SetStatusBar(LPCTSTR lpszNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Charts wrapper class + +class Charts : public COleDispatchDriver +{ +public: + Charts() {} // Calls COleDispatchDriver default constructor + Charts(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Charts(const Charts& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count); + void Copy(const VARIANT& Before, const VARIANT& After); + long GetCount(); + void Delete(); + LPDISPATCH GetItem(const VARIANT& Index); + void Move(const VARIANT& Before, const VARIANT& After); + LPUNKNOWN Get_NewEnum(); + void PrintPreview(const VARIANT& EnableChanges); + void Select(const VARIANT& Replace); + LPDISPATCH GetHPageBreaks(); + LPDISPATCH GetVPageBreaks(); + VARIANT GetVisible(); + void SetVisible(const VARIANT& newValue); + LPDISPATCH Get_Default(const VARIANT& Index); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); +}; +///////////////////////////////////////////////////////////////////////////// +// DrawingObjects wrapper class + +class DrawingObjects : public COleDispatchDriver +{ +public: + DrawingObjects() {} // Calls COleDispatchDriver default constructor + DrawingObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DrawingObjects(const DrawingObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT AddItem(const VARIANT& Text, const VARIANT& Index); + VARIANT GetArrowHeadLength(); + void SetArrowHeadLength(const VARIANT& newValue); + VARIANT GetArrowHeadStyle(); + void SetArrowHeadStyle(const VARIANT& newValue); + VARIANT GetArrowHeadWidth(); + void SetArrowHeadWidth(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + LPDISPATCH GetBorder(); + BOOL GetCancelButton(); + void SetCancelButton(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDefaultButton(); + void SetDefaultButton(BOOL bNewValue); + BOOL GetDismissButton(); + void SetDismissButton(BOOL bNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + BOOL GetDisplayVerticalScrollBar(); + void SetDisplayVerticalScrollBar(BOOL bNewValue); + long GetDropDownLines(); + void SetDropDownLines(long nNewValue); + LPDISPATCH GetFont(); + BOOL GetHelpButton(); + void SetHelpButton(BOOL bNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + long GetInputType(); + void SetInputType(long nNewValue); + LPDISPATCH GetInterior(); + long GetLargeChange(); + void SetLargeChange(long nNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT List(const VARIANT& Index); + CString GetListFillRange(); + void SetListFillRange(LPCTSTR lpszNewValue); + long GetListIndex(); + void SetListIndex(long nNewValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + long GetMax(); + void SetMax(long nNewValue); + long GetMin(); + void SetMin(long nNewValue); + BOOL GetMultiLine(); + void SetMultiLine(BOOL bNewValue); + BOOL GetMultiSelect(); + void SetMultiSelect(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); + VARIANT RemoveAllItems(); + VARIANT RemoveItem(long Index, const VARIANT& Count); + VARIANT Reshape(long Vertex, const VARIANT& Insert, const VARIANT& Left, const VARIANT& Top); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); + VARIANT Selected(const VARIANT& Index); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + long GetSmallChange(); + void SetSmallChange(long nNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + LPDISPATCH Ungroup(); + long GetValue(); + void SetValue(long nNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + VARIANT Vertices(const VARIANT& Index1, const VARIANT& Index2); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Group(); + VARIANT LinkCombo(const VARIANT& Link); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotCache wrapper class + +class PivotCache : public COleDispatchDriver +{ +public: + PivotCache() {} // Calls COleDispatchDriver default constructor + PivotCache(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotCache(const PivotCache& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetBackgroundQuery(); + void SetBackgroundQuery(BOOL bNewValue); + VARIANT GetConnection(); + void SetConnection(const VARIANT& newValue); + BOOL GetEnableRefresh(); + void SetEnableRefresh(BOOL bNewValue); + long GetIndex(); + long GetMemoryUsed(); + BOOL GetOptimizeCache(); + void SetOptimizeCache(BOOL bNewValue); + long GetRecordCount(); + void Refresh(); + DATE GetRefreshDate(); + CString GetRefreshName(); + BOOL GetRefreshOnFileOpen(); + void SetRefreshOnFileOpen(BOOL bNewValue); + BOOL GetSavePassword(); + void SetSavePassword(BOOL bNewValue); + VARIANT GetSourceData(); + void SetSourceData(const VARIANT& newValue); + VARIANT GetCommandText(); + void SetCommandText(const VARIANT& newValue); + long GetCommandType(); + void SetCommandType(long nNewValue); + long GetQueryType(); + BOOL GetMaintainConnection(); + void SetMaintainConnection(BOOL bNewValue); + long GetRefreshPeriod(); + void SetRefreshPeriod(long nNewValue); + LPDISPATCH GetRecordset(); + void SetRefRecordset(LPDISPATCH newValue); + void ResetTimer(); + VARIANT GetLocalConnection(); + void SetLocalConnection(const VARIANT& newValue); + LPDISPATCH CreatePivotTable(const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& ReadData, const VARIANT& DefaultVersion); + BOOL GetUseLocalConnection(); + void SetUseLocalConnection(BOOL bNewValue); + LPDISPATCH GetADOConnection(); + BOOL GetIsConnected(); + void MakeConnection(); + BOOL GetOlap(); + long GetSourceType(); + long GetMissingItemsLimit(); + void SetMissingItemsLimit(long nNewValue); + CString GetSourceConnectionFile(); + void SetSourceConnectionFile(LPCTSTR lpszNewValue); + CString GetSourceDataFile(); + long GetRobustConnect(); + void SetRobustConnect(long nNewValue); + void SaveAsODC(LPCTSTR ODCFileName, const VARIANT& Description, const VARIANT& Keywords); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotCaches wrapper class + +class PivotCaches : public COleDispatchDriver +{ +public: + PivotCaches() {} // Calls COleDispatchDriver default constructor + PivotCaches(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotCaches(const PivotCaches& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN _NewEnum(); + LPDISPATCH Add(long SourceType, const VARIANT& SourceData); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotFormula wrapper class + +class PivotFormula : public COleDispatchDriver +{ +public: + PivotFormula() {} // Calls COleDispatchDriver default constructor + PivotFormula(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotFormula(const PivotFormula& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Delete(); + CString Get_Default(); + void Set_Default(LPCTSTR lpszNewValue); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + CString GetValue(); + void SetValue(LPCTSTR lpszNewValue); + long GetIndex(); + void SetIndex(long nNewValue); + CString GetStandardFormula(); + void SetStandardFormula(LPCTSTR lpszNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotFormulas wrapper class + +class PivotFormulas : public COleDispatchDriver +{ +public: + PivotFormulas() {} // Calls COleDispatchDriver default constructor + PivotFormulas(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotFormulas(const PivotFormulas& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN _NewEnum(); + LPDISPATCH Add(LPCTSTR Formula, const VARIANT& UseStandardFormula); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotTable wrapper class + +class PivotTable : public COleDispatchDriver +{ +public: + PivotTable() {} // Calls COleDispatchDriver default constructor + PivotTable(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotTable(const PivotTable& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT AddFields(const VARIANT& RowFields, const VARIANT& ColumnFields, const VARIANT& PageFields, const VARIANT& AddToTable); + LPDISPATCH GetColumnFields(const VARIANT& Index); + BOOL GetColumnGrand(); + void SetColumnGrand(BOOL bNewValue); + LPDISPATCH GetColumnRange(); + VARIANT ShowPages(const VARIANT& PageField); + LPDISPATCH GetDataBodyRange(); + LPDISPATCH GetDataFields(const VARIANT& Index); + LPDISPATCH GetDataLabelRange(); + CString Get_Default(); + void Set_Default(LPCTSTR lpszNewValue); + BOOL GetHasAutoFormat(); + void SetHasAutoFormat(BOOL bNewValue); + LPDISPATCH GetHiddenFields(const VARIANT& Index); + CString GetInnerDetail(); + void SetInnerDetail(LPCTSTR lpszNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetPageFields(const VARIANT& Index); + LPDISPATCH GetPageRange(); + LPDISPATCH GetPageRangeCells(); + LPDISPATCH PivotFields(const VARIANT& Index); + DATE GetRefreshDate(); + CString GetRefreshName(); + BOOL RefreshTable(); + LPDISPATCH GetRowFields(const VARIANT& Index); + BOOL GetRowGrand(); + void SetRowGrand(BOOL bNewValue); + LPDISPATCH GetRowRange(); + BOOL GetSaveData(); + void SetSaveData(BOOL bNewValue); + VARIANT GetSourceData(); + void SetSourceData(const VARIANT& newValue); + LPDISPATCH GetTableRange1(); + LPDISPATCH GetTableRange2(); + CString GetValue(); + void SetValue(LPCTSTR lpszNewValue); + LPDISPATCH GetVisibleFields(const VARIANT& Index); + long GetCacheIndex(); + void SetCacheIndex(long nNewValue); + LPDISPATCH CalculatedFields(); + BOOL GetDisplayErrorString(); + void SetDisplayErrorString(BOOL bNewValue); + BOOL GetDisplayNullString(); + void SetDisplayNullString(BOOL bNewValue); + BOOL GetEnableDrilldown(); + void SetEnableDrilldown(BOOL bNewValue); + BOOL GetEnableFieldDialog(); + void SetEnableFieldDialog(BOOL bNewValue); + BOOL GetEnableWizard(); + void SetEnableWizard(BOOL bNewValue); + CString GetErrorString(); + void SetErrorString(LPCTSTR lpszNewValue); + double GetData(LPCTSTR Name); + void ListFormulas(); + BOOL GetManualUpdate(); + void SetManualUpdate(BOOL bNewValue); + BOOL GetMergeLabels(); + void SetMergeLabels(BOOL bNewValue); + CString GetNullString(); + void SetNullString(LPCTSTR lpszNewValue); + LPDISPATCH PivotCache(); + LPDISPATCH GetPivotFormulas(); + void PivotTableWizard(const VARIANT& SourceType, const VARIANT& SourceData, const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& RowGrand, const VARIANT& ColumnGrand, const VARIANT& SaveData, const VARIANT& HasAutoFormat, + const VARIANT& AutoPage, const VARIANT& Reserved, const VARIANT& BackgroundQuery, const VARIANT& OptimizeCache, const VARIANT& PageFieldOrder, const VARIANT& PageFieldWrapCount, const VARIANT& ReadData, const VARIANT& Connection); + BOOL GetSubtotalHiddenPageItems(); + void SetSubtotalHiddenPageItems(BOOL bNewValue); + long GetPageFieldOrder(); + void SetPageFieldOrder(long nNewValue); + CString GetPageFieldStyle(); + void SetPageFieldStyle(LPCTSTR lpszNewValue); + long GetPageFieldWrapCount(); + void SetPageFieldWrapCount(long nNewValue); + BOOL GetPreserveFormatting(); + void SetPreserveFormatting(BOOL bNewValue); + CString GetPivotSelection(); + void SetPivotSelection(LPCTSTR lpszNewValue); + long GetSelectionMode(); + void SetSelectionMode(long nNewValue); + CString GetTableStyle(); + void SetTableStyle(LPCTSTR lpszNewValue); + CString GetTag(); + void SetTag(LPCTSTR lpszNewValue); + void Update(); + CString GetVacatedStyle(); + void SetVacatedStyle(LPCTSTR lpszNewValue); + void Format(long Format); + BOOL GetPrintTitles(); + void SetPrintTitles(BOOL bNewValue); + LPDISPATCH GetCubeFields(); + CString GetGrandTotalName(); + void SetGrandTotalName(LPCTSTR lpszNewValue); + BOOL GetSmallGrid(); + void SetSmallGrid(BOOL bNewValue); + BOOL GetRepeatItemsOnEachPrintedPage(); + void SetRepeatItemsOnEachPrintedPage(BOOL bNewValue); + BOOL GetTotalsAnnotation(); + void SetTotalsAnnotation(BOOL bNewValue); + void PivotSelect(LPCTSTR Name, long Mode, const VARIANT& UseStandardName); + CString GetPivotSelectionStandard(); + void SetPivotSelectionStandard(LPCTSTR lpszNewValue); + LPDISPATCH GetPivotData(const VARIANT& DataField, const VARIANT& Field1, const VARIANT& Item1, const VARIANT& Field2, const VARIANT& Item2, const VARIANT& Field3, const VARIANT& Item3, const VARIANT& Field4, const VARIANT& Item4, + const VARIANT& Field5, const VARIANT& Item5, const VARIANT& Field6, const VARIANT& Item6, const VARIANT& Field7, const VARIANT& Item7, const VARIANT& Field8, const VARIANT& Item8, const VARIANT& Field9, const VARIANT& Item9, + const VARIANT& Field10, const VARIANT& Item10, const VARIANT& Field11, const VARIANT& Item11, const VARIANT& Field12, const VARIANT& Item12, const VARIANT& Field13, const VARIANT& Item13, const VARIANT& Field14, const VARIANT& Item14); + LPDISPATCH GetDataPivotField(); + BOOL GetEnableDataValueEditing(); + void SetEnableDataValueEditing(BOOL bNewValue); + LPDISPATCH AddDataField(LPDISPATCH Field, const VARIANT& Caption, const VARIANT& Function); + CString GetMdx(); + BOOL GetViewCalculatedMembers(); + void SetViewCalculatedMembers(BOOL bNewValue); + LPDISPATCH GetCalculatedMembers(); + BOOL GetDisplayImmediateItems(); + void SetDisplayImmediateItems(BOOL bNewValue); + BOOL GetEnableFieldList(); + void SetEnableFieldList(BOOL bNewValue); + BOOL GetVisualTotals(); + void SetVisualTotals(BOOL bNewValue); + BOOL GetShowPageMultipleItemLabel(); + void SetShowPageMultipleItemLabel(BOOL bNewValue); + long GetVersion(); + CString CreateCubeFile(LPCTSTR File, const VARIANT& Measures, const VARIANT& Levels, const VARIANT& Members, const VARIANT& Properties); + BOOL GetDisplayEmptyRow(); + void SetDisplayEmptyRow(BOOL bNewValue); + BOOL GetDisplayEmptyColumn(); + void SetDisplayEmptyColumn(BOOL bNewValue); + BOOL GetShowCellBackgroundFromOLAP(); + void SetShowCellBackgroundFromOLAP(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotTables wrapper class + +class PivotTables : public COleDispatchDriver +{ +public: + PivotTables() {} // Calls COleDispatchDriver default constructor + PivotTables(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotTables(const PivotTables& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); + LPDISPATCH Add(LPDISPATCH PivotCache, const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& ReadData, const VARIANT& DefaultVersion); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotField wrapper class + +class PivotField : public COleDispatchDriver +{ +public: + PivotField() {} // Calls COleDispatchDriver default constructor + PivotField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotField(const PivotField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCalculation(); + void SetCalculation(long nNewValue); + LPDISPATCH GetChildField(); + VARIANT GetChildItems(const VARIANT& Index); + VARIANT GetCurrentPage(); + void SetCurrentPage(const VARIANT& newValue); + LPDISPATCH GetDataRange(); + long GetDataType(); + CString Get_Default(); + void Set_Default(LPCTSTR lpszNewValue); + long GetFunction(); + void SetFunction(long nNewValue); + VARIANT GetGroupLevel(); + VARIANT GetHiddenItems(const VARIANT& Index); + LPDISPATCH GetLabelRange(); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + CString GetNumberFormat(); + void SetNumberFormat(LPCTSTR lpszNewValue); + long GetOrientation(); + void SetOrientation(long nNewValue); + BOOL GetShowAllItems(); + void SetShowAllItems(BOOL bNewValue); + LPDISPATCH GetParentField(); + VARIANT GetParentItems(const VARIANT& Index); + VARIANT PivotItems(const VARIANT& Index); + VARIANT GetPosition(); + void SetPosition(const VARIANT& newValue); + CString GetSourceName(); + VARIANT GetSubtotals(const VARIANT& Index); + void SetSubtotals(const VARIANT& Index, const VARIANT& newValue); + VARIANT GetBaseField(); + void SetBaseField(const VARIANT& newValue); + VARIANT GetBaseItem(); + void SetBaseItem(const VARIANT& newValue); + VARIANT GetTotalLevels(); + CString GetValue(); + void SetValue(LPCTSTR lpszNewValue); + VARIANT GetVisibleItems(const VARIANT& Index); + LPDISPATCH CalculatedItems(); + void Delete(); + BOOL GetDragToColumn(); + void SetDragToColumn(BOOL bNewValue); + BOOL GetDragToHide(); + void SetDragToHide(BOOL bNewValue); + BOOL GetDragToPage(); + void SetDragToPage(BOOL bNewValue); + BOOL GetDragToRow(); + void SetDragToRow(BOOL bNewValue); + BOOL GetDragToData(); + void SetDragToData(BOOL bNewValue); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + BOOL GetIsCalculated(); + long GetMemoryUsed(); + BOOL GetServerBased(); + void SetServerBased(BOOL bNewValue); + void AutoSort(long Order, LPCTSTR Field); + void AutoShow(long Type, long Range, long Count, LPCTSTR Field); + long GetAutoSortOrder(); + CString GetAutoSortField(); + long GetAutoShowType(); + long GetAutoShowRange(); + long GetAutoShowCount(); + CString GetAutoShowField(); + BOOL GetLayoutBlankLine(); + void SetLayoutBlankLine(BOOL bNewValue); + long GetLayoutSubtotalLocation(); + void SetLayoutSubtotalLocation(long nNewValue); + BOOL GetLayoutPageBreak(); + void SetLayoutPageBreak(BOOL bNewValue); + long GetLayoutForm(); + void SetLayoutForm(long nNewValue); + CString GetSubtotalName(); + void SetSubtotalName(LPCTSTR lpszNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + BOOL GetDrilledDown(); + void SetDrilledDown(BOOL bNewValue); + LPDISPATCH GetCubeField(); + CString GetCurrentPageName(); + void SetCurrentPageName(LPCTSTR lpszNewValue); + CString GetStandardFormula(); + void SetStandardFormula(LPCTSTR lpszNewValue); + VARIANT GetHiddenItemsList(); + void SetHiddenItemsList(const VARIANT& newValue); + BOOL GetDatabaseSort(); + void SetDatabaseSort(BOOL bNewValue); + BOOL GetIsMemberProperty(); + LPDISPATCH GetPropertyParentField(); + long GetPropertyOrder(); + void SetPropertyOrder(long nNewValue); + BOOL GetEnableItemSelection(); + void SetEnableItemSelection(BOOL bNewValue); + VARIANT GetCurrentPageList(); + void SetCurrentPageList(const VARIANT& newValue); + void AddPageItem(LPCTSTR Item, const VARIANT& ClearList); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotFields wrapper class + +class PivotFields : public COleDispatchDriver +{ +public: + PivotFields() {} // Calls COleDispatchDriver default constructor + PivotFields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotFields(const PivotFields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// CalculatedFields wrapper class + +class CalculatedFields : public COleDispatchDriver +{ +public: + CalculatedFields() {} // Calls COleDispatchDriver default constructor + CalculatedFields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CalculatedFields(const CalculatedFields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Field); + LPUNKNOWN _NewEnum(); + LPDISPATCH Add(LPCTSTR Name, LPCTSTR Formula, const VARIANT& UseStandardFormula); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotItem wrapper class + +class PivotItem : public COleDispatchDriver +{ +public: + PivotItem() {} // Calls COleDispatchDriver default constructor + PivotItem(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotItem(const PivotItem& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT GetChildItems(const VARIANT& Index); + LPDISPATCH GetDataRange(); + CString Get_Default(); + void Set_Default(LPCTSTR lpszNewValue); + LPDISPATCH GetLabelRange(); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetParentItem(); + BOOL GetParentShowDetail(); + long GetPosition(); + void SetPosition(long nNewValue); + BOOL GetShowDetail(); + void SetShowDetail(BOOL bNewValue); + VARIANT GetSourceName(); + CString GetValue(); + void SetValue(LPCTSTR lpszNewValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + void Delete(); + BOOL GetIsCalculated(); + long GetRecordCount(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + BOOL GetDrilledDown(); + void SetDrilledDown(BOOL bNewValue); + CString GetStandardFormula(); + void SetStandardFormula(LPCTSTR lpszNewValue); + CString GetSourceNameStandard(); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotItems wrapper class + +class PivotItems : public COleDispatchDriver +{ +public: + PivotItems() {} // Calls COleDispatchDriver default constructor + PivotItems(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotItems(const PivotItems& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Add(LPCTSTR Name); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// CalculatedItems wrapper class + +class CalculatedItems : public COleDispatchDriver +{ +public: + CalculatedItems() {} // Calls COleDispatchDriver default constructor + CalculatedItems(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CalculatedItems(const CalculatedItems& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Field); + LPUNKNOWN _NewEnum(); + LPDISPATCH Add(LPCTSTR Name, LPCTSTR Formula, const VARIANT& UseStandardFormula); +}; +///////////////////////////////////////////////////////////////////////////// +// Characters wrapper class + +class Characters : public COleDispatchDriver +{ +public: + Characters() {} // Calls COleDispatchDriver default constructor + Characters(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Characters(const Characters& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + long GetCount(); + VARIANT Delete(); + LPDISPATCH GetFont(); + VARIANT Insert(LPCTSTR String); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + CString GetPhoneticCharacters(); + void SetPhoneticCharacters(LPCTSTR lpszNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Dialogs wrapper class + +class Dialogs : public COleDispatchDriver +{ +public: + Dialogs() {} // Calls COleDispatchDriver default constructor + Dialogs(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Dialogs(const Dialogs& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetItem(long Index); + LPDISPATCH Get_Default(long Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Dialog wrapper class + +class Dialog : public COleDispatchDriver +{ +public: + Dialog() {} // Calls COleDispatchDriver default constructor + Dialog(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Dialog(const Dialog& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL Show(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, const VARIANT& Arg11, + const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, const VARIANT& Arg21, + const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30); +}; +///////////////////////////////////////////////////////////////////////////// +// SoundNote wrapper class + +class SoundNote : public COleDispatchDriver +{ +public: + SoundNote() {} // Calls COleDispatchDriver default constructor + SoundNote(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SoundNote(const SoundNote& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT Delete(); + VARIANT Import(LPCTSTR Filename); + VARIANT Play(); + VARIANT Record(); +}; +///////////////////////////////////////////////////////////////////////////// +// Button wrapper class + +class Button : public COleDispatchDriver +{ +public: + Button() {} // Calls COleDispatchDriver default constructor + Button(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Button(const Button& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + BOOL GetCancelButton(); + void SetCancelButton(BOOL bNewValue); + BOOL GetDefaultButton(); + void SetDefaultButton(BOOL bNewValue); + BOOL GetDismissButton(); + void SetDismissButton(BOOL bNewValue); + BOOL GetHelpButton(); + void SetHelpButton(BOOL bNewValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Buttons wrapper class + +class Buttons : public COleDispatchDriver +{ +public: + Buttons() {} // Calls COleDispatchDriver default constructor + Buttons(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Buttons(const Buttons& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + BOOL GetCancelButton(); + void SetCancelButton(BOOL bNewValue); + BOOL GetDefaultButton(); + void SetDefaultButton(BOOL bNewValue); + BOOL GetDismissButton(); + void SetDismissButton(BOOL bNewValue); + BOOL GetHelpButton(); + void SetHelpButton(BOOL bNewValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// CheckBox wrapper class + +class CheckBox : public COleDispatchDriver +{ +public: + CheckBox() {} // Calls COleDispatchDriver default constructor + CheckBox(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CheckBox(const CheckBox& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + LPDISPATCH GetBorder(); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + LPDISPATCH GetInterior(); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); + VARIANT GetValue(); + void SetValue(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// CheckBoxes wrapper class + +class CheckBoxes : public COleDispatchDriver +{ +public: + CheckBoxes() {} // Calls COleDispatchDriver default constructor + CheckBoxes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CheckBoxes(const CheckBoxes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + LPDISPATCH GetBorder(); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + LPDISPATCH GetInterior(); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); + VARIANT GetValue(); + void SetValue(const VARIANT& newValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// OptionButton wrapper class + +class OptionButton : public COleDispatchDriver +{ +public: + OptionButton() {} // Calls COleDispatchDriver default constructor + OptionButton(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + OptionButton(const OptionButton& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + LPDISPATCH GetBorder(); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + LPDISPATCH GetInterior(); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); + VARIANT GetValue(); + void SetValue(const VARIANT& newValue); + LPDISPATCH GetGroupBox(); +}; +///////////////////////////////////////////////////////////////////////////// +// OptionButtons wrapper class + +class OptionButtons : public COleDispatchDriver +{ +public: + OptionButtons() {} // Calls COleDispatchDriver default constructor + OptionButtons(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + OptionButtons(const OptionButtons& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + LPDISPATCH GetBorder(); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + LPDISPATCH GetInterior(); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); + VARIANT GetValue(); + void SetValue(const VARIANT& newValue); + LPDISPATCH GetGroupBox(); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// EditBox wrapper class + +class EditBox : public COleDispatchDriver +{ +public: + EditBox() {} // Calls COleDispatchDriver default constructor + EditBox(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + EditBox(const EditBox& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + BOOL GetDisplayVerticalScrollBar(); + void SetDisplayVerticalScrollBar(BOOL bNewValue); + long GetInputType(); + void SetInputType(long nNewValue); + CString GetLinkedObject(); + BOOL GetMultiLine(); + void SetMultiLine(BOOL bNewValue); + BOOL GetPasswordEdit(); + void SetPasswordEdit(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// EditBoxes wrapper class + +class EditBoxes : public COleDispatchDriver +{ +public: + EditBoxes() {} // Calls COleDispatchDriver default constructor + EditBoxes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + EditBoxes(const EditBoxes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + BOOL GetDisplayVerticalScrollBar(); + void SetDisplayVerticalScrollBar(BOOL bNewValue); + long GetInputType(); + void SetInputType(long nNewValue); + BOOL GetMultiLine(); + void SetMultiLine(BOOL bNewValue); + BOOL GetPasswordEdit(); + void SetPasswordEdit(BOOL bNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + VARIANT Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// ScrollBar wrapper class + +class ScrollBar : public COleDispatchDriver +{ +public: + ScrollBar() {} // Calls COleDispatchDriver default constructor + ScrollBar(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ScrollBar(const ScrollBar& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + long GetMax(); + void SetMax(long nNewValue); + long GetMin(); + void SetMin(long nNewValue); + long GetSmallChange(); + void SetSmallChange(long nNewValue); + long GetValue(); + void SetValue(long nNewValue); + long GetLargeChange(); + void SetLargeChange(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ScrollBars wrapper class + +class ScrollBars : public COleDispatchDriver +{ +public: + ScrollBars() {} // Calls COleDispatchDriver default constructor + ScrollBars(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ScrollBars(const ScrollBars& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + long GetMax(); + void SetMax(long nNewValue); + long GetMin(); + void SetMin(long nNewValue); + long GetSmallChange(); + void SetSmallChange(long nNewValue); + long GetValue(); + void SetValue(long nNewValue); + long GetLargeChange(); + void SetLargeChange(long nNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// ListBox wrapper class + +class ListBox : public COleDispatchDriver +{ +public: + ListBox() {} // Calls COleDispatchDriver default constructor + ListBox(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListBox(const ListBox& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + VARIANT AddItem(const VARIANT& Text, const VARIANT& Index); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + long Get_Default(); + void Set_Default(long nNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT GetLinkedObject(); + VARIANT GetList(const VARIANT& Index); + void SetList(const VARIANT& Index, const VARIANT& newValue); + long GetListCount(); + CString GetListFillRange(); + void SetListFillRange(LPCTSTR lpszNewValue); + long GetListIndex(); + void SetListIndex(long nNewValue); + long GetMultiSelect(); + void SetMultiSelect(long nNewValue); + VARIANT RemoveAllItems(); + VARIANT RemoveItem(long Index, const VARIANT& Count); + VARIANT GetSelected(const VARIANT& Index); + void SetSelected(const VARIANT& Index, const VARIANT& newValue); + long GetValue(); + void SetValue(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ListBoxes wrapper class + +class ListBoxes : public COleDispatchDriver +{ +public: + ListBoxes() {} // Calls COleDispatchDriver default constructor + ListBoxes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListBoxes(const ListBoxes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + VARIANT AddItem(const VARIANT& Text, const VARIANT& Index); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + long Get_Default(); + void Set_Default(long nNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT GetList(const VARIANT& Index); + void SetList(const VARIANT& Index, const VARIANT& newValue); + CString GetListFillRange(); + void SetListFillRange(LPCTSTR lpszNewValue); + long GetListIndex(); + void SetListIndex(long nNewValue); + long GetMultiSelect(); + void SetMultiSelect(long nNewValue); + VARIANT RemoveAllItems(); + VARIANT RemoveItem(long Index, const VARIANT& Count); + VARIANT GetSelected(const VARIANT& Index); + void SetSelected(const VARIANT& Index, const VARIANT& newValue); + long GetValue(); + void SetValue(long nNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// GroupBox wrapper class + +class GroupBox : public COleDispatchDriver +{ +public: + GroupBox() {} // Calls COleDispatchDriver default constructor + GroupBox(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + GroupBox(const GroupBox& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// GroupBoxes wrapper class + +class GroupBoxes : public COleDispatchDriver +{ +public: + GroupBoxes() {} // Calls COleDispatchDriver default constructor + GroupBoxes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + GroupBoxes(const GroupBoxes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// DropDown wrapper class + +class DropDown : public COleDispatchDriver +{ +public: + DropDown() {} // Calls COleDispatchDriver default constructor + DropDown(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DropDown(const DropDown& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + VARIANT AddItem(const VARIANT& Text, const VARIANT& Index); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + long Get_Default(); + void Set_Default(long nNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT GetLinkedObject(); + VARIANT GetList(const VARIANT& Index); + void SetList(const VARIANT& Index, const VARIANT& newValue); + long GetListCount(); + CString GetListFillRange(); + void SetListFillRange(LPCTSTR lpszNewValue); + long GetListIndex(); + void SetListIndex(long nNewValue); + VARIANT RemoveAllItems(); + VARIANT RemoveItem(long Index, const VARIANT& Count); + VARIANT GetSelected(const VARIANT& Index); + void SetSelected(const VARIANT& Index, const VARIANT& newValue); + long GetValue(); + void SetValue(long nNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + long GetDropDownLines(); + void SetDropDownLines(long nNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// DropDowns wrapper class + +class DropDowns : public COleDispatchDriver +{ +public: + DropDowns() {} // Calls COleDispatchDriver default constructor + DropDowns(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DropDowns(const DropDowns& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + VARIANT AddItem(const VARIANT& Text, const VARIANT& Index); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + long Get_Default(); + void Set_Default(long nNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT GetList(const VARIANT& Index); + void SetList(const VARIANT& Index, const VARIANT& newValue); + CString GetListFillRange(); + void SetListFillRange(LPCTSTR lpszNewValue); + long GetListIndex(); + void SetListIndex(long nNewValue); + VARIANT RemoveAllItems(); + VARIANT RemoveItem(long Index, const VARIANT& Count); + VARIANT GetSelected(const VARIANT& Index); + void SetSelected(const VARIANT& Index, const VARIANT& newValue); + long GetValue(); + void SetValue(long nNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + long GetDropDownLines(); + void SetDropDownLines(long nNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height, const VARIANT& Editable); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Spinner wrapper class + +class Spinner : public COleDispatchDriver +{ +public: + Spinner() {} // Calls COleDispatchDriver default constructor + Spinner(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Spinner(const Spinner& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + long GetMax(); + void SetMax(long nNewValue); + long GetMin(); + void SetMin(long nNewValue); + long GetSmallChange(); + void SetSmallChange(long nNewValue); + long GetValue(); + void SetValue(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Spinners wrapper class + +class Spinners : public COleDispatchDriver +{ +public: + Spinners() {} // Calls COleDispatchDriver default constructor + Spinners(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Spinners(const Spinners& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + long Get_Default(); + void Set_Default(long nNewValue); + BOOL GetDisplay3DShading(); + void SetDisplay3DShading(BOOL bNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + long GetMax(); + void SetMax(long nNewValue); + long GetMin(); + void SetMin(long nNewValue); + long GetSmallChange(); + void SetSmallChange(long nNewValue); + long GetValue(); + void SetValue(long nNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// DialogFrame wrapper class + +class DialogFrame : public COleDispatchDriver +{ +public: + DialogFrame() {} // Calls COleDispatchDriver default constructor + DialogFrame(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DialogFrame(const DialogFrame& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT CopyPicture(long Appearance, long Format); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT Select(const VARIANT& Replace); + double GetTop(); + void SetTop(double newValue); + double GetWidth(); + void SetWidth(double newValue); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Label wrapper class + +class Label : public COleDispatchDriver +{ +public: + Label() {} // Calls COleDispatchDriver default constructor + Label(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Label(const Label& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Labels wrapper class + +class Labels : public COleDispatchDriver +{ +public: + Labels() {} // Calls COleDispatchDriver default constructor + Labels(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Labels(const Labels& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetAccelerator(); + void SetAccelerator(const VARIANT& newValue); + VARIANT GetPhoneticAccelerator(); + void SetPhoneticAccelerator(const VARIANT& newValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Panes wrapper class + +class Panes : public COleDispatchDriver +{ +public: + Panes() {} // Calls COleDispatchDriver default constructor + Panes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Panes(const Panes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetItem(long Index); + LPDISPATCH Get_Default(long Index); +}; +///////////////////////////////////////////////////////////////////////////// +// Pane wrapper class + +class Pane : public COleDispatchDriver +{ +public: + Pane() {} // Calls COleDispatchDriver default constructor + Pane(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Pane(const Pane& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL Activate(); + long GetIndex(); + VARIANT LargeScroll(const VARIANT& Down, const VARIANT& Up, const VARIANT& ToRight, const VARIANT& ToLeft); + long GetScrollColumn(); + void SetScrollColumn(long nNewValue); + long GetScrollRow(); + void SetScrollRow(long nNewValue); + VARIANT SmallScroll(const VARIANT& Down, const VARIANT& Up, const VARIANT& ToRight, const VARIANT& ToLeft); + LPDISPATCH GetVisibleRange(); + void ScrollIntoView(long Left, long Top, long Width, long Height, const VARIANT& Start); +}; +///////////////////////////////////////////////////////////////////////////// +// Scenarios wrapper class + +class Scenarios : public COleDispatchDriver +{ +public: + Scenarios() {} // Calls COleDispatchDriver default constructor + Scenarios(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Scenarios(const Scenarios& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR Name, const VARIANT& ChangingCells, const VARIANT& Values, const VARIANT& Comment, const VARIANT& Locked, const VARIANT& Hidden); + long GetCount(); + VARIANT CreateSummary(long ReportType, const VARIANT& ResultCells); + LPDISPATCH Item(const VARIANT& Index); + VARIANT Merge(const VARIANT& Source); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Scenario wrapper class + +class Scenario : public COleDispatchDriver +{ +public: + Scenario() {} // Calls COleDispatchDriver default constructor + Scenario(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Scenario(const Scenario& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT ChangeScenario(const VARIANT& ChangingCells, const VARIANT& Values); + LPDISPATCH GetChangingCells(); + CString GetComment(); + void SetComment(LPCTSTR lpszNewValue); + VARIANT Delete(); + BOOL GetHidden(); + void SetHidden(BOOL bNewValue); + long GetIndex(); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT Show(); + VARIANT GetValues(const VARIANT& Index); +}; +///////////////////////////////////////////////////////////////////////////// +// GroupObject wrapper class + +class GroupObject : public COleDispatchDriver +{ +public: + GroupObject() {} // Calls COleDispatchDriver default constructor + GroupObject(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + GroupObject(const GroupObject& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetArrowHeadLength(); + void SetArrowHeadLength(const VARIANT& newValue); + VARIANT GetArrowHeadStyle(); + void SetArrowHeadStyle(const VARIANT& newValue); + VARIANT GetArrowHeadWidth(); + void SetArrowHeadWidth(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + LPDISPATCH GetBorder(); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + long Get_Default(); + void Set_Default(long nNewValue); + LPDISPATCH GetFont(); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + LPDISPATCH GetInterior(); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + LPDISPATCH Ungroup(); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// GroupObjects wrapper class + +class GroupObjects : public COleDispatchDriver +{ +public: + GroupObjects() {} // Calls COleDispatchDriver default constructor + GroupObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + GroupObjects(const GroupObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetArrowHeadLength(); + void SetArrowHeadLength(const VARIANT& newValue); + VARIANT GetArrowHeadStyle(); + void SetArrowHeadStyle(const VARIANT& newValue); + VARIANT GetArrowHeadWidth(); + void SetArrowHeadWidth(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + LPDISPATCH GetBorder(); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + long Get_Default(); + void Set_Default(long nNewValue); + LPDISPATCH GetFont(); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + LPDISPATCH GetInterior(); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + LPDISPATCH Ungroup(); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Line wrapper class + +class Line : public COleDispatchDriver +{ +public: + Line() {} // Calls COleDispatchDriver default constructor + Line(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Line(const Line& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + VARIANT GetArrowHeadLength(); + void SetArrowHeadLength(const VARIANT& newValue); + VARIANT GetArrowHeadStyle(); + void SetArrowHeadStyle(const VARIANT& newValue); + VARIANT GetArrowHeadWidth(); + void SetArrowHeadWidth(const VARIANT& newValue); + LPDISPATCH GetBorder(); +}; +///////////////////////////////////////////////////////////////////////////// +// Lines wrapper class + +class Lines : public COleDispatchDriver +{ +public: + Lines() {} // Calls COleDispatchDriver default constructor + Lines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Lines(const Lines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + VARIANT GetArrowHeadLength(); + void SetArrowHeadLength(const VARIANT& newValue); + VARIANT GetArrowHeadStyle(); + void SetArrowHeadStyle(const VARIANT& newValue); + VARIANT GetArrowHeadWidth(); + void SetArrowHeadWidth(const VARIANT& newValue); + LPDISPATCH GetBorder(); + LPDISPATCH Add(double X1, double Y1, double X2, double Y2); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Rectangle wrapper class + +class Rectangle : public COleDispatchDriver +{ +public: + Rectangle() {} // Calls COleDispatchDriver default constructor + Rectangle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Rectangle(const Rectangle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Rectangles wrapper class + +class Rectangles : public COleDispatchDriver +{ +public: + Rectangles() {} // Calls COleDispatchDriver default constructor + Rectangles(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Rectangles(const Rectangles& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Oval wrapper class + +class Oval : public COleDispatchDriver +{ +public: + Oval() {} // Calls COleDispatchDriver default constructor + Oval(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Oval(const Oval& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Ovals wrapper class + +class Ovals : public COleDispatchDriver +{ +public: + Ovals() {} // Calls COleDispatchDriver default constructor + Ovals(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Ovals(const Ovals& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Arc wrapper class + +class Arc : public COleDispatchDriver +{ +public: + Arc() {} // Calls COleDispatchDriver default constructor + Arc(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Arc(const Arc& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); +}; +///////////////////////////////////////////////////////////////////////////// +// Arcs wrapper class + +class Arcs : public COleDispatchDriver +{ +public: + Arcs() {} // Calls COleDispatchDriver default constructor + Arcs(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Arcs(const Arcs& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + LPDISPATCH Add(double X1, double Y1, double X2, double Y2); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// OLEObjectEvents wrapper class + +class OLEObjectEvents : public COleDispatchDriver +{ +public: + OLEObjectEvents() {} // Calls COleDispatchDriver default constructor + OLEObjectEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + OLEObjectEvents(const OLEObjectEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + void GotFocus(); + void LostFocus(); +}; +///////////////////////////////////////////////////////////////////////////// +// _OLEObject wrapper class + +class _OLEObject : public COleDispatchDriver +{ +public: + _OLEObject() {} // Calls COleDispatchDriver default constructor + _OLEObject(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + _OLEObject(const _OLEObject& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + VARIANT Activate(); + BOOL GetAutoLoad(); + void SetAutoLoad(BOOL bNewValue); + BOOL GetAutoUpdate(); + void SetAutoUpdate(BOOL bNewValue); + LPDISPATCH GetObject(); + VARIANT GetOLEType(); + CString GetSourceName(); + void SetSourceName(LPCTSTR lpszNewValue); + VARIANT Update(); + VARIANT Verb(long Verb); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + CString GetListFillRange(); + void SetListFillRange(LPCTSTR lpszNewValue); + CString GetProgID(); +}; +///////////////////////////////////////////////////////////////////////////// +// OLEObjects wrapper class + +class OLEObjects : public COleDispatchDriver +{ +public: + OLEObjects() {} // Calls COleDispatchDriver default constructor + OLEObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + OLEObjects(const OLEObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + BOOL GetAutoLoad(); + void SetAutoLoad(BOOL bNewValue); + CString GetSourceName(); + void SetSourceName(LPCTSTR lpszNewValue); + LPDISPATCH Add(const VARIANT& ClassType, const VARIANT& Filename, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel, const VARIANT& Left, const VARIANT& Top, + const VARIANT& Width, const VARIANT& Height); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// TextBox wrapper class + +class TextBox : public COleDispatchDriver +{ +public: + TextBox() {} // Calls COleDispatchDriver default constructor + TextBox(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + TextBox(const TextBox& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// TextBoxes wrapper class + +class TextBoxes : public COleDispatchDriver +{ +public: + TextBoxes() {} // Calls COleDispatchDriver default constructor + TextBoxes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + TextBoxes(const TextBoxes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// MyPicture wrapper class + +class MyPicture : public COleDispatchDriver +{ +public: + MyPicture() {} // Calls COleDispatchDriver default constructor + MyPicture(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + MyPicture(const MyPicture& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Pictures wrapper class + +class Pictures : public COleDispatchDriver +{ +public: + Pictures() {} // Calls COleDispatchDriver default constructor + Pictures(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Pictures(const Pictures& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Insert(LPCTSTR Filename, const VARIANT& Converter); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); + LPDISPATCH Paste(const VARIANT& Link); +}; +///////////////////////////////////////////////////////////////////////////// +// Drawing wrapper class + +class Drawing : public COleDispatchDriver +{ +public: + Drawing() {} // Calls COleDispatchDriver default constructor + Drawing(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Drawing(const Drawing& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + VARIANT AddVertex(double Left, double Top); + VARIANT Reshape(long Vertex, BOOL Insert, const VARIANT& Left, const VARIANT& Top); + VARIANT GetVertices(const VARIANT& Index1, const VARIANT& Index2); +}; +///////////////////////////////////////////////////////////////////////////// +// Drawings wrapper class + +class Drawings : public COleDispatchDriver +{ +public: + Drawings() {} // Calls COleDispatchDriver default constructor + Drawings(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Drawings(const Drawings& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + BOOL GetAddIndent(); + void SetAddIndent(BOOL bNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + VARIANT CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + LPDISPATCH GetFont(); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + VARIANT Reshape(long Vertex, BOOL Insert, const VARIANT& Left, const VARIANT& Top); + LPDISPATCH Add(double X1, double Y1, double X2, double Y2, BOOL Closed); + long GetCount(); + LPDISPATCH Group(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// RoutingSlip wrapper class + +class RoutingSlip : public COleDispatchDriver +{ +public: + RoutingSlip() {} // Calls COleDispatchDriver default constructor + RoutingSlip(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + RoutingSlip(const RoutingSlip& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetDelivery(); + void SetDelivery(long nNewValue); + VARIANT GetMessage(); + void SetMessage(const VARIANT& newValue); + VARIANT GetRecipients(const VARIANT& Index); + void SetRecipients(const VARIANT& Index, const VARIANT& newValue); + VARIANT Reset(); + BOOL GetReturnWhenDone(); + void SetReturnWhenDone(BOOL bNewValue); + long GetStatus(); + VARIANT GetSubject(); + void SetSubject(const VARIANT& newValue); + BOOL GetTrackStatus(); + void SetTrackStatus(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Outline wrapper class + +class Outline : public COleDispatchDriver +{ +public: + Outline() {} // Calls COleDispatchDriver default constructor + Outline(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Outline(const Outline& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetAutomaticStyles(); + void SetAutomaticStyles(BOOL bNewValue); + VARIANT ShowLevels(const VARIANT& RowLevels, const VARIANT& ColumnLevels); + long GetSummaryColumn(); + void SetSummaryColumn(long nNewValue); + long GetSummaryRow(); + void SetSummaryRow(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Module wrapper class + +class Module : public COleDispatchDriver +{ +public: + Module() {} // Calls COleDispatchDriver default constructor + Module(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Module(const Module& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Activate(); + void Copy(const VARIANT& Before, const VARIANT& After); + void Delete(); + CString GetCodeName(); + CString Get_CodeName(); + void Set_CodeName(LPCTSTR lpszNewValue); + long GetIndex(); + void Move(const VARIANT& Before, const VARIANT& After); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetNext(); + LPDISPATCH GetPageSetup(); + LPDISPATCH GetPrevious(); + BOOL GetProtectContents(); + BOOL GetProtectionMode(); + void Select(const VARIANT& Replace); + void Unprotect(const VARIANT& Password); + long GetVisible(); + void SetVisible(long nNewValue); + LPDISPATCH GetShapes(); + VARIANT InsertFile(const VARIANT& Filename, const VARIANT& Merge); + void SaveAs(LPCTSTR Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AddToMru, const VARIANT& TextCodepage, + const VARIANT& TextVisualLayout); + void Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly); +}; +///////////////////////////////////////////////////////////////////////////// +// Modules wrapper class + +class Modules : public COleDispatchDriver +{ +public: + Modules() {} // Calls COleDispatchDriver default constructor + Modules(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Modules(const Modules& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count); + void Copy(const VARIANT& Before, const VARIANT& After); + long GetCount(); + void Delete(); + LPDISPATCH GetItem(const VARIANT& Index); + void Move(const VARIANT& Before, const VARIANT& After); + LPUNKNOWN Get_NewEnum(); + void Select(const VARIANT& Replace); + LPDISPATCH GetHPageBreaks(); + LPDISPATCH GetVPageBreaks(); + VARIANT GetVisible(); + void SetVisible(const VARIANT& newValue); + LPDISPATCH Get_Default(const VARIANT& Index); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); +}; +///////////////////////////////////////////////////////////////////////////// +// DialogSheet wrapper class + +class DialogSheet : public COleDispatchDriver +{ +public: + DialogSheet() {} // Calls COleDispatchDriver default constructor + DialogSheet(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DialogSheet(const DialogSheet& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Activate(); + void Copy(const VARIANT& Before, const VARIANT& After); + void Delete(); + CString GetCodeName(); + CString Get_CodeName(); + void Set_CodeName(LPCTSTR lpszNewValue); + long GetIndex(); + void Move(const VARIANT& Before, const VARIANT& After); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetNext(); + LPDISPATCH GetPageSetup(); + LPDISPATCH GetPrevious(); + void PrintPreview(const VARIANT& EnableChanges); + BOOL GetProtectContents(); + BOOL GetProtectDrawingObjects(); + BOOL GetProtectionMode(); + BOOL GetProtectScenarios(); + void Select(const VARIANT& Replace); + void Unprotect(const VARIANT& Password); + long GetVisible(); + void SetVisible(long nNewValue); + LPDISPATCH GetShapes(); + BOOL GetEnableCalculation(); + void SetEnableCalculation(BOOL bNewValue); + LPDISPATCH ChartObjects(const VARIANT& Index); + void CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang); + BOOL GetEnableAutoFilter(); + void SetEnableAutoFilter(BOOL bNewValue); + long GetEnableSelection(); + void SetEnableSelection(long nNewValue); + BOOL GetEnableOutlining(); + void SetEnableOutlining(BOOL bNewValue); + BOOL GetEnablePivotTable(); + void SetEnablePivotTable(BOOL bNewValue); + VARIANT Evaluate(const VARIANT& Name); + VARIANT _Evaluate(const VARIANT& Name); + void ResetAllPageBreaks(); + LPDISPATCH GetNames(); + LPDISPATCH OLEObjects(const VARIANT& Index); + void Paste(const VARIANT& Destination, const VARIANT& Link); + CString GetScrollArea(); + void SetScrollArea(LPCTSTR lpszNewValue); + LPDISPATCH GetHPageBreaks(); + LPDISPATCH GetVPageBreaks(); + LPDISPATCH GetQueryTables(); + BOOL GetDisplayPageBreaks(); + void SetDisplayPageBreaks(BOOL bNewValue); + LPDISPATCH GetComments(); + LPDISPATCH GetHyperlinks(); + void ClearCircles(); + void CircleInvalid(); + LPDISPATCH GetAutoFilter(); + BOOL GetDisplayRightToLeft(); + void SetDisplayRightToLeft(BOOL bNewValue); + LPDISPATCH GetScripts(); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); + LPDISPATCH GetTab(); + LPDISPATCH GetMailEnvelope(); + void SaveAs(LPCTSTR Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AddToMru, const VARIANT& TextCodepage, + const VARIANT& TextVisualLayout, const VARIANT& Local); + LPDISPATCH GetCustomProperties(); + LPDISPATCH GetSmartTags(); + LPDISPATCH GetProtection(); + void PasteSpecial(const VARIANT& Format, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel, const VARIANT& NoHTMLFormatting); + void Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly, const VARIANT& AllowFormattingCells, const VARIANT& AllowFormattingColumns, + const VARIANT& AllowFormattingRows, const VARIANT& AllowInsertingColumns, const VARIANT& AllowInsertingRows, const VARIANT& AllowInsertingHyperlinks, const VARIANT& AllowDeletingColumns, const VARIANT& AllowDeletingRows, + const VARIANT& AllowSorting, const VARIANT& AllowFiltering, const VARIANT& AllowUsingPivotTables); + VARIANT GetDefaultButton(); + void SetDefaultButton(const VARIANT& newValue); + VARIANT GetFocus(); + void SetFocus(const VARIANT& newValue); + BOOL Hide(const VARIANT& Cancel); + BOOL Show(); +}; +///////////////////////////////////////////////////////////////////////////// +// DialogSheets wrapper class + +class DialogSheets : public COleDispatchDriver +{ +public: + DialogSheets() {} // Calls COleDispatchDriver default constructor + DialogSheets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DialogSheets(const DialogSheets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count); + void Copy(const VARIANT& Before, const VARIANT& After); + long GetCount(); + void Delete(); + LPDISPATCH GetItem(const VARIANT& Index); + void Move(const VARIANT& Before, const VARIANT& After); + LPUNKNOWN Get_NewEnum(); + void PrintPreview(const VARIANT& EnableChanges); + void Select(const VARIANT& Replace); + LPDISPATCH GetHPageBreaks(); + LPDISPATCH GetVPageBreaks(); + VARIANT GetVisible(); + void SetVisible(const VARIANT& newValue); + LPDISPATCH Get_Default(const VARIANT& Index); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); +}; +///////////////////////////////////////////////////////////////////////////// +// Worksheets wrapper class + +class Worksheets : public COleDispatchDriver +{ +public: + Worksheets() {} // Calls COleDispatchDriver default constructor + Worksheets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Worksheets(const Worksheets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count, const VARIANT& Type); + void Copy(const VARIANT& Before, const VARIANT& After); + long GetCount(); + void Delete(); + void FillAcrossSheets(LPDISPATCH Range, long Type); + LPDISPATCH GetItem(const VARIANT& Index); + void Move(const VARIANT& Before, const VARIANT& After); + LPUNKNOWN Get_NewEnum(); + void PrintPreview(const VARIANT& EnableChanges); + void Select(const VARIANT& Replace); + LPDISPATCH GetHPageBreaks(); + LPDISPATCH GetVPageBreaks(); + VARIANT GetVisible(); + void SetVisible(const VARIANT& newValue); + LPDISPATCH Get_Default(const VARIANT& Index); + void PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName); +}; +///////////////////////////////////////////////////////////////////////////// +// PageSetup wrapper class + +class PageSetup : public COleDispatchDriver +{ +public: + PageSetup() {} // Calls COleDispatchDriver default constructor + PageSetup(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PageSetup(const PageSetup& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetBlackAndWhite(); + void SetBlackAndWhite(BOOL bNewValue); + double GetBottomMargin(); + void SetBottomMargin(double newValue); + CString GetCenterFooter(); + void SetCenterFooter(LPCTSTR lpszNewValue); + CString GetCenterHeader(); + void SetCenterHeader(LPCTSTR lpszNewValue); + BOOL GetCenterHorizontally(); + void SetCenterHorizontally(BOOL bNewValue); + BOOL GetCenterVertically(); + void SetCenterVertically(BOOL bNewValue); + long GetChartSize(); + void SetChartSize(long nNewValue); + BOOL GetDraft(); + void SetDraft(BOOL bNewValue); + long GetFirstPageNumber(); + void SetFirstPageNumber(long nNewValue); + VARIANT GetFitToPagesTall(); + void SetFitToPagesTall(const VARIANT& newValue); + VARIANT GetFitToPagesWide(); + void SetFitToPagesWide(const VARIANT& newValue); + double GetFooterMargin(); + void SetFooterMargin(double newValue); + double GetHeaderMargin(); + void SetHeaderMargin(double newValue); + CString GetLeftFooter(); + void SetLeftFooter(LPCTSTR lpszNewValue); + CString GetLeftHeader(); + void SetLeftHeader(LPCTSTR lpszNewValue); + double GetLeftMargin(); + void SetLeftMargin(double newValue); + long GetOrder(); + void SetOrder(long nNewValue); + long GetOrientation(); + void SetOrientation(long nNewValue); + long GetPaperSize(); + void SetPaperSize(long nNewValue); + CString GetPrintArea(); + void SetPrintArea(LPCTSTR lpszNewValue); + BOOL GetPrintGridlines(); + void SetPrintGridlines(BOOL bNewValue); + BOOL GetPrintHeadings(); + void SetPrintHeadings(BOOL bNewValue); + BOOL GetPrintNotes(); + void SetPrintNotes(BOOL bNewValue); + VARIANT GetPrintQuality(const VARIANT& Index); + void SetPrintQuality(const VARIANT& Index, const VARIANT& newValue); + CString GetPrintTitleColumns(); + void SetPrintTitleColumns(LPCTSTR lpszNewValue); + CString GetPrintTitleRows(); + void SetPrintTitleRows(LPCTSTR lpszNewValue); + CString GetRightFooter(); + void SetRightFooter(LPCTSTR lpszNewValue); + CString GetRightHeader(); + void SetRightHeader(LPCTSTR lpszNewValue); + double GetRightMargin(); + void SetRightMargin(double newValue); + double GetTopMargin(); + void SetTopMargin(double newValue); + VARIANT GetZoom(); + void SetZoom(const VARIANT& newValue); + long GetPrintComments(); + void SetPrintComments(long nNewValue); + long GetPrintErrors(); + void SetPrintErrors(long nNewValue); + LPDISPATCH GetCenterHeaderPicture(); + LPDISPATCH GetCenterFooterPicture(); + LPDISPATCH GetLeftHeaderPicture(); + LPDISPATCH GetLeftFooterPicture(); + LPDISPATCH GetRightHeaderPicture(); + LPDISPATCH GetRightFooterPicture(); +}; +///////////////////////////////////////////////////////////////////////////// +// Names wrapper class + +class Names : public COleDispatchDriver +{ +public: + Names() {} // Calls COleDispatchDriver default constructor + Names(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Names(const Names& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Name, const VARIANT& RefersTo, const VARIANT& Visible, const VARIANT& MacroType, const VARIANT& ShortcutKey, const VARIANT& Category, const VARIANT& NameLocal, const VARIANT& RefersToLocal, + const VARIANT& CategoryLocal, const VARIANT& RefersToR1C1, const VARIANT& RefersToR1C1Local); + LPDISPATCH Item(const VARIANT& Index, const VARIANT& IndexLocal, const VARIANT& RefersTo); + LPDISPATCH _Default(const VARIANT& Index, const VARIANT& IndexLocal, const VARIANT& RefersTo); + long GetCount(); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Name wrapper class + +class Name : public COleDispatchDriver +{ +public: + Name() {} // Calls COleDispatchDriver default constructor + Name(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Name(const Name& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString Get_Default(); + long GetIndex(); + CString GetCategory(); + void SetCategory(LPCTSTR lpszNewValue); + CString GetCategoryLocal(); + void SetCategoryLocal(LPCTSTR lpszNewValue); + void Delete(); + long GetMacroType(); + void SetMacroType(long nNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetRefersTo(); + void SetRefersTo(const VARIANT& newValue); + CString GetShortcutKey(); + void SetShortcutKey(LPCTSTR lpszNewValue); + CString GetValue(); + void SetValue(LPCTSTR lpszNewValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + CString GetNameLocal(); + void SetNameLocal(LPCTSTR lpszNewValue); + VARIANT GetRefersToLocal(); + void SetRefersToLocal(const VARIANT& newValue); + VARIANT GetRefersToR1C1(); + void SetRefersToR1C1(const VARIANT& newValue); + VARIANT GetRefersToR1C1Local(); + void SetRefersToR1C1Local(const VARIANT& newValue); + LPDISPATCH GetRefersToRange(); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartObject wrapper class + +class ChartObject : public COleDispatchDriver +{ +public: + ChartObject() {} // Calls COleDispatchDriver default constructor + ChartObject(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartObject(const ChartObject& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBottomRightCell(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + long GetIndex(); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + LPDISPATCH GetTopLeftCell(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + long GetZOrder(); + LPDISPATCH GetShapeRange(); + VARIANT Activate(); + LPDISPATCH GetChart(); + BOOL GetProtectChartObject(); + void SetProtectChartObject(BOOL bNewValue); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartObjects wrapper class + +class ChartObjects : public COleDispatchDriver +{ +public: + ChartObjects() {} // Calls COleDispatchDriver default constructor + ChartObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartObjects(const ChartObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT BringToFront(); + VARIANT Copy(); + VARIANT CopyPicture(long Appearance, long Format); + VARIANT Cut(); + VARIANT Delete(); + LPDISPATCH Duplicate(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + double GetHeight(); + void SetHeight(double newValue); + double GetLeft(); + void SetLeft(double newValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + VARIANT GetPlacement(); + void SetPlacement(const VARIANT& newValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + VARIANT Select(const VARIANT& Replace); + VARIANT SendToBack(); + double GetTop(); + void SetTop(double newValue); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + double GetWidth(); + void SetWidth(double newValue); + LPDISPATCH GetShapeRange(); + BOOL GetRoundedCorners(); + void SetRoundedCorners(BOOL bNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetInterior(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + LPDISPATCH Add(double Left, double Top, double Width, double Height); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Mailer wrapper class + +class Mailer : public COleDispatchDriver +{ +public: + Mailer() {} // Calls COleDispatchDriver default constructor + Mailer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Mailer(const Mailer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT GetBCCRecipients(); + void SetBCCRecipients(const VARIANT& newValue); + VARIANT GetCCRecipients(); + void SetCCRecipients(const VARIANT& newValue); + VARIANT GetEnclosures(); + void SetEnclosures(const VARIANT& newValue); + BOOL GetReceived(); + DATE GetSendDateTime(); + CString GetSender(); + CString GetSubject(); + void SetSubject(LPCTSTR lpszNewValue); + VARIANT GetToRecipients(); + void SetToRecipients(const VARIANT& newValue); + VARIANT GetWhichAddress(); + void SetWhichAddress(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// CustomViews wrapper class + +class CustomViews : public COleDispatchDriver +{ +public: + CustomViews() {} // Calls COleDispatchDriver default constructor + CustomViews(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CustomViews(const CustomViews& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& ViewName); + LPDISPATCH Add(LPCTSTR ViewName, const VARIANT& PrintSettings, const VARIANT& RowColSettings); + LPDISPATCH Get_Default(const VARIANT& ViewName); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// CustomView wrapper class + +class CustomView : public COleDispatchDriver +{ +public: + CustomView() {} // Calls COleDispatchDriver default constructor + CustomView(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CustomView(const CustomView& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + BOOL GetPrintSettings(); + BOOL GetRowColSettings(); + void Show(); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// FormatConditions wrapper class + +class FormatConditions : public COleDispatchDriver +{ +public: + FormatConditions() {} // Calls COleDispatchDriver default constructor + FormatConditions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + FormatConditions(const FormatConditions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Add(long Type, const VARIANT& Operator, const VARIANT& Formula1, const VARIANT& Formula2); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// FormatCondition wrapper class + +class FormatCondition : public COleDispatchDriver +{ +public: + FormatCondition() {} // Calls COleDispatchDriver default constructor + FormatCondition(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + FormatCondition(const FormatCondition& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Modify(long Type, const VARIANT& Operator, const VARIANT& Formula1, const VARIANT& Formula2); + long GetType(); + long GetOperator(); + CString GetFormula1(); + CString GetFormula2(); + LPDISPATCH GetInterior(); + LPDISPATCH GetBorders(); + LPDISPATCH GetFont(); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// Comments wrapper class + +class Comments : public COleDispatchDriver +{ +public: + Comments() {} // Calls COleDispatchDriver default constructor + Comments(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Comments(const Comments& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(long Index); + LPDISPATCH Get_Default(long Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Comment wrapper class + +class Comment : public COleDispatchDriver +{ +public: + Comment() {} // Calls COleDispatchDriver default constructor + Comment(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Comment(const Comment& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetAuthor(); + LPDISPATCH GetShape(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + CString Text(const VARIANT& Text, const VARIANT& Start, const VARIANT& Overwrite); + void Delete(); + LPDISPATCH Next(); + LPDISPATCH Previous(); +}; +///////////////////////////////////////////////////////////////////////////// +// RefreshEvents wrapper class + +class RefreshEvents : public COleDispatchDriver +{ +public: + RefreshEvents() {} // Calls COleDispatchDriver default constructor + RefreshEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + RefreshEvents(const RefreshEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + void BeforeRefresh(BOOL* Cancel); + void AfterRefresh(BOOL Success); +}; +///////////////////////////////////////////////////////////////////////////// +// _QueryTable wrapper class + +class _QueryTable : public COleDispatchDriver +{ +public: + _QueryTable() {} // Calls COleDispatchDriver default constructor + _QueryTable(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + _QueryTable(const _QueryTable& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + BOOL GetFieldNames(); + void SetFieldNames(BOOL bNewValue); + BOOL GetRowNumbers(); + void SetRowNumbers(BOOL bNewValue); + BOOL GetFillAdjacentFormulas(); + void SetFillAdjacentFormulas(BOOL bNewValue); + BOOL GetRefreshOnFileOpen(); + void SetRefreshOnFileOpen(BOOL bNewValue); + BOOL GetRefreshing(); + BOOL GetFetchedRowOverflow(); + BOOL GetBackgroundQuery(); + void SetBackgroundQuery(BOOL bNewValue); + void CancelRefresh(); + long GetRefreshStyle(); + void SetRefreshStyle(long nNewValue); + BOOL GetEnableRefresh(); + void SetEnableRefresh(BOOL bNewValue); + BOOL GetSavePassword(); + void SetSavePassword(BOOL bNewValue); + LPDISPATCH GetDestination(); + VARIANT GetConnection(); + void SetConnection(const VARIANT& newValue); + CString GetPostText(); + void SetPostText(LPCTSTR lpszNewValue); + LPDISPATCH GetResultRange(); + void Delete(); + BOOL Refresh(const VARIANT& BackgroundQuery); + LPDISPATCH GetParameters(); + LPDISPATCH GetRecordset(); + void SetRefRecordset(LPDISPATCH newValue); + BOOL GetSaveData(); + void SetSaveData(BOOL bNewValue); + BOOL GetEnableEditing(); + void SetEnableEditing(BOOL bNewValue); + long GetTextFilePlatform(); + void SetTextFilePlatform(long nNewValue); + long GetTextFileStartRow(); + void SetTextFileStartRow(long nNewValue); + long GetTextFileParseType(); + void SetTextFileParseType(long nNewValue); + long GetTextFileTextQualifier(); + void SetTextFileTextQualifier(long nNewValue); + BOOL GetTextFileConsecutiveDelimiter(); + void SetTextFileConsecutiveDelimiter(BOOL bNewValue); + BOOL GetTextFileTabDelimiter(); + void SetTextFileTabDelimiter(BOOL bNewValue); + BOOL GetTextFileSemicolonDelimiter(); + void SetTextFileSemicolonDelimiter(BOOL bNewValue); + BOOL GetTextFileCommaDelimiter(); + void SetTextFileCommaDelimiter(BOOL bNewValue); + BOOL GetTextFileSpaceDelimiter(); + void SetTextFileSpaceDelimiter(BOOL bNewValue); + CString GetTextFileOtherDelimiter(); + void SetTextFileOtherDelimiter(LPCTSTR lpszNewValue); + VARIANT GetTextFileColumnDataTypes(); + void SetTextFileColumnDataTypes(const VARIANT& newValue); + VARIANT GetTextFileFixedColumnWidths(); + void SetTextFileFixedColumnWidths(const VARIANT& newValue); + BOOL GetPreserveColumnInfo(); + void SetPreserveColumnInfo(BOOL bNewValue); + BOOL GetPreserveFormatting(); + void SetPreserveFormatting(BOOL bNewValue); + BOOL GetAdjustColumnWidth(); + void SetAdjustColumnWidth(BOOL bNewValue); + VARIANT GetCommandText(); + void SetCommandText(const VARIANT& newValue); + long GetCommandType(); + void SetCommandType(long nNewValue); + BOOL GetTextFilePromptOnRefresh(); + void SetTextFilePromptOnRefresh(BOOL bNewValue); + long GetQueryType(); + BOOL GetMaintainConnection(); + void SetMaintainConnection(BOOL bNewValue); + CString GetTextFileDecimalSeparator(); + void SetTextFileDecimalSeparator(LPCTSTR lpszNewValue); + CString GetTextFileThousandsSeparator(); + void SetTextFileThousandsSeparator(LPCTSTR lpszNewValue); + long GetRefreshPeriod(); + void SetRefreshPeriod(long nNewValue); + void ResetTimer(); + long GetWebSelectionType(); + void SetWebSelectionType(long nNewValue); + long GetWebFormatting(); + void SetWebFormatting(long nNewValue); + CString GetWebTables(); + void SetWebTables(LPCTSTR lpszNewValue); + BOOL GetWebPreFormattedTextToColumns(); + void SetWebPreFormattedTextToColumns(BOOL bNewValue); + BOOL GetWebSingleBlockTextImport(); + void SetWebSingleBlockTextImport(BOOL bNewValue); + BOOL GetWebDisableDateRecognition(); + void SetWebDisableDateRecognition(BOOL bNewValue); + BOOL GetWebConsecutiveDelimitersAsOne(); + void SetWebConsecutiveDelimitersAsOne(BOOL bNewValue); + BOOL GetWebDisableRedirections(); + void SetWebDisableRedirections(BOOL bNewValue); + VARIANT GetEditWebPage(); + void SetEditWebPage(const VARIANT& newValue); + CString GetSourceConnectionFile(); + void SetSourceConnectionFile(LPCTSTR lpszNewValue); + CString GetSourceDataFile(); + void SetSourceDataFile(LPCTSTR lpszNewValue); + long GetRobustConnect(); + void SetRobustConnect(long nNewValue); + BOOL GetTextFileTrailingMinusNumbers(); + void SetTextFileTrailingMinusNumbers(BOOL bNewValue); + void SaveAsODC(LPCTSTR ODCFileName, const VARIANT& Description, const VARIANT& Keywords); + LPDISPATCH GetListObject(); + long GetTextFileVisualLayout(); + void SetTextFileVisualLayout(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// QueryTables wrapper class + +class QueryTables : public COleDispatchDriver +{ +public: + QueryTables() {} // Calls COleDispatchDriver default constructor + QueryTables(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + QueryTables(const QueryTables& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Add(const VARIANT& Connection, LPDISPATCH Destination, const VARIANT& Sql); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Parameter wrapper class + +class Parameter : public COleDispatchDriver +{ +public: + Parameter() {} // Calls COleDispatchDriver default constructor + Parameter(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Parameter(const Parameter& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetDataType(); + void SetDataType(long nNewValue); + long GetType(); + CString GetPromptString(); + VARIANT GetValue(); + LPDISPATCH GetSourceRange(); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + void SetParam(long Type, const VARIANT& Value); + BOOL GetRefreshOnChange(); + void SetRefreshOnChange(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Parameters wrapper class + +class Parameters : public COleDispatchDriver +{ +public: + Parameters() {} // Calls COleDispatchDriver default constructor + Parameters(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Parameters(const Parameters& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR Name, const VARIANT& iDataType); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + void Delete(); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// ODBCError wrapper class + +class ODBCError : public COleDispatchDriver +{ +public: + ODBCError() {} // Calls COleDispatchDriver default constructor + ODBCError(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ODBCError(const ODBCError& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetSqlState(); + CString GetErrorString(); +}; +///////////////////////////////////////////////////////////////////////////// +// ODBCErrors wrapper class + +class ODBCErrors : public COleDispatchDriver +{ +public: + ODBCErrors() {} // Calls COleDispatchDriver default constructor + ODBCErrors(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ODBCErrors(const ODBCErrors& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(long Index); + LPDISPATCH Get_Default(long Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Validation wrapper class + +class Validation : public COleDispatchDriver +{ +public: + Validation() {} // Calls COleDispatchDriver default constructor + Validation(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Validation(const Validation& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Add(long Type, const VARIANT& AlertStyle, const VARIANT& Operator, const VARIANT& Formula1, const VARIANT& Formula2); + long GetAlertStyle(); + BOOL GetIgnoreBlank(); + void SetIgnoreBlank(BOOL bNewValue); + long GetIMEMode(); + void SetIMEMode(long nNewValue); + BOOL GetInCellDropdown(); + void SetInCellDropdown(BOOL bNewValue); + void Delete(); + CString GetErrorMessage(); + void SetErrorMessage(LPCTSTR lpszNewValue); + CString GetErrorTitle(); + void SetErrorTitle(LPCTSTR lpszNewValue); + CString GetInputMessage(); + void SetInputMessage(LPCTSTR lpszNewValue); + CString GetInputTitle(); + void SetInputTitle(LPCTSTR lpszNewValue); + CString GetFormula1(); + CString GetFormula2(); + void Modify(const VARIANT& Type, const VARIANT& AlertStyle, const VARIANT& Operator, const VARIANT& Formula1, const VARIANT& Formula2); + long GetOperator(); + BOOL GetShowError(); + void SetShowError(BOOL bNewValue); + BOOL GetShowInput(); + void SetShowInput(BOOL bNewValue); + long GetType(); + BOOL GetValue(); +}; +///////////////////////////////////////////////////////////////////////////// +// Hyperlinks wrapper class + +class Hyperlinks : public COleDispatchDriver +{ +public: + Hyperlinks() {} // Calls COleDispatchDriver default constructor + Hyperlinks(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Hyperlinks(const Hyperlinks& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPDISPATCH Anchor, LPCTSTR Address, const VARIANT& SubAddress, const VARIANT& ScreenTip, const VARIANT& TextToDisplay); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// Hyperlink wrapper class + +class Hyperlink : public COleDispatchDriver +{ +public: + Hyperlink() {} // Calls COleDispatchDriver default constructor + Hyperlink(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Hyperlink(const Hyperlink& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + LPDISPATCH GetRange(); + LPDISPATCH GetShape(); + CString GetSubAddress(); + void SetSubAddress(LPCTSTR lpszNewValue); + CString GetAddress(); + void SetAddress(LPCTSTR lpszNewValue); + long GetType(); + void AddToFavorites(); + void Delete(); + void Follow(const VARIANT& NewWindow, const VARIANT& AddHistory, const VARIANT& ExtraInfo, const VARIANT& Method, const VARIANT& HeaderInfo); + CString GetEmailSubject(); + void SetEmailSubject(LPCTSTR lpszNewValue); + CString GetScreenTip(); + void SetScreenTip(LPCTSTR lpszNewValue); + CString GetTextToDisplay(); + void SetTextToDisplay(LPCTSTR lpszNewValue); + void CreateNewDocument(LPCTSTR Filename, BOOL EditNow, BOOL Overwrite); +}; +///////////////////////////////////////////////////////////////////////////// +// AutoFilter wrapper class + +class AutoFilter : public COleDispatchDriver +{ +public: + AutoFilter() {} // Calls COleDispatchDriver default constructor + AutoFilter(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AutoFilter(const AutoFilter& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetRange(); + LPDISPATCH GetFilters(); +}; +///////////////////////////////////////////////////////////////////////////// +// Filters wrapper class + +class Filters : public COleDispatchDriver +{ +public: + Filters() {} // Calls COleDispatchDriver default constructor + Filters(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Filters(const Filters& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Get_Default(long Index); + LPDISPATCH GetItem(long Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Filter wrapper class + +class Filter : public COleDispatchDriver +{ +public: + Filter() {} // Calls COleDispatchDriver default constructor + Filter(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Filter(const Filter& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetOn(); + VARIANT GetCriteria1(); + long GetOperator(); + VARIANT GetCriteria2(); +}; +///////////////////////////////////////////////////////////////////////////// +// AutoCorrect wrapper class + +class AutoCorrect : public COleDispatchDriver +{ +public: + AutoCorrect() {} // Calls COleDispatchDriver default constructor + AutoCorrect(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AutoCorrect(const AutoCorrect& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT AddReplacement(LPCTSTR What, LPCTSTR Replacement); + BOOL GetCapitalizeNamesOfDays(); + void SetCapitalizeNamesOfDays(BOOL bNewValue); + VARIANT DeleteReplacement(LPCTSTR What); + VARIANT GetReplacementList(const VARIANT& Index); + void SetReplacementList(const VARIANT& Index, const VARIANT& newValue); + BOOL GetReplaceText(); + void SetReplaceText(BOOL bNewValue); + BOOL GetTwoInitialCapitals(); + void SetTwoInitialCapitals(BOOL bNewValue); + BOOL GetCorrectSentenceCap(); + void SetCorrectSentenceCap(BOOL bNewValue); + BOOL GetCorrectCapsLock(); + void SetCorrectCapsLock(BOOL bNewValue); + BOOL GetDisplayAutoCorrectOptions(); + void SetDisplayAutoCorrectOptions(BOOL bNewValue); + BOOL GetAutoExpandListRange(); + void SetAutoExpandListRange(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Border wrapper class + +class Border : public COleDispatchDriver +{ +public: + Border() {} // Calls COleDispatchDriver default constructor + Border(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Border(const Border& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT GetColor(); + void SetColor(const VARIANT& newValue); + VARIANT GetColorIndex(); + void SetColorIndex(const VARIANT& newValue); + VARIANT GetLineStyle(); + void SetLineStyle(const VARIANT& newValue); + VARIANT GetWeight(); + void SetWeight(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Interior wrapper class + +class Interior : public COleDispatchDriver +{ +public: + Interior() {} // Calls COleDispatchDriver default constructor + Interior(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Interior(const Interior& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT GetColor(); + void SetColor(const VARIANT& newValue); + VARIANT GetColorIndex(); + void SetColorIndex(const VARIANT& newValue); + VARIANT GetInvertIfNegative(); + void SetInvertIfNegative(const VARIANT& newValue); + VARIANT GetPattern(); + void SetPattern(const VARIANT& newValue); + VARIANT GetPatternColor(); + void SetPatternColor(const VARIANT& newValue); + VARIANT GetPatternColorIndex(); + void SetPatternColorIndex(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartFillFormat wrapper class + +class ChartFillFormat : public COleDispatchDriver +{ +public: + ChartFillFormat() {} // Calls COleDispatchDriver default constructor + ChartFillFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartFillFormat(const ChartFillFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void OneColorGradient(long Style, long Variant, float Degree); + void TwoColorGradient(long Style, long Variant); + void PresetTextured(long PresetTexture); + void Solid(); + void Patterned(long Pattern); + void UserPicture(const VARIANT& PictureFile, const VARIANT& PictureFormat, const VARIANT& PictureStackUnit, const VARIANT& PicturePlacement); + void UserTextured(LPCTSTR TextureFile); + void PresetGradient(long Style, long Variant, long PresetGradientType); + LPDISPATCH GetBackColor(); + LPDISPATCH GetForeColor(); + long GetGradientColorType(); + float GetGradientDegree(); + long GetGradientStyle(); + long GetGradientVariant(); + long GetPattern(); + long GetPresetGradientType(); + long GetPresetTexture(); + CString GetTextureName(); + long GetTextureType(); + long GetType(); + long GetVisible(); + void SetVisible(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartColorFormat wrapper class + +class ChartColorFormat : public COleDispatchDriver +{ +public: + ChartColorFormat() {} // Calls COleDispatchDriver default constructor + ChartColorFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartColorFormat(const ChartColorFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetSchemeColor(); + void SetSchemeColor(long nNewValue); + long GetRgb(); + long Get_Default(); + long GetType(); +}; +///////////////////////////////////////////////////////////////////////////// +// Axis wrapper class + +class Axis : public COleDispatchDriver +{ +public: + Axis() {} // Calls COleDispatchDriver default constructor + Axis(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Axis(const Axis& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetAxisBetweenCategories(); + void SetAxisBetweenCategories(BOOL bNewValue); + long GetAxisGroup(); + LPDISPATCH GetAxisTitle(); + LPDISPATCH GetBorder(); + VARIANT GetCategoryNames(); + void SetCategoryNames(const VARIANT& newValue); + long GetCrosses(); + void SetCrosses(long nNewValue); + double GetCrossesAt(); + void SetCrossesAt(double newValue); + VARIANT Delete(); + BOOL GetHasMajorGridlines(); + void SetHasMajorGridlines(BOOL bNewValue); + BOOL GetHasMinorGridlines(); + void SetHasMinorGridlines(BOOL bNewValue); + BOOL GetHasTitle(); + void SetHasTitle(BOOL bNewValue); + LPDISPATCH GetMajorGridlines(); + long GetMajorTickMark(); + void SetMajorTickMark(long nNewValue); + double GetMajorUnit(); + void SetMajorUnit(double newValue); + BOOL GetMajorUnitIsAuto(); + void SetMajorUnitIsAuto(BOOL bNewValue); + double GetMaximumScale(); + void SetMaximumScale(double newValue); + BOOL GetMaximumScaleIsAuto(); + void SetMaximumScaleIsAuto(BOOL bNewValue); + double GetMinimumScale(); + void SetMinimumScale(double newValue); + BOOL GetMinimumScaleIsAuto(); + void SetMinimumScaleIsAuto(BOOL bNewValue); + LPDISPATCH GetMinorGridlines(); + long GetMinorTickMark(); + void SetMinorTickMark(long nNewValue); + double GetMinorUnit(); + void SetMinorUnit(double newValue); + BOOL GetMinorUnitIsAuto(); + void SetMinorUnitIsAuto(BOOL bNewValue); + BOOL GetReversePlotOrder(); + void SetReversePlotOrder(BOOL bNewValue); + long GetScaleType(); + void SetScaleType(long nNewValue); + VARIANT Select(); + long GetTickLabelPosition(); + void SetTickLabelPosition(long nNewValue); + LPDISPATCH GetTickLabels(); + long GetTickLabelSpacing(); + void SetTickLabelSpacing(long nNewValue); + long GetTickMarkSpacing(); + void SetTickMarkSpacing(long nNewValue); + long GetType(); + void SetType(long nNewValue); + long GetBaseUnit(); + void SetBaseUnit(long nNewValue); + BOOL GetBaseUnitIsAuto(); + void SetBaseUnitIsAuto(BOOL bNewValue); + long GetMajorUnitScale(); + void SetMajorUnitScale(long nNewValue); + long GetMinorUnitScale(); + void SetMinorUnitScale(long nNewValue); + long GetCategoryType(); + void SetCategoryType(long nNewValue); + double GetLeft(); + double GetTop(); + double GetWidth(); + double GetHeight(); + long GetDisplayUnit(); + void SetDisplayUnit(long nNewValue); + double GetDisplayUnitCustom(); + void SetDisplayUnitCustom(double newValue); + BOOL GetHasDisplayUnitLabel(); + void SetHasDisplayUnitLabel(BOOL bNewValue); + LPDISPATCH GetDisplayUnitLabel(); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartTitle wrapper class + +class ChartTitle : public COleDispatchDriver +{ +public: + ChartTitle() {} // Calls COleDispatchDriver default constructor + ChartTitle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartTitle(const ChartTitle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + LPDISPATCH GetFont(); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + double GetLeft(); + void SetLeft(double newValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + double GetTop(); + void SetTop(double newValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// AxisTitle wrapper class + +class AxisTitle : public COleDispatchDriver +{ +public: + AxisTitle() {} // Calls COleDispatchDriver default constructor + AxisTitle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AxisTitle(const AxisTitle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + LPDISPATCH GetFont(); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + double GetLeft(); + void SetLeft(double newValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + double GetTop(); + void SetTop(double newValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartGroup wrapper class + +class ChartGroup : public COleDispatchDriver +{ +public: + ChartGroup() {} // Calls COleDispatchDriver default constructor + ChartGroup(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartGroup(const ChartGroup& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetAxisGroup(); + void SetAxisGroup(long nNewValue); + long GetDoughnutHoleSize(); + void SetDoughnutHoleSize(long nNewValue); + LPDISPATCH GetDownBars(); + LPDISPATCH GetDropLines(); + long GetFirstSliceAngle(); + void SetFirstSliceAngle(long nNewValue); + long GetGapWidth(); + void SetGapWidth(long nNewValue); + BOOL GetHasDropLines(); + void SetHasDropLines(BOOL bNewValue); + BOOL GetHasHiLoLines(); + void SetHasHiLoLines(BOOL bNewValue); + BOOL GetHasRadarAxisLabels(); + void SetHasRadarAxisLabels(BOOL bNewValue); + BOOL GetHasSeriesLines(); + void SetHasSeriesLines(BOOL bNewValue); + BOOL GetHasUpDownBars(); + void SetHasUpDownBars(BOOL bNewValue); + LPDISPATCH GetHiLoLines(); + long GetIndex(); + long GetOverlap(); + void SetOverlap(long nNewValue); + LPDISPATCH GetRadarAxisLabels(); + LPDISPATCH SeriesCollection(const VARIANT& Index); + LPDISPATCH GetSeriesLines(); + LPDISPATCH GetUpBars(); + BOOL GetVaryByCategories(); + void SetVaryByCategories(BOOL bNewValue); + long GetSizeRepresents(); + void SetSizeRepresents(long nNewValue); + long GetBubbleScale(); + void SetBubbleScale(long nNewValue); + BOOL GetShowNegativeBubbles(); + void SetShowNegativeBubbles(BOOL bNewValue); + long GetSplitType(); + void SetSplitType(long nNewValue); + VARIANT GetSplitValue(); + void SetSplitValue(const VARIANT& newValue); + long GetSecondPlotSize(); + void SetSecondPlotSize(long nNewValue); + BOOL GetHas3DShading(); + void SetHas3DShading(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartGroups wrapper class + +class ChartGroups : public COleDispatchDriver +{ +public: + ChartGroups() {} // Calls COleDispatchDriver default constructor + ChartGroups(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartGroups(const ChartGroups& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Axes wrapper class + +class Axes : public COleDispatchDriver +{ +public: + Axes() {} // Calls COleDispatchDriver default constructor + Axes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Axes(const Axes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(long Type, long AxisGroup); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Points wrapper class + +class Points : public COleDispatchDriver +{ +public: + Points() {} // Calls COleDispatchDriver default constructor + Points(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Points(const Points& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(long Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Point wrapper class + +class Point : public COleDispatchDriver +{ +public: + Point() {} // Calls COleDispatchDriver default constructor + Point(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Point(const Point& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBorder(); + VARIANT ClearFormats(); + VARIANT Copy(); + LPDISPATCH GetDataLabel(); + VARIANT Delete(); + long GetExplosion(); + void SetExplosion(long nNewValue); + BOOL GetHasDataLabel(); + void SetHasDataLabel(BOOL bNewValue); + LPDISPATCH GetInterior(); + BOOL GetInvertIfNegative(); + void SetInvertIfNegative(BOOL bNewValue); + long GetMarkerBackgroundColor(); + void SetMarkerBackgroundColor(long nNewValue); + long GetMarkerBackgroundColorIndex(); + void SetMarkerBackgroundColorIndex(long nNewValue); + long GetMarkerForegroundColor(); + void SetMarkerForegroundColor(long nNewValue); + long GetMarkerForegroundColorIndex(); + void SetMarkerForegroundColorIndex(long nNewValue); + long GetMarkerSize(); + void SetMarkerSize(long nNewValue); + long GetMarkerStyle(); + void SetMarkerStyle(long nNewValue); + VARIANT Paste(); + long GetPictureType(); + void SetPictureType(long nNewValue); + long GetPictureUnit(); + void SetPictureUnit(long nNewValue); + VARIANT Select(); + BOOL GetApplyPictToSides(); + void SetApplyPictToSides(BOOL bNewValue); + BOOL GetApplyPictToFront(); + void SetApplyPictToFront(BOOL bNewValue); + BOOL GetApplyPictToEnd(); + void SetApplyPictToEnd(BOOL bNewValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + BOOL GetSecondaryPlot(); + void SetSecondaryPlot(BOOL bNewValue); + LPDISPATCH GetFill(); + VARIANT ApplyDataLabels(long Type, const VARIANT& LegendKey, const VARIANT& AutoText, const VARIANT& HasLeaderLines, const VARIANT& ShowSeriesName, const VARIANT& ShowCategoryName, const VARIANT& ShowValue, const VARIANT& ShowPercentage, + const VARIANT& ShowBubbleSize, const VARIANT& Separator); +}; +///////////////////////////////////////////////////////////////////////////// +// Series wrapper class + +class Series : public COleDispatchDriver +{ +public: + Series() {} // Calls COleDispatchDriver default constructor + Series(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Series(const Series& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetAxisGroup(); + void SetAxisGroup(long nNewValue); + LPDISPATCH GetBorder(); + VARIANT ClearFormats(); + VARIANT Copy(); + LPDISPATCH DataLabels(const VARIANT& Index); + VARIANT Delete(); + VARIANT ErrorBar(long Direction, long Include, long Type, const VARIANT& Amount, const VARIANT& MinusValues); + LPDISPATCH GetErrorBars(); + long GetExplosion(); + void SetExplosion(long nNewValue); + CString GetFormula(); + void SetFormula(LPCTSTR lpszNewValue); + CString GetFormulaLocal(); + void SetFormulaLocal(LPCTSTR lpszNewValue); + CString GetFormulaR1C1(); + void SetFormulaR1C1(LPCTSTR lpszNewValue); + CString GetFormulaR1C1Local(); + void SetFormulaR1C1Local(LPCTSTR lpszNewValue); + BOOL GetHasDataLabels(); + void SetHasDataLabels(BOOL bNewValue); + BOOL GetHasErrorBars(); + void SetHasErrorBars(BOOL bNewValue); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + BOOL GetInvertIfNegative(); + void SetInvertIfNegative(BOOL bNewValue); + long GetMarkerBackgroundColor(); + void SetMarkerBackgroundColor(long nNewValue); + long GetMarkerBackgroundColorIndex(); + void SetMarkerBackgroundColorIndex(long nNewValue); + long GetMarkerForegroundColor(); + void SetMarkerForegroundColor(long nNewValue); + long GetMarkerForegroundColorIndex(); + void SetMarkerForegroundColorIndex(long nNewValue); + long GetMarkerSize(); + void SetMarkerSize(long nNewValue); + long GetMarkerStyle(); + void SetMarkerStyle(long nNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT Paste(); + long GetPictureType(); + void SetPictureType(long nNewValue); + long GetPictureUnit(); + void SetPictureUnit(long nNewValue); + long GetPlotOrder(); + void SetPlotOrder(long nNewValue); + LPDISPATCH Points(const VARIANT& Index); + VARIANT Select(); + BOOL GetSmooth(); + void SetSmooth(BOOL bNewValue); + LPDISPATCH Trendlines(const VARIANT& Index); + long GetType(); + void SetType(long nNewValue); + long GetChartType(); + void SetChartType(long nNewValue); + void ApplyCustomType(long ChartType); + VARIANT GetValues(); + void SetValues(const VARIANT& newValue); + VARIANT GetXValues(); + void SetXValues(const VARIANT& newValue); + VARIANT GetBubbleSizes(); + void SetBubbleSizes(const VARIANT& newValue); + long GetBarShape(); + void SetBarShape(long nNewValue); + BOOL GetApplyPictToSides(); + void SetApplyPictToSides(BOOL bNewValue); + BOOL GetApplyPictToFront(); + void SetApplyPictToFront(BOOL bNewValue); + BOOL GetApplyPictToEnd(); + void SetApplyPictToEnd(BOOL bNewValue); + BOOL GetHas3DEffect(); + void SetHas3DEffect(BOOL bNewValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + BOOL GetHasLeaderLines(); + void SetHasLeaderLines(BOOL bNewValue); + LPDISPATCH GetLeaderLines(); + VARIANT ApplyDataLabels(long Type, const VARIANT& LegendKey, const VARIANT& AutoText, const VARIANT& HasLeaderLines, const VARIANT& ShowSeriesName, const VARIANT& ShowCategoryName, const VARIANT& ShowValue, const VARIANT& ShowPercentage, + const VARIANT& ShowBubbleSize, const VARIANT& Separator); +}; +///////////////////////////////////////////////////////////////////////////// +// SeriesCollection wrapper class + +class SeriesCollection : public COleDispatchDriver +{ +public: + SeriesCollection() {} // Calls COleDispatchDriver default constructor + SeriesCollection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SeriesCollection(const SeriesCollection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Source, long Rowcol, const VARIANT& SeriesLabels, const VARIANT& CategoryLabels, const VARIANT& Replace); + long GetCount(); + VARIANT Extend(const VARIANT& Source, const VARIANT& Rowcol, const VARIANT& CategoryLabels); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); + VARIANT Paste(long Rowcol, const VARIANT& SeriesLabels, const VARIANT& CategoryLabels, const VARIANT& Replace, const VARIANT& NewSeries); + LPDISPATCH NewSeries(); +}; +///////////////////////////////////////////////////////////////////////////// +// DataLabel wrapper class + +class DataLabel : public COleDispatchDriver +{ +public: + DataLabel() {} // Calls COleDispatchDriver default constructor + DataLabel(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DataLabel(const DataLabel& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + LPDISPATCH GetFont(); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + double GetLeft(); + void SetLeft(double newValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + double GetTop(); + void SetTop(double newValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoText(); + void SetAutoText(BOOL bNewValue); + CString GetNumberFormat(); + void SetNumberFormat(LPCTSTR lpszNewValue); + BOOL GetNumberFormatLinked(); + void SetNumberFormatLinked(BOOL bNewValue); + VARIANT GetNumberFormatLocal(); + void SetNumberFormatLocal(const VARIANT& newValue); + BOOL GetShowLegendKey(); + void SetShowLegendKey(BOOL bNewValue); + VARIANT GetType(); + void SetType(const VARIANT& newValue); + long GetPosition(); + void SetPosition(long nNewValue); + BOOL GetShowSeriesName(); + void SetShowSeriesName(BOOL bNewValue); + BOOL GetShowCategoryName(); + void SetShowCategoryName(BOOL bNewValue); + BOOL GetShowValue(); + void SetShowValue(BOOL bNewValue); + BOOL GetShowPercentage(); + void SetShowPercentage(BOOL bNewValue); + BOOL GetShowBubbleSize(); + void SetShowBubbleSize(BOOL bNewValue); + VARIANT GetSeparator(); + void SetSeparator(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// DataLabels wrapper class + +class DataLabels : public COleDispatchDriver +{ +public: + DataLabels() {} // Calls COleDispatchDriver default constructor + DataLabels(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DataLabels(const DataLabels& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + LPDISPATCH GetFont(); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + BOOL GetAutoText(); + void SetAutoText(BOOL bNewValue); + CString GetNumberFormat(); + void SetNumberFormat(LPCTSTR lpszNewValue); + BOOL GetNumberFormatLinked(); + void SetNumberFormatLinked(BOOL bNewValue); + VARIANT GetNumberFormatLocal(); + void SetNumberFormatLocal(const VARIANT& newValue); + BOOL GetShowLegendKey(); + void SetShowLegendKey(BOOL bNewValue); + VARIANT GetType(); + void SetType(const VARIANT& newValue); + long GetPosition(); + void SetPosition(long nNewValue); + BOOL GetShowSeriesName(); + void SetShowSeriesName(BOOL bNewValue); + BOOL GetShowCategoryName(); + void SetShowCategoryName(BOOL bNewValue); + BOOL GetShowValue(); + void SetShowValue(BOOL bNewValue); + BOOL GetShowPercentage(); + void SetShowPercentage(BOOL bNewValue); + BOOL GetShowBubbleSize(); + void SetShowBubbleSize(BOOL bNewValue); + VARIANT GetSeparator(); + void SetSeparator(const VARIANT& newValue); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// LegendEntry wrapper class + +class LegendEntry : public COleDispatchDriver +{ +public: + LegendEntry() {} // Calls COleDispatchDriver default constructor + LegendEntry(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + LegendEntry(const LegendEntry& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT Delete(); + LPDISPATCH GetFont(); + long GetIndex(); + LPDISPATCH GetLegendKey(); + VARIANT Select(); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + double GetLeft(); + double GetTop(); + double GetWidth(); + double GetHeight(); +}; +///////////////////////////////////////////////////////////////////////////// +// LegendEntries wrapper class + +class LegendEntries : public COleDispatchDriver +{ +public: + LegendEntries() {} // Calls COleDispatchDriver default constructor + LegendEntries(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + LegendEntries(const LegendEntries& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// LegendKey wrapper class + +class LegendKey : public COleDispatchDriver +{ +public: + LegendKey() {} // Calls COleDispatchDriver default constructor + LegendKey(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + LegendKey(const LegendKey& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBorder(); + VARIANT ClearFormats(); + VARIANT Delete(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + BOOL GetInvertIfNegative(); + void SetInvertIfNegative(BOOL bNewValue); + long GetMarkerBackgroundColor(); + void SetMarkerBackgroundColor(long nNewValue); + long GetMarkerBackgroundColorIndex(); + void SetMarkerBackgroundColorIndex(long nNewValue); + long GetMarkerForegroundColor(); + void SetMarkerForegroundColor(long nNewValue); + long GetMarkerForegroundColorIndex(); + void SetMarkerForegroundColorIndex(long nNewValue); + long GetMarkerSize(); + void SetMarkerSize(long nNewValue); + long GetMarkerStyle(); + void SetMarkerStyle(long nNewValue); + long GetPictureType(); + void SetPictureType(long nNewValue); + long GetPictureUnit(); + void SetPictureUnit(long nNewValue); + VARIANT Select(); + BOOL GetSmooth(); + void SetSmooth(BOOL bNewValue); + double GetLeft(); + double GetTop(); + double GetWidth(); + double GetHeight(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Trendlines wrapper class + +class Trendlines : public COleDispatchDriver +{ +public: + Trendlines() {} // Calls COleDispatchDriver default constructor + Trendlines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Trendlines(const Trendlines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(long Type, const VARIANT& Order, const VARIANT& Period, const VARIANT& Forward, const VARIANT& Backward, const VARIANT& Intercept, const VARIANT& DisplayEquation, const VARIANT& DisplayRSquared, const VARIANT& Name); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Trendline wrapper class + +class Trendline : public COleDispatchDriver +{ +public: + Trendline() {} // Calls COleDispatchDriver default constructor + Trendline(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Trendline(const Trendline& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetBackward(); + void SetBackward(long nNewValue); + LPDISPATCH GetBorder(); + VARIANT ClearFormats(); + LPDISPATCH GetDataLabel(); + VARIANT Delete(); + BOOL GetDisplayEquation(); + void SetDisplayEquation(BOOL bNewValue); + BOOL GetDisplayRSquared(); + void SetDisplayRSquared(BOOL bNewValue); + long GetForward(); + void SetForward(long nNewValue); + long GetIndex(); + double GetIntercept(); + void SetIntercept(double newValue); + BOOL GetInterceptIsAuto(); + void SetInterceptIsAuto(BOOL bNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + BOOL GetNameIsAuto(); + void SetNameIsAuto(BOOL bNewValue); + long GetOrder(); + void SetOrder(long nNewValue); + long GetPeriod(); + void SetPeriod(long nNewValue); + VARIANT Select(); + long GetType(); + void SetType(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Corners wrapper class + +class Corners : public COleDispatchDriver +{ +public: + Corners() {} // Calls COleDispatchDriver default constructor + Corners(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Corners(const Corners& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); +}; +///////////////////////////////////////////////////////////////////////////// +// SeriesLines wrapper class + +class SeriesLines : public COleDispatchDriver +{ +public: + SeriesLines() {} // Calls COleDispatchDriver default constructor + SeriesLines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SeriesLines(const SeriesLines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// HiLoLines wrapper class + +class HiLoLines : public COleDispatchDriver +{ +public: + HiLoLines() {} // Calls COleDispatchDriver default constructor + HiLoLines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + HiLoLines(const HiLoLines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// Gridlines wrapper class + +class Gridlines : public COleDispatchDriver +{ +public: + Gridlines() {} // Calls COleDispatchDriver default constructor + Gridlines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Gridlines(const Gridlines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// DropLines wrapper class + +class DropLines : public COleDispatchDriver +{ +public: + DropLines() {} // Calls COleDispatchDriver default constructor + DropLines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DropLines(const DropLines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// LeaderLines wrapper class + +class LeaderLines : public COleDispatchDriver +{ +public: + LeaderLines() {} // Calls COleDispatchDriver default constructor + LeaderLines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + LeaderLines(const LeaderLines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBorder(); + void Delete(); + void Select(); +}; +///////////////////////////////////////////////////////////////////////////// +// UpBars wrapper class + +class UpBars : public COleDispatchDriver +{ +public: + UpBars() {} // Calls COleDispatchDriver default constructor + UpBars(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + UpBars(const UpBars& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); +}; +///////////////////////////////////////////////////////////////////////////// +// DownBars wrapper class + +class DownBars : public COleDispatchDriver +{ +public: + DownBars() {} // Calls COleDispatchDriver default constructor + DownBars(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DownBars(const DownBars& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); +}; +///////////////////////////////////////////////////////////////////////////// +// Floor wrapper class + +class Floor : public COleDispatchDriver +{ +public: + Floor() {} // Calls COleDispatchDriver default constructor + Floor(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Floor(const Floor& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT ClearFormats(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + VARIANT GetPictureType(); + void SetPictureType(const VARIANT& newValue); + void Paste(); +}; +///////////////////////////////////////////////////////////////////////////// +// Walls wrapper class + +class Walls : public COleDispatchDriver +{ +public: + Walls() {} // Calls COleDispatchDriver default constructor + Walls(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Walls(const Walls& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT ClearFormats(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + VARIANT GetPictureType(); + void SetPictureType(const VARIANT& newValue); + void Paste(); + VARIANT GetPictureUnit(); + void SetPictureUnit(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// TickLabels wrapper class + +class TickLabels : public COleDispatchDriver +{ +public: + TickLabels() {} // Calls COleDispatchDriver default constructor + TickLabels(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + TickLabels(const TickLabels& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT Delete(); + LPDISPATCH GetFont(); + CString GetName(); + CString GetNumberFormat(); + void SetNumberFormat(LPCTSTR lpszNewValue); + BOOL GetNumberFormatLinked(); + void SetNumberFormatLinked(BOOL bNewValue); + VARIANT GetNumberFormatLocal(); + void SetNumberFormatLocal(const VARIANT& newValue); + long GetOrientation(); + void SetOrientation(long nNewValue); + VARIANT Select(); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); + long GetDepth(); + long GetOffset(); + void SetOffset(long nNewValue); + long GetAlignment(); + void SetAlignment(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// PlotArea wrapper class + +class PlotArea : public COleDispatchDriver +{ +public: + PlotArea() {} // Calls COleDispatchDriver default constructor + PlotArea(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PlotArea(const PlotArea& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT ClearFormats(); + double GetHeight(); + void SetHeight(double newValue); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + double GetLeft(); + void SetLeft(double newValue); + double GetTop(); + void SetTop(double newValue); + double GetWidth(); + void SetWidth(double newValue); + double GetInsideLeft(); + double GetInsideTop(); + double GetInsideWidth(); + double GetInsideHeight(); +}; +///////////////////////////////////////////////////////////////////////////// +// ChartArea wrapper class + +class ChartArea : public COleDispatchDriver +{ +public: + ChartArea() {} // Calls COleDispatchDriver default constructor + ChartArea(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ChartArea(const ChartArea& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Clear(); + VARIANT ClearContents(); + VARIANT Copy(); + LPDISPATCH GetFont(); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + VARIANT ClearFormats(); + double GetHeight(); + void SetHeight(double newValue); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + double GetLeft(); + void SetLeft(double newValue); + double GetTop(); + void SetTop(double newValue); + double GetWidth(); + void SetWidth(double newValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Legend wrapper class + +class Legend : public COleDispatchDriver +{ +public: + Legend() {} // Calls COleDispatchDriver default constructor + Legend(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Legend(const Legend& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + LPDISPATCH GetFont(); + LPDISPATCH LegendEntries(const VARIANT& Index); + long GetPosition(); + void SetPosition(long nNewValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + VARIANT Clear(); + double GetHeight(); + void SetHeight(double newValue); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + double GetLeft(); + void SetLeft(double newValue); + double GetTop(); + void SetTop(double newValue); + double GetWidth(); + void SetWidth(double newValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ErrorBars wrapper class + +class ErrorBars : public COleDispatchDriver +{ +public: + ErrorBars() {} // Calls COleDispatchDriver default constructor + ErrorBars(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ErrorBars(const ErrorBars& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + VARIANT ClearFormats(); + long GetEndStyle(); + void SetEndStyle(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// DataTable wrapper class + +class DataTable : public COleDispatchDriver +{ +public: + DataTable() {} // Calls COleDispatchDriver default constructor + DataTable(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DataTable(const DataTable& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetShowLegendKey(); + void SetShowLegendKey(BOOL bNewValue); + BOOL GetHasBorderHorizontal(); + void SetHasBorderHorizontal(BOOL bNewValue); + BOOL GetHasBorderVertical(); + void SetHasBorderVertical(BOOL bNewValue); + BOOL GetHasBorderOutline(); + void SetHasBorderOutline(BOOL bNewValue); + LPDISPATCH GetBorder(); + LPDISPATCH GetFont(); + void Select(); + void Delete(); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Phonetic wrapper class + +class Phonetic : public COleDispatchDriver +{ +public: + Phonetic() {} // Calls COleDispatchDriver default constructor + Phonetic(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Phonetic(const Phonetic& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + long GetCharacterType(); + void SetCharacterType(long nNewValue); + long GetAlignment(); + void SetAlignment(long nNewValue); + LPDISPATCH GetFont(); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Shape wrapper class + +class Shape : public COleDispatchDriver +{ +public: + Shape() {} // Calls COleDispatchDriver default constructor + Shape(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Shape(const Shape& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Apply(); + void Delete(); + LPDISPATCH Duplicate(); + void Flip(long FlipCmd); + void IncrementLeft(float Increment); + void IncrementRotation(float Increment); + void IncrementTop(float Increment); + void PickUp(); + void RerouteConnections(); + void ScaleHeight(float Factor, long RelativeToOriginalSize, const VARIANT& Scale); + void ScaleWidth(float Factor, long RelativeToOriginalSize, const VARIANT& Scale); + void Select(const VARIANT& Replace); + void SetShapesDefaultProperties(); + LPDISPATCH Ungroup(); + void ZOrder(long ZOrderCmd); + LPDISPATCH GetAdjustments(); + LPDISPATCH GetTextFrame(); + long GetAutoShapeType(); + void SetAutoShapeType(long nNewValue); + LPDISPATCH GetCallout(); + long GetConnectionSiteCount(); + long GetConnector(); + LPDISPATCH GetConnectorFormat(); + LPDISPATCH GetFill(); + LPDISPATCH GetGroupItems(); + float GetHeight(); + void SetHeight(float newValue); + long GetHorizontalFlip(); + float GetLeft(); + void SetLeft(float newValue); + LPDISPATCH GetLine(); + long GetLockAspectRatio(); + void SetLockAspectRatio(long nNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetNodes(); + float GetRotation(); + void SetRotation(float newValue); + LPDISPATCH GetPictureFormat(); + LPDISPATCH GetShadow(); + LPDISPATCH GetTextEffect(); + LPDISPATCH GetThreeD(); + float GetTop(); + void SetTop(float newValue); + long GetType(); + long GetVerticalFlip(); + VARIANT GetVertices(); + long GetVisible(); + void SetVisible(long nNewValue); + float GetWidth(); + void SetWidth(float newValue); + long GetZOrderPosition(); + LPDISPATCH GetHyperlink(); + long GetBlackWhiteMode(); + void SetBlackWhiteMode(long nNewValue); + CString GetOnAction(); + void SetOnAction(LPCTSTR lpszNewValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + LPDISPATCH GetTopLeftCell(); + LPDISPATCH GetBottomRightCell(); + long GetPlacement(); + void SetPlacement(long nNewValue); + void Copy(); + void Cut(); + void CopyPicture(const VARIANT& Appearance, const VARIANT& Format); + LPDISPATCH GetControlFormat(); + LPDISPATCH GetLinkFormat(); + LPDISPATCH GetOLEFormat(); + long GetFormControlType(); + CString GetAlternativeText(); + void SetAlternativeText(LPCTSTR lpszNewValue); + LPDISPATCH GetScript(); + LPDISPATCH GetDiagramNode(); + long GetHasDiagramNode(); + LPDISPATCH GetDiagram(); + long GetHasDiagram(); + long GetChild(); + LPDISPATCH GetParentGroup(); + long GetId(); +}; +///////////////////////////////////////////////////////////////////////////// +// Shapes wrapper class + +class Shapes : public COleDispatchDriver +{ +public: + Shapes() {} // Calls COleDispatchDriver default constructor + Shapes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Shapes(const Shapes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH _Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH AddCallout(long Type, float Left, float Top, float Width, float Height); + LPDISPATCH AddConnector(long Type, float BeginX, float BeginY, float EndX, float EndY); + LPDISPATCH AddCurve(const VARIANT& SafeArrayOfPoints); + LPDISPATCH AddLabel(long Orientation, float Left, float Top, float Width, float Height); + LPDISPATCH AddLine(float BeginX, float BeginY, float EndX, float EndY); + LPDISPATCH AddPicture(LPCTSTR Filename, long LinkToFile, long SaveWithDocument, float Left, float Top, float Width, float Height); + LPDISPATCH AddPolyline(const VARIANT& SafeArrayOfPoints); + LPDISPATCH AddShape(long Type, float Left, float Top, float Width, float Height); + LPDISPATCH AddTextEffect(long PresetTextEffect, LPCTSTR Text, LPCTSTR FontName, float FontSize, long FontBold, long FontItalic, float Left, float Top); + LPDISPATCH AddTextbox(long Orientation, float Left, float Top, float Width, float Height); + LPDISPATCH BuildFreeform(long EditingType, float X1, float Y1); + LPDISPATCH GetRange(const VARIANT& Index); + void SelectAll(); + LPDISPATCH AddFormControl(long Type, long Left, long Top, long Width, long Height); + LPDISPATCH AddOLEObject(const VARIANT& ClassType, const VARIANT& Filename, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel, const VARIANT& Left, + const VARIANT& Top, const VARIANT& Width, const VARIANT& Height); + LPDISPATCH AddDiagram(long Type, float Left, float Top, float Width, float Height); +}; +///////////////////////////////////////////////////////////////////////////// +// ShapeRange wrapper class + +class ShapeRange : public COleDispatchDriver +{ +public: + ShapeRange() {} // Calls COleDispatchDriver default constructor + ShapeRange(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ShapeRange(const ShapeRange& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH _Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + void Align(long AlignCmd, long RelativeTo); + void Apply(); + void Delete(); + void Distribute(long DistributeCmd, long RelativeTo); + LPDISPATCH Duplicate(); + void Flip(long FlipCmd); + void IncrementLeft(float Increment); + void IncrementRotation(float Increment); + void IncrementTop(float Increment); + LPDISPATCH Group(); + void PickUp(); + void RerouteConnections(); + LPDISPATCH Regroup(); + void ScaleHeight(float Factor, long RelativeToOriginalSize, const VARIANT& Scale); + void ScaleWidth(float Factor, long RelativeToOriginalSize, const VARIANT& Scale); + void Select(const VARIANT& Replace); + void SetShapesDefaultProperties(); + LPDISPATCH Ungroup(); + void ZOrder(long ZOrderCmd); + LPDISPATCH GetAdjustments(); + LPDISPATCH GetTextFrame(); + long GetAutoShapeType(); + void SetAutoShapeType(long nNewValue); + LPDISPATCH GetCallout(); + long GetConnectionSiteCount(); + long GetConnector(); + LPDISPATCH GetConnectorFormat(); + LPDISPATCH GetFill(); + LPDISPATCH GetGroupItems(); + float GetHeight(); + void SetHeight(float newValue); + long GetHorizontalFlip(); + float GetLeft(); + void SetLeft(float newValue); + LPDISPATCH GetLine(); + long GetLockAspectRatio(); + void SetLockAspectRatio(long nNewValue); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetNodes(); + float GetRotation(); + void SetRotation(float newValue); + LPDISPATCH GetPictureFormat(); + LPDISPATCH GetShadow(); + LPDISPATCH GetTextEffect(); + LPDISPATCH GetThreeD(); + float GetTop(); + void SetTop(float newValue); + long GetType(); + long GetVerticalFlip(); + VARIANT GetVertices(); + long GetVisible(); + void SetVisible(long nNewValue); + float GetWidth(); + void SetWidth(float newValue); + long GetZOrderPosition(); + long GetBlackWhiteMode(); + void SetBlackWhiteMode(long nNewValue); + CString GetAlternativeText(); + void SetAlternativeText(LPCTSTR lpszNewValue); + LPDISPATCH GetDiagramNode(); + long GetHasDiagramNode(); + LPDISPATCH GetDiagram(); + long GetHasDiagram(); + long GetChild(); + LPDISPATCH GetParentGroup(); + long GetId(); +}; +///////////////////////////////////////////////////////////////////////////// +// GroupShapes wrapper class + +class GroupShapes : public COleDispatchDriver +{ +public: + GroupShapes() {} // Calls COleDispatchDriver default constructor + GroupShapes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + GroupShapes(const GroupShapes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH _Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH GetRange(const VARIANT& Index); +}; +///////////////////////////////////////////////////////////////////////////// +// TextFrame wrapper class + +class TextFrame : public COleDispatchDriver +{ +public: + TextFrame() {} // Calls COleDispatchDriver default constructor + TextFrame(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + TextFrame(const TextFrame& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + float GetMarginBottom(); + void SetMarginBottom(float newValue); + float GetMarginLeft(); + void SetMarginLeft(float newValue); + float GetMarginRight(); + void SetMarginRight(float newValue); + float GetMarginTop(); + void SetMarginTop(float newValue); + long GetOrientation(); + void SetOrientation(long nNewValue); + LPDISPATCH Characters(const VARIANT& Start, const VARIANT& Length); + long GetHorizontalAlignment(); + void SetHorizontalAlignment(long nNewValue); + long GetVerticalAlignment(); + void SetVerticalAlignment(long nNewValue); + BOOL GetAutoSize(); + void SetAutoSize(BOOL bNewValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + BOOL GetAutoMargins(); + void SetAutoMargins(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ConnectorFormat wrapper class + +class ConnectorFormat : public COleDispatchDriver +{ +public: + ConnectorFormat() {} // Calls COleDispatchDriver default constructor + ConnectorFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ConnectorFormat(const ConnectorFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void BeginConnect(LPDISPATCH ConnectedShape, long ConnectionSite); + void BeginDisconnect(); + void EndConnect(LPDISPATCH ConnectedShape, long ConnectionSite); + void EndDisconnect(); + long GetBeginConnected(); + LPDISPATCH GetBeginConnectedShape(); + long GetBeginConnectionSite(); + long GetEndConnected(); + LPDISPATCH GetEndConnectedShape(); + long GetEndConnectionSite(); + long GetType(); + void SetType(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// FreeformBuilder wrapper class + +class FreeformBuilder : public COleDispatchDriver +{ +public: + FreeformBuilder() {} // Calls COleDispatchDriver default constructor + FreeformBuilder(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + FreeformBuilder(const FreeformBuilder& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void AddNodes(long SegmentType, long EditingType, float X1, float Y1, const VARIANT& X2, const VARIANT& Y2, const VARIANT& X3, const VARIANT& Y3); + LPDISPATCH ConvertToShape(); +}; +///////////////////////////////////////////////////////////////////////////// +// ControlFormat wrapper class + +class ControlFormat : public COleDispatchDriver +{ +public: + ControlFormat() {} // Calls COleDispatchDriver default constructor + ControlFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ControlFormat(const ControlFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void AddItem(LPCTSTR Text, const VARIANT& Index); + void RemoveAllItems(); + void RemoveItem(long Index, const VARIANT& Count); + long GetDropDownLines(); + void SetDropDownLines(long nNewValue); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + long GetLargeChange(); + void SetLargeChange(long nNewValue); + CString GetLinkedCell(); + void SetLinkedCell(LPCTSTR lpszNewValue); + VARIANT List(const VARIANT& Index); + long GetListCount(); + void SetListCount(long nNewValue); + CString GetListFillRange(); + void SetListFillRange(LPCTSTR lpszNewValue); + long GetListIndex(); + void SetListIndex(long nNewValue); + BOOL GetLockedText(); + void SetLockedText(BOOL bNewValue); + long GetMax(); + void SetMax(long nNewValue); + long GetMin(); + void SetMin(long nNewValue); + long GetMultiSelect(); + void SetMultiSelect(long nNewValue); + BOOL GetPrintObject(); + void SetPrintObject(BOOL bNewValue); + long GetSmallChange(); + void SetSmallChange(long nNewValue); + long Get_Default(); + void Set_Default(long nNewValue); + long GetValue(); + void SetValue(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// OLEFormat wrapper class + +class OLEFormat : public COleDispatchDriver +{ +public: + OLEFormat() {} // Calls COleDispatchDriver default constructor + OLEFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + OLEFormat(const OLEFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Activate(); + LPDISPATCH GetObject(); + CString GetProgID(); + void Verb(const VARIANT& Verb); +}; +///////////////////////////////////////////////////////////////////////////// +// LinkFormat wrapper class + +class LinkFormat : public COleDispatchDriver +{ +public: + LinkFormat() {} // Calls COleDispatchDriver default constructor + LinkFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + LinkFormat(const LinkFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetAutoUpdate(); + void SetAutoUpdate(BOOL bNewValue); + BOOL GetLocked(); + void SetLocked(BOOL bNewValue); + void Update(); +}; +///////////////////////////////////////////////////////////////////////////// +// PublishObjects wrapper class + +class PublishObjects : public COleDispatchDriver +{ +public: + PublishObjects() {} // Calls COleDispatchDriver default constructor + PublishObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PublishObjects(const PublishObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(long SourceType, LPCTSTR Filename, const VARIANT& Sheet, const VARIANT& Source, const VARIANT& HtmlType, const VARIANT& DivID, const VARIANT& Title); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + void Delete(); + void Publish(); +}; +///////////////////////////////////////////////////////////////////////////// +// OLEDBError wrapper class + +class OLEDBError : public COleDispatchDriver +{ +public: + OLEDBError() {} // Calls COleDispatchDriver default constructor + OLEDBError(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + OLEDBError(const OLEDBError& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetSqlState(); + CString GetErrorString(); + long GetNative(); + long GetNumber(); + long GetStage(); +}; +///////////////////////////////////////////////////////////////////////////// +// OLEDBErrors wrapper class + +class OLEDBErrors : public COleDispatchDriver +{ +public: + OLEDBErrors() {} // Calls COleDispatchDriver default constructor + OLEDBErrors(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + OLEDBErrors(const OLEDBErrors& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(long Index); + LPDISPATCH Get_Default(long Index); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Phonetics wrapper class + +class Phonetics : public COleDispatchDriver +{ +public: + Phonetics() {} // Calls COleDispatchDriver default constructor + Phonetics(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Phonetics(const Phonetics& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + long GetStart(); + long GetLength(); + BOOL GetVisible(); + void SetVisible(BOOL bNewValue); + long GetCharacterType(); + void SetCharacterType(long nNewValue); + long GetAlignment(); + void SetAlignment(long nNewValue); + LPDISPATCH GetFont(); + LPDISPATCH GetItem(long Index); + void Delete(); + void Add(long Start, long Length, LPCTSTR Text); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + LPDISPATCH Get_Default(long Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotLayout wrapper class + +class PivotLayout : public COleDispatchDriver +{ +public: + PivotLayout() {} // Calls COleDispatchDriver default constructor + PivotLayout(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotLayout(const PivotLayout& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetPivotTable(); +}; +///////////////////////////////////////////////////////////////////////////// +// DisplayUnitLabel wrapper class + +class DisplayUnitLabel : public COleDispatchDriver +{ +public: + DisplayUnitLabel() {} // Calls COleDispatchDriver default constructor + DisplayUnitLabel(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + DisplayUnitLabel(const DisplayUnitLabel& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + VARIANT Select(); + LPDISPATCH GetBorder(); + VARIANT Delete(); + LPDISPATCH GetInterior(); + LPDISPATCH GetFill(); + CString GetCaption(); + void SetCaption(LPCTSTR lpszNewValue); + LPDISPATCH GetCharacters(const VARIANT& Start, const VARIANT& Length); + LPDISPATCH GetFont(); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + double GetLeft(); + void SetLeft(double newValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + BOOL GetShadow(); + void SetShadow(BOOL bNewValue); + CString GetText(); + void SetText(LPCTSTR lpszNewValue); + double GetTop(); + void SetTop(double newValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + long GetReadingOrder(); + void SetReadingOrder(long nNewValue); + VARIANT GetAutoScaleFont(); + void SetAutoScaleFont(const VARIANT& newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// CellFormat wrapper class + +class CellFormat : public COleDispatchDriver +{ +public: + CellFormat() {} // Calls COleDispatchDriver default constructor + CellFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CellFormat(const CellFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetBorders(); + void SetRefBorders(LPDISPATCH newValue); + LPDISPATCH GetFont(); + void SetRefFont(LPDISPATCH newValue); + LPDISPATCH GetInterior(); + void SetRefInterior(LPDISPATCH newValue); + VARIANT GetNumberFormat(); + void SetNumberFormat(const VARIANT& newValue); + VARIANT GetNumberFormatLocal(); + void SetNumberFormatLocal(const VARIANT& newValue); + VARIANT GetAddIndent(); + void SetAddIndent(const VARIANT& newValue); + VARIANT GetIndentLevel(); + void SetIndentLevel(const VARIANT& newValue); + VARIANT GetHorizontalAlignment(); + void SetHorizontalAlignment(const VARIANT& newValue); + VARIANT GetVerticalAlignment(); + void SetVerticalAlignment(const VARIANT& newValue); + VARIANT GetOrientation(); + void SetOrientation(const VARIANT& newValue); + VARIANT GetShrinkToFit(); + void SetShrinkToFit(const VARIANT& newValue); + VARIANT GetWrapText(); + void SetWrapText(const VARIANT& newValue); + VARIANT GetLocked(); + void SetLocked(const VARIANT& newValue); + VARIANT GetFormulaHidden(); + void SetFormulaHidden(const VARIANT& newValue); + VARIANT GetMergeCells(); + void SetMergeCells(const VARIANT& newValue); + void Clear(); +}; +///////////////////////////////////////////////////////////////////////////// +// UsedObjects wrapper class + +class UsedObjects : public COleDispatchDriver +{ +public: + UsedObjects() {} // Calls COleDispatchDriver default constructor + UsedObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + UsedObjects(const UsedObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); +}; +///////////////////////////////////////////////////////////////////////////// +// CustomProperties wrapper class + +class CustomProperties : public COleDispatchDriver +{ +public: + CustomProperties() {} // Calls COleDispatchDriver default constructor + CustomProperties(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CustomProperties(const CustomProperties& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR Name, const VARIANT& Value); + long GetCount(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// CustomProperty wrapper class + +class CustomProperty : public COleDispatchDriver +{ +public: + CustomProperty() {} // Calls COleDispatchDriver default constructor + CustomProperty(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CustomProperty(const CustomProperty& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + VARIANT GetValue(); + void SetValue(const VARIANT& newValue); + VARIANT Get_Default(); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// CalculatedMembers wrapper class + +class CalculatedMembers : public COleDispatchDriver +{ +public: + CalculatedMembers() {} // Calls COleDispatchDriver default constructor + CalculatedMembers(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CalculatedMembers(const CalculatedMembers& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH Add(LPCTSTR Name, LPCTSTR Formula, const VARIANT& SolveOrder, const VARIANT& Type); +}; +///////////////////////////////////////////////////////////////////////////// +// CalculatedMember wrapper class + +class CalculatedMember : public COleDispatchDriver +{ +public: + CalculatedMember() {} // Calls COleDispatchDriver default constructor + CalculatedMember(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + CalculatedMember(const CalculatedMember& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + CString GetFormula(); + CString GetSourceName(); + long GetSolveOrder(); + BOOL GetIsValid(); + CString Get_Default(); + void Delete(); + long GetType(); +}; +///////////////////////////////////////////////////////////////////////////// +// Watches wrapper class + +class Watches : public COleDispatchDriver +{ +public: + Watches() {} // Calls COleDispatchDriver default constructor + Watches(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Watches(const Watches& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Source); + long GetCount(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// Watch wrapper class + +class Watch : public COleDispatchDriver +{ +public: + Watch() {} // Calls COleDispatchDriver default constructor + Watch(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Watch(const Watch& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Delete(); + VARIANT GetSource(); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotCell wrapper class + +class PivotCell : public COleDispatchDriver +{ +public: + PivotCell() {} // Calls COleDispatchDriver default constructor + PivotCell(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotCell(const PivotCell& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetPivotCellType(); + LPDISPATCH GetPivotTable(); + LPDISPATCH GetDataField(); + LPDISPATCH GetPivotField(); + LPDISPATCH GetPivotItem(); + LPDISPATCH GetRowItems(); + LPDISPATCH GetColumnItems(); + LPDISPATCH GetRange(); + long GetCustomSubtotalFunction(); +}; +///////////////////////////////////////////////////////////////////////////// +// Graphic wrapper class + +class Graphic : public COleDispatchDriver +{ +public: + Graphic() {} // Calls COleDispatchDriver default constructor + Graphic(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Graphic(const Graphic& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + float GetBrightness(); + void SetBrightness(float newValue); + long GetColorType(); + void SetColorType(long nNewValue); + float GetContrast(); + void SetContrast(float newValue); + float GetCropBottom(); + void SetCropBottom(float newValue); + float GetCropLeft(); + void SetCropLeft(float newValue); + float GetCropRight(); + void SetCropRight(float newValue); + float GetCropTop(); + void SetCropTop(float newValue); + CString GetFilename(); + void SetFilename(LPCTSTR lpszNewValue); + float GetHeight(); + void SetHeight(float newValue); + long GetLockAspectRatio(); + void SetLockAspectRatio(long nNewValue); + float GetWidth(); + void SetWidth(float newValue); +}; +///////////////////////////////////////////////////////////////////////////// +// AutoRecover wrapper class + +class AutoRecover : public COleDispatchDriver +{ +public: + AutoRecover() {} // Calls COleDispatchDriver default constructor + AutoRecover(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AutoRecover(const AutoRecover& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + long GetTime(); + void SetTime(long nNewValue); + CString GetPath(); + void SetPath(LPCTSTR lpszNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// ErrorCheckingOptions wrapper class + +class ErrorCheckingOptions : public COleDispatchDriver +{ +public: + ErrorCheckingOptions() {} // Calls COleDispatchDriver default constructor + ErrorCheckingOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ErrorCheckingOptions(const ErrorCheckingOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetBackgroundChecking(); + void SetBackgroundChecking(BOOL bNewValue); + long GetIndicatorColorIndex(); + void SetIndicatorColorIndex(long nNewValue); + BOOL GetEvaluateToError(); + void SetEvaluateToError(BOOL bNewValue); + BOOL GetTextDate(); + void SetTextDate(BOOL bNewValue); + BOOL GetNumberAsText(); + void SetNumberAsText(BOOL bNewValue); + BOOL GetInconsistentFormula(); + void SetInconsistentFormula(BOOL bNewValue); + BOOL GetOmittedCells(); + void SetOmittedCells(BOOL bNewValue); + BOOL GetUnlockedFormulaCells(); + void SetUnlockedFormulaCells(BOOL bNewValue); + BOOL GetEmptyCellReferences(); + void SetEmptyCellReferences(BOOL bNewValue); + BOOL GetListDataValidation(); + void SetListDataValidation(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Errors wrapper class + +class Errors : public COleDispatchDriver +{ +public: + Errors() {} // Calls COleDispatchDriver default constructor + Errors(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Errors(const Errors& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetItem(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); +}; +///////////////////////////////////////////////////////////////////////////// +// Error wrapper class + +class Error : public COleDispatchDriver +{ +public: + Error() {} // Calls COleDispatchDriver default constructor + Error(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Error(const Error& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetValue(); + BOOL GetIgnore(); + void SetIgnore(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// SmartTagAction wrapper class + +class SmartTagAction : public COleDispatchDriver +{ +public: + SmartTagAction() {} // Calls COleDispatchDriver default constructor + SmartTagAction(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SmartTagAction(const SmartTagAction& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetName(); + void Execute(); + CString Get_Default(); + long GetType(); + BOOL GetPresentInPane(); + BOOL GetExpandHelp(); + void SetExpandHelp(BOOL bNewValue); + BOOL GetCheckboxState(); + void SetCheckboxState(BOOL bNewValue); + CString GetTextboxText(); + void SetTextboxText(LPCTSTR lpszNewValue); + long GetListSelection(); + void SetListSelection(long nNewValue); + long GetRadioGroupSelection(); + void SetRadioGroupSelection(long nNewValue); + LPDISPATCH GetActiveXControl(); +}; +///////////////////////////////////////////////////////////////////////////// +// SmartTagActions wrapper class + +class SmartTagActions : public COleDispatchDriver +{ +public: + SmartTagActions() {} // Calls COleDispatchDriver default constructor + SmartTagActions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SmartTagActions(const SmartTagActions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// SmartTag wrapper class + +class SmartTag : public COleDispatchDriver +{ +public: + SmartTag() {} // Calls COleDispatchDriver default constructor + SmartTag(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SmartTag(const SmartTag& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString GetDownloadURL(); + CString GetName(); + CString Get_Default(); + CString GetXml(); + LPDISPATCH GetRange(); + void Delete(); + LPDISPATCH GetSmartTagActions(); + LPDISPATCH GetProperties(); +}; +///////////////////////////////////////////////////////////////////////////// +// SmartTags wrapper class + +class SmartTags : public COleDispatchDriver +{ +public: + SmartTags() {} // Calls COleDispatchDriver default constructor + SmartTags(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SmartTags(const SmartTags& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR SmartTagType); + long GetCount(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// SmartTagRecognizer wrapper class + +class SmartTagRecognizer : public COleDispatchDriver +{ +public: + SmartTagRecognizer() {} // Calls COleDispatchDriver default constructor + SmartTagRecognizer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SmartTagRecognizer(const SmartTagRecognizer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + BOOL GetEnabled(); + void SetEnabled(BOOL bNewValue); + CString GetProgID(); + CString Get_Default(); + CString GetFullName(); +}; +///////////////////////////////////////////////////////////////////////////// +// SmartTagRecognizers wrapper class + +class SmartTagRecognizers : public COleDispatchDriver +{ +public: + SmartTagRecognizers() {} // Calls COleDispatchDriver default constructor + SmartTagRecognizers(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SmartTagRecognizers(const SmartTagRecognizers& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + BOOL GetRecognize(); + void SetRecognize(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// SmartTagOptions wrapper class + +class SmartTagOptions : public COleDispatchDriver +{ +public: + SmartTagOptions() {} // Calls COleDispatchDriver default constructor + SmartTagOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SmartTagOptions(const SmartTagOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetDisplaySmartTags(); + void SetDisplaySmartTags(long nNewValue); + BOOL GetEmbedSmartTags(); + void SetEmbedSmartTags(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// SpellingOptions wrapper class + +class SpellingOptions : public COleDispatchDriver +{ +public: + SpellingOptions() {} // Calls COleDispatchDriver default constructor + SpellingOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + SpellingOptions(const SpellingOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + long GetDictLang(); + void SetDictLang(long nNewValue); + CString GetUserDict(); + void SetUserDict(LPCTSTR lpszNewValue); + BOOL GetIgnoreCaps(); + void SetIgnoreCaps(BOOL bNewValue); + BOOL GetSuggestMainOnly(); + void SetSuggestMainOnly(BOOL bNewValue); + BOOL GetIgnoreMixedDigits(); + void SetIgnoreMixedDigits(BOOL bNewValue); + BOOL GetIgnoreFileNames(); + void SetIgnoreFileNames(BOOL bNewValue); + BOOL GetGermanPostReform(); + void SetGermanPostReform(BOOL bNewValue); + BOOL GetKoreanCombineAux(); + void SetKoreanCombineAux(BOOL bNewValue); + BOOL GetKoreanUseAutoChangeList(); + void SetKoreanUseAutoChangeList(BOOL bNewValue); + BOOL GetKoreanProcessCompound(); + void SetKoreanProcessCompound(BOOL bNewValue); + long GetHebrewModes(); + void SetHebrewModes(long nNewValue); + long GetArabicModes(); + void SetArabicModes(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Speech wrapper class + +class Speech : public COleDispatchDriver +{ +public: + Speech() {} // Calls COleDispatchDriver default constructor + Speech(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Speech(const Speech& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + void Speak(LPCTSTR Text, const VARIANT& SpeakAsync, const VARIANT& SpeakXML, const VARIANT& Purge); + long GetDirection(); + void SetDirection(long nNewValue); + BOOL GetSpeakCellOnEnter(); + void SetSpeakCellOnEnter(BOOL bNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// Protection wrapper class + +class Protection : public COleDispatchDriver +{ +public: + Protection() {} // Calls COleDispatchDriver default constructor + Protection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Protection(const Protection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + BOOL GetAllowFormattingCells(); + BOOL GetAllowFormattingColumns(); + BOOL GetAllowFormattingRows(); + BOOL GetAllowInsertingColumns(); + BOOL GetAllowInsertingRows(); + BOOL GetAllowInsertingHyperlinks(); + BOOL GetAllowDeletingColumns(); + BOOL GetAllowDeletingRows(); + BOOL GetAllowSorting(); + BOOL GetAllowFiltering(); + BOOL GetAllowUsingPivotTables(); + LPDISPATCH GetAllowEditRanges(); +}; +///////////////////////////////////////////////////////////////////////////// +// PivotItemList wrapper class + +class PivotItemList : public COleDispatchDriver +{ +public: + PivotItemList() {} // Calls COleDispatchDriver default constructor + PivotItemList(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + PivotItemList(const PivotItemList& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long GetCount(); + LPDISPATCH Item(const VARIANT& Index); + LPDISPATCH Get_Default(const VARIANT& Field); + LPUNKNOWN _NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// Tab wrapper class + +class Tab : public COleDispatchDriver +{ +public: + Tab() {} // Calls COleDispatchDriver default constructor + Tab(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Tab(const Tab& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + VARIANT GetColor(); + void SetColor(const VARIANT& newValue); + long GetColorIndex(); + void SetColorIndex(long nNewValue); +}; +///////////////////////////////////////////////////////////////////////////// +// AllowEditRanges wrapper class + +class AllowEditRanges : public COleDispatchDriver +{ +public: + AllowEditRanges() {} // Calls COleDispatchDriver default constructor + AllowEditRanges(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AllowEditRanges(const AllowEditRanges& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPDISPATCH Add(LPCTSTR Title, LPDISPATCH Range, const VARIANT& Password); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// AllowEditRange wrapper class + +class AllowEditRange : public COleDispatchDriver +{ +public: + AllowEditRange() {} // Calls COleDispatchDriver default constructor + AllowEditRange(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + AllowEditRange(const AllowEditRange& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + CString GetTitle(); + void SetTitle(LPCTSTR lpszNewValue); + LPDISPATCH GetRange(); + void SetRefRange(LPDISPATCH newValue); + void ChangePassword(LPCTSTR Password); + void Delete(); + void Unprotect(const VARIANT& Password); + LPDISPATCH GetUsers(); +}; +///////////////////////////////////////////////////////////////////////////// +// UserAccessList wrapper class + +class UserAccessList : public COleDispatchDriver +{ +public: + UserAccessList() {} // Calls COleDispatchDriver default constructor + UserAccessList(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + UserAccessList(const UserAccessList& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + long GetCount(); + LPDISPATCH GetItem(const VARIANT& Index); + LPDISPATCH Add(LPCTSTR Name, BOOL AllowEdit); + void DeleteAll(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// UserAccess wrapper class + +class UserAccess : public COleDispatchDriver +{ +public: + UserAccess() {} // Calls COleDispatchDriver default constructor + UserAccess(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + UserAccess(const UserAccess& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + CString GetName(); + BOOL GetAllowEdit(); + void SetAllowEdit(BOOL bNewValue); + void Delete(); +}; +///////////////////////////////////////////////////////////////////////////// +// RTD wrapper class + +class RTD : public COleDispatchDriver +{ +public: + RTD() {} // Calls COleDispatchDriver default constructor + RTD(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + RTD(const RTD& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + long GetThrottleInterval(); + void SetThrottleInterval(long nNewValue); + void RefreshData(); + void RestartServers(); +}; +///////////////////////////////////////////////////////////////////////////// +// Diagram wrapper class + +class Diagram : public COleDispatchDriver +{ +public: + Diagram() {} // Calls COleDispatchDriver default constructor + Diagram(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + Diagram(const Diagram& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetNodes(); + long GetType(); + long GetAutoLayout(); + void SetAutoLayout(long nNewValue); + long GetReverse(); + void SetReverse(long nNewValue); + long GetAutoFormat(); + void SetAutoFormat(long nNewValue); + void Convert(long Type); + void FitText(); +}; +///////////////////////////////////////////////////////////////////////////// +// ListObjects wrapper class + +class ListObjects : public COleDispatchDriver +{ +public: + ListObjects() {} // Calls COleDispatchDriver default constructor + ListObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListObjects(const ListObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(long SourceType, const VARIANT& Source, const VARIANT& LinkSource, long XlListObjectHasHeaders, const VARIANT& Destination); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH GetItem(const VARIANT& Index); + long GetCount(); +}; +///////////////////////////////////////////////////////////////////////////// +// ListObject wrapper class + +class ListObject : public COleDispatchDriver +{ +public: + ListObject() {} // Calls COleDispatchDriver default constructor + ListObject(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListObject(const ListObject& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Delete(); + CString Publish(const VARIANT& Target, BOOL LinkSource); + void Refresh(); + void Unlink(); + void Unlist(); + void UpdateChanges(long iConflictType); + void Resize(LPDISPATCH Range); + CString Get_Default(); + BOOL GetActive(); + LPDISPATCH GetDataBodyRange(); + BOOL GetDisplayRightToLeft(); + LPDISPATCH GetHeaderRowRange(); + LPDISPATCH GetInsertRowRange(); + LPDISPATCH GetListColumns(); + LPDISPATCH GetListRows(); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetQueryTable(); + LPDISPATCH GetRange(); + BOOL GetShowAutoFilter(); + void SetShowAutoFilter(BOOL bNewValue); + BOOL GetShowTotals(); + void SetShowTotals(BOOL bNewValue); + long GetSourceType(); + LPDISPATCH GetTotalsRowRange(); + CString GetSharePointURL(); + LPDISPATCH GetXmlMap(); +}; +///////////////////////////////////////////////////////////////////////////// +// ListColumns wrapper class + +class ListColumns : public COleDispatchDriver +{ +public: + ListColumns() {} // Calls COleDispatchDriver default constructor + ListColumns(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListColumns(const ListColumns& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Position); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH GetItem(const VARIANT& Index); + long GetCount(); +}; +///////////////////////////////////////////////////////////////////////////// +// ListColumn wrapper class + +class ListColumn : public COleDispatchDriver +{ +public: + ListColumn() {} // Calls COleDispatchDriver default constructor + ListColumn(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListColumn(const ListColumn& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Delete(); + CString Get_Default(); + LPDISPATCH GetListDataFormat(); + long GetIndex(); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + LPDISPATCH GetRange(); + long GetTotalsCalculation(); + void SetTotalsCalculation(long nNewValue); + LPDISPATCH GetXPath(); + CString GetSharePointFormula(); +}; +///////////////////////////////////////////////////////////////////////////// +// ListRows wrapper class + +class ListRows : public COleDispatchDriver +{ +public: + ListRows() {} // Calls COleDispatchDriver default constructor + ListRows(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListRows(const ListRows& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(const VARIANT& Position); + LPDISPATCH Get_Default(const VARIANT& Index); + LPUNKNOWN Get_NewEnum(); + LPDISPATCH GetItem(const VARIANT& Index); + long GetCount(); +}; +///////////////////////////////////////////////////////////////////////////// +// ListRow wrapper class + +class ListRow : public COleDispatchDriver +{ +public: + ListRow() {} // Calls COleDispatchDriver default constructor + ListRow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListRow(const ListRow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + void Delete(); + long GetIndex(); + BOOL GetInvalidData(); + LPDISPATCH GetRange(); +}; +///////////////////////////////////////////////////////////////////////////// +// XmlNamespace wrapper class + +class XmlNamespace : public COleDispatchDriver +{ +public: + XmlNamespace() {} // Calls COleDispatchDriver default constructor + XmlNamespace(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + XmlNamespace(const XmlNamespace& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString Get_Default(); + CString GetUri(); + CString GetPrefix(); +}; +///////////////////////////////////////////////////////////////////////////// +// XmlNamespaces wrapper class + +class XmlNamespaces : public COleDispatchDriver +{ +public: + XmlNamespaces() {} // Calls COleDispatchDriver default constructor + XmlNamespaces(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + XmlNamespaces(const XmlNamespaces& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + long GetCount(); + CString GetValue(); + LPUNKNOWN Get_NewEnum(); + void InstallManifest(LPCTSTR Path, const VARIANT& InstallForAllUsers); +}; +///////////////////////////////////////////////////////////////////////////// +// XmlDataBinding wrapper class + +class XmlDataBinding : public COleDispatchDriver +{ +public: + XmlDataBinding() {} // Calls COleDispatchDriver default constructor + XmlDataBinding(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + XmlDataBinding(const XmlDataBinding& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString Get_Default(); + long Refresh(); + void LoadSettings(LPCTSTR Url); + void ClearSettings(); + CString GetSourceUrl(); +}; +///////////////////////////////////////////////////////////////////////////// +// XmlSchema wrapper class + +class XmlSchema : public COleDispatchDriver +{ +public: + XmlSchema() {} // Calls COleDispatchDriver default constructor + XmlSchema(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + XmlSchema(const XmlSchema& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH GetNamespace(); + CString GetXml(); + CString GetName(); +}; +///////////////////////////////////////////////////////////////////////////// +// XmlSchemas wrapper class + +class XmlSchemas : public COleDispatchDriver +{ +public: + XmlSchemas() {} // Calls COleDispatchDriver default constructor + XmlSchemas(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + XmlSchemas(const XmlSchemas& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + long GetCount(); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// XmlMap wrapper class + +class XmlMap : public COleDispatchDriver +{ +public: + XmlMap() {} // Calls COleDispatchDriver default constructor + XmlMap(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + XmlMap(const XmlMap& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString Get_Default(); + CString GetName(); + void SetName(LPCTSTR lpszNewValue); + BOOL GetIsExportable(); + BOOL GetShowImportExportValidationErrors(); + void SetShowImportExportValidationErrors(BOOL bNewValue); + BOOL GetSaveDataSourceDefinition(); + void SetSaveDataSourceDefinition(BOOL bNewValue); + BOOL GetAdjustColumnWidth(); + void SetAdjustColumnWidth(BOOL bNewValue); + BOOL GetPreserveColumnFilter(); + void SetPreserveColumnFilter(BOOL bNewValue); + BOOL GetPreserveNumberFormatting(); + void SetPreserveNumberFormatting(BOOL bNewValue); + BOOL GetAppendOnImport(); + void SetAppendOnImport(BOOL bNewValue); + CString GetRootElementName(); + LPDISPATCH GetRootElementNamespace(); + LPDISPATCH GetSchemas(); + LPDISPATCH GetDataBinding(); + void Delete(); + long Import(LPCTSTR Url, const VARIANT& Overwrite); + long ImportXml(LPCTSTR XmlData, const VARIANT& Overwrite); + long Export(LPCTSTR Url, const VARIANT& Overwrite); + long ExportXml(BSTR* Data); +}; +///////////////////////////////////////////////////////////////////////////// +// XmlMaps wrapper class + +class XmlMaps : public COleDispatchDriver +{ +public: + XmlMaps() {} // Calls COleDispatchDriver default constructor + XmlMaps(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + XmlMaps(const XmlMaps& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + LPDISPATCH Add(LPCTSTR Schema, const VARIANT& RootElementName); + LPDISPATCH Get_Default(const VARIANT& Index); + LPDISPATCH GetItem(const VARIANT& Index); + long GetCount(); + LPUNKNOWN Get_NewEnum(); +}; +///////////////////////////////////////////////////////////////////////////// +// ListDataFormat wrapper class + +class ListDataFormat : public COleDispatchDriver +{ +public: + ListDataFormat() {} // Calls COleDispatchDriver default constructor + ListDataFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + ListDataFormat(const ListDataFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + long Get_Default(); + VARIANT GetChoices(); + long GetDecimalPlaces(); + VARIANT GetDefaultValue(); + BOOL GetIsPercent(); + long GetLcid(); + long GetMaxCharacters(); + VARIANT GetMaxNumber(); + VARIANT GetMinNumber(); + BOOL GetRequired(); + long GetType(); + BOOL GetReadOnly(); + BOOL GetAllowFillIn(); +}; +///////////////////////////////////////////////////////////////////////////// +// XPath wrapper class + +class XPath : public COleDispatchDriver +{ +public: + XPath() {} // Calls COleDispatchDriver default constructor + XPath(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} + XPath(const XPath& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} + +// Attributes +public: + +// Operations +public: + LPDISPATCH GetApplication(); + long GetCreator(); + LPDISPATCH GetParent(); + CString Get_Default(); + CString GetValue(); + LPDISPATCH GetMap(); + void SetValue(LPDISPATCH Map, LPCTSTR XPath, const VARIANT& SelectionNamespace, const VARIANT& Repeating); + void Clear(); + BOOL GetRepeating(); +}; + + +//´ +#endif \ No newline at end of file diff --git a/LaipuDrawing/hlp/HTMLDefines.h b/LaipuDrawing/hlp/HTMLDefines.h new file mode 100644 index 0000000..0d89863 --- /dev/null +++ b/LaipuDrawing/hlp/HTMLDefines.h @@ -0,0 +1,536 @@ + +// (ID_* IDM_*) +#define HID_WAFER_1 0x10004 +#define HID_WAFER_2 0x10005 +#define HID_OPEN_CUT_FILE2 0x10005 +#define HID_STATUSBAR_PANE1 0x10078 +#define HID_STATUSBAR_PANE2 0x10079 +#define HID_VIEW_CUSTOMIZE 0x1007E +#define HID_WINDOW_MANAGER 0x10083 +#define HID_VIEW_OUTPUTWND 0x10084 +#define HID_VIEW_PROPERTIESWND 0x10085 +#define HID_SORTPROPERTIES 0x10086 +#define HID_PROPERTIES1 0x10087 +#define HID_PROPERTIES2 0x10088 +#define HID_EXPAND_ALL 0x10089 +#define HID_VIEW_NAVIGATION 0x10093 +#define HID_SET_STYLE 0x1009B +#define HID_VIEW_APPLOOK_WIN_2000 0x1009C +#define HID_VIEW_APPLOOK_OFF_XP 0x1009D +#define HID_VIEW_APPLOOK_WIN_XP 0x1009E +#define HID_VIEW_APPLOOK_OFF_2003 0x1009F +#define HID_VIEW_APPLOOK_VS_2005 0x100A0 +#define HID_VIEW_APPLOOK_VS_2008 0x100A1 +#define HID_VIEW_APPLOOK_OFF_2007_BLUE 0x100A2 +#define HID_VIEW_APPLOOK_OFF_2007_BLACK 0x100A3 +#define HID_VIEW_APPLOOK_OFF_2007_SILVER 0x100A4 +#define HID_VIEW_APPLOOK_OFF_2007_AQUA 0x100A5 +#define HID_VIEW_APPLOOK_WINDOWS_7 0x100A6 +#define HID_TOOLS_OPTIONS 0x100A7 +#define HID_VIEW_CAPTION_BAR 0x100A8 +#define HID_OPEN_OBJ_BTN 0x10534 +#define HID_SAVE_OBJ_BTN 0x10535 +#define HID_OPEN_TXT_BTN 0x10536 +#define HID_EXT_PAR_CSV_BTN 0x10537 +#define HID_SAVE_TXT_BTN 0x10537 +#define HID_PCS_MAP_1 0x10585 +#define HID_PCS_MAP_2 0x10588 +#define HID_PCS_MAP_3 0x10589 +#define HID_PCS_MAP_4 0x1058A +#define HID_PCS_MAP_5 0x1058B +#define HID_PCS_MAP_6 0x1058C +#define HID_PCS_MAP_7 0x1058D +#define HID_ROBOT_CTRL_BTN 0x1058E +#define HID_PORT1_MAPPING_BTN 0x105C5 +#define HID_PORT1_UNLOAD_BTN 0x105C6 +#define HID_PORT2_MAPPING_BTN 0x105C7 +#define HID_PORT2_UNLOAD_BTN 0x105C8 +#define HID_ADD_JOB_BTN 0x105C9 +#define HID_CANCEL_JOB_BTN 0x105CA +#define HID_START_QUEUE_BTN 0x105D5 +#define HID_STOP_JOB_BTN 0x105D6 +#define HID_PLATE_LOAD_BTN 0x105D7 +#define HID_ARM_UNLOAD_BTN 0x105D8 +#define HID_ADJUST_UNLOAD_BTN 0x105D9 +#define HID_PLATE_UNLOAD_BTN 0x105DF +#define HID_PAUSE_JOB_BTN 0x105E3 +#define HID_RECOVER_ALL_WAFER_BTN 0x105E6 +#define HID_PORT1_COMMIT_BTN 0x105F2 +#define HID_PORT2_COMMIT_BTN 0x105F3 +#define HID_PROCESS_RECIPE_BTN 0x105FC +#define HID_PROCESS_STEP_BTN 0x105FD +#define HID_ALIGNER_VAC_OFF_BTN2 0x10673 +#define HID_PROPERTY_COMB 0x18002 +#define HID_MOUSE_POINT 0x18003 +#define HID_MOUSE_RECT 0x18004 +#define HID_MOUSE_LINE 0x18005 +#define HID_BUTTON32774 0x18006 +#define HID_SLE_ALL 0x18007 +#define HID_REV_SEL_OBJ 0x18008 +#define HID_DEL_SEL_OBJ 0x18009 +#define HID_ZOOM_IN 0x1800B +#define HID_ZOOM_OUT 0x1800C +#define HID_UNDO 0x1800D +#define HID_REDO 0x1800E +#define HID_MOUSE_CIRLE 0x1800F +#define HID_ 0x18010 +#define HID_MOUSE_ARC 0x18010 +#define HID_MORROR_H 0x18011 +#define HID_MIRROR_V 0x18012 +#define HID_ROTATO 0x18013 +#define HID_DIS_MEASURE 0x18014 +#define HID_MOUSE_CIRCLE 0x18015 +#define HID_MOVE_TO_CENTER 0x18016 +#define HID_CUT 0x18017 +#define HID_EXTEND 0x18018 +#define HID_BREAK 0x18019 +#define HID_CHAMFER 0x1801A +#define HID_FILLET 0x1801B +#define HID_EXPLODE 0x1801C +#define HID_ARRAY 0x1801D +#define HID_TXT 0x1801E +#define HID_DELETE 0x18021 +#define HID_MIRROR_H 0x18022 +#define HID_ROTATO_90_L 0x18023 +#define HID_ROTATO_90_R 0x18024 +#define HID_JOIN 0x18025 +#define HID_BREAK_AT_POINT 0x18026 +#define HID_SEL_VIEW 0x18028 +#define HID_WORK_SPACE_VIEW 0x18029 +#define HID_MOVE 0x1802A +#define HID_COPY 0x1802B +#define HID_POLYGON 0x1802C +#define HID_CONSTRUCT_LIN 0x1802D +#define HID_PLINE 0x1802E +#define HID_XLINE 0x1802F +#define HID_ELLIPSE 0x18030 +#define HID_ELLIPSE_ARC 0x18031 +#define HID_TOOL_POINT 0x18032 +#define HID_REVERSE 0x18033 +#define HID_ADD_NODE 0x18034 +#define HID_BUTTON32821 0x18035 +#define HID_DEL_NODE 0x18035 +#define HID_MOUSE_TXT 0x18036 +#define HID_Menu 0x18037 +#define HID_MENU_PLT 0x18038 +#define HID_32825 0x18039 +#define HID_OPEN_PLT 0x1803A +#define HID_32827 0x1803B +#define HID_32828 0x1803C +#define HID_WRITE_DEVICE_PAR 0x1803D +#define HID_EXPORT_DEVICE_PAR 0x1803E +#define HID_Menu32831 0x1803F +#define HID_PLATFORM_CTRL 0x18040 +#define HID_32833 0x18041 +#define HID_DEVICE_TEST 0x18042 +#define HID_Menu32835 0x18043 +#define HID_32836 0x18044 +#define HID_AREA_COMPENSET 0x18045 +#define HID_AREA_COMPENSATE 0x18046 +#define HID_OUTPUT_CMD 0x18047 +#define HID_OUTPUT_LOG 0x18048 +#define HID_PANE_DRAW_PROP 0x18049 +#define HID_PANE_DEVICE_PROP 0x1804A +#define HID_FILL 0x1804B +#define HID_BARCODE 0x1804C +#define HID_FILE_SAVE1 0x1804D +#define HID_FILE_OPEN1 0x1804E +#define HID_32847 0x1804F +#define HID_AUTHORITY 0x18050 +#define HID_32849 0x18051 +#define HID_OBJ_COMPONENT 0x18052 +#define HID_32851 0x18053 +#define HID_32852 0x18054 +#define HID_MARK_AREA 0x18055 +#define HID_OPEN_FILE 0x18056 +#define HID_SAVE_FILE_AS 0x18057 +#define HID_SAVE_FILE 0x18058 +#define HID_SET_POINT 0x18059 +#define HID_SET_MARK 0x1805A +#define HID_PT_MOVE_TO_CCD 0x1805B +#define HID_Menu32860 0x1805C +#define HID_CTRL_DLG 0x1805D +#define HID_32862 0x1805E +#define HID_USER_MGR 0x1805F +#define HID_DEVICE_PAR 0x18060 +#define HID_32865 0x18061 +#define HID_TH_TEST_DLG 0x18062 +#define HID_32867 0x18063 +#define HID_OPEN_DXF 0x18064 +#define HID_OPEN_DXF_FILE 0x18066 +#define HID_OBJ_FILL 0x18068 +#define HID_LASER_COORD 0x18069 +#define HID_32874 0x1806A +#define HID_OPEN_ATTE_APP 0x1806B +#define HID_32876 0x1806C +#define HID_LASER_MODE_TEST 0x1806D +#define HID_PANE_PAR_SET_PROP 0x1806E +#define HID_32878 0x1806E +#define HID_MEASURE_PAR_SET 0x1806F + +// ʾ(IDP_*) +#define HIDP_OLE_INIT_FAILED 0x30064 +#define HIDP_SOCKETS_INIT_FAILED 0x30068 + +// Դ(IDR_*) +#define HIDR_HELP_MENU 0x20076 +#define HIDR_POPUP_EDIT 0x20077 +#define HIDR_MAINFRAME 0x2007F +#define HIDR_MAINFRAME_256 0x20080 +#define HIDR_LaiPuLaserTYPE 0x20081 +#define HIDR_LAIPU_LASER_MENU 0x20082 +#define HIDR_OUTPUT_POPUP 0x20090 +#define HIDR_PROPERTIES 0x20091 +#define HIDR_THEME_MENU 0x2009A + +// Ի(IDD_*) +#define HIDD_ABOUTBOX 0x20064 +#define HIDD_ARRAY_DLG 0x200C7 +#define HIDD_BYD_CTRL_DLG 0x200D0 +#define HIDD_AUTHORITY_MGR 0x20142 +#define HIDD_AUTHORITY_LOGIN 0x20142 +#define HIDD_CREAT_ACCOUNT 0x20143 +#define HIDD_MARK_PAR 0x20146 +#define HIDD_DEVICE_STATE_2 0x20147 +#define HIDD_GRAPHICS_EDIT 0x20147 +#define HIDD_USER_MGR 0x2014C +#define HIDD_AUTHORITY_ACCOUNT 0x2014C +#define HIDD_IS3000_INFO_DLG 0x20159 +#define HIDD_IS3000_SLOT_DLG 0x2015A +#define HIDD_CREAT_ACCOUNT2 0x2015B +#define HIDD_AUTHORITY_CREAT_ACCOUNT 0x2015B +#define HIDD_ARRAY_DLG1 0x2015E +#define HIDD_WORK_RECORD_DLG 0x20162 +#define HIDD_PEN_PAR_LIST_DLG 0x20163 +#define HIDD_ARRAY_DLG2 0x20165 +#define HIDD_DEVICE_STATE_LIST_DLG 0x20165 +#define HIDD_IO_STATE_DLG 0x20165 +#define HIDD_LASER_STATE_DLG 0x2016A +#define HIDD_LASER_STATE_DLG_PI 0x2016A +#define HIDD_SET_LASER_PAR_DLG 0x2016D +#define HIDD_TIMING_PROGRESS_DLG 0x2016D +#define HIDD_SET_PASER_PAR_DLG 0x20170 +#define HIDD_WARNING_STATE_LIST_DLG 0x20171 +#define HIDD_LASER_POW_CHECK_DLG 0x20172 +#define HIDD_SET_RED_LASER_PAR_808_DLG 0x20175 +#define HIDD_POW_CHECK_PAR_DLG 0x20179 +#define HIDD_DEVICE_MAIN_DLG 0x2017E +#define HIDD_CHILD_DEVICE_STATE 0x2017F +#define HIDD_CHILD_RECORD 0x20180 +#define HIDD_CHILD_WAFER_HISTORY 0x20180 +#define HIDD_CHILD_RECIPE 0x20184 +#define HIDD_ADD_JOB_DLG 0x20185 +#define HIDD_PP_SELECT_COMMIT_DLG 0x20188 +#define HIDD_AUTHORITY_PAR_DLG 0x20191 +#define HIDD_JOB_WAFER_RECIPE_DLG 0x20193 +#define HIDD_RECIPE_CTRL_DLG 0x20195 +#define HIDD_CHILD_EVENT_LOG 0x201A2 +#define HIDD_CHILD_DATA_ANALYSIS 0x201A3 +#define HIDD_LAYER_VIEW_SHOW_DLG 0x201A7 +#define HIDD_CHILD_RECIPE_COMPARE 0x201A8 +#define HIDD_CHILD_ALARM_LOG 0x201A9 +#define HIDD_CHILD_WAFER_HISTORY1 0x201AA +#define HIDD_CHILD_CHECK_HISTORY 0x201AA +#define HIDD_CHILD_REAL_TIME_HISTORY 0x201AC +#define HIDD_CHILD_BEAM_HISTORY 0x201AD +#define HIDD_CHILD_BEAM_HISTORY1 0x201AE +#define HIDD_CHILD_OSCILL_HISTORY 0x201AE +#define HIDD_CHILD_CONFIG_HISTORY 0x201AE +#define HIDD_CHILD_PAR_HISTORY1 0x201AF +#define HIDD_CHILD_RCP_PAR_HISTORY 0x201B1 +#define HIDD_CHILD_USER_HISTORY 0x201B2 +#define HIDD_MAP_HISTORY_DLG 0x201B3 +#define HIDD_OFFSET_TABLE_DLG 0x201B4 +#define HIDD_OFFSET_TAB_CREATE_DLG 0x201B5 +#define HIDD_CHILD_JOB_HISTORY 0x201B6 +#define HIDD_SHIMBLE_BTN 0x20533 +#define HIDD_THIMBLE_BTN 0x20533 +#define HIDD_PLAT_VACUUM_PO_BTN 0x20534 +#define HIDD_PLAT_VACUUM_BTN 0x20535 +#define HIDD_PLAT_VACUUM_BTN2 0x20540 +#define HIDD_OPEN_TMP_CCD_BTN 0x20540 +#define HIDD_MARK_TEST_BTN 0x20542 +#define HIDD_MARK_TEST_BTN2 0x20543 +#define HIDD_CLOSE_TMP_CCD_BTN 0x20544 +#define HIDD_ONLINE_BTN 0x205C3 +#define HIDD_NEW_SLE_ALL_SLOT 0x205C8 +#define HIDD_NEW_NOT_SLE_ALL_SLOT 0x205C9 +#define HIDD_NEW_SLE_RCP_TO_ALL_SLOT 0x205CB +#define HIDD_NEW_SLE_RCP_TO_ONE_SLOT 0x205CC +#define HIDD_ARM_AUTO_BTN 0x205D4 +#define HIDD_RESET_RECIPE_BTN 0x205EC +#define HIDD_ONLINE_BTN2 0x205F0 +#define HIDD_SECS_ONLINE_BTN 0x205F0 +#define HIDD_SECS_ONLINE_BTN2 0x205F7 +#define HIDD_LOCK_RECIPE_BTN 0x205F7 +#define HIDD_CYCLIC_RUN_BTN 0x205F7 +#define HIDD_RUN_TIME_ZERO_BTN 0x205FA +#define HIDD_DOOR_CTRL_BTN 0x205FB +#define HIDD_LASER_SPOT_IMAGE_BTN 0x20619 +#define HIDD_RED_LASER_POW_CHECK_BTN 0x20624 +#define HIDD_LASER_FRE2 0x20630 +#define HIDD_LASER_LDD_TIME 0x20630 +#define HIDD_RED_LASER_ENGY_K 0x20638 +#define HIDD_RED_LASER_ENGY_PO 0x20639 +#define HIDD_PORT_LIST 0x2067C + +// ܿؼ(IDW_*) +// This is a part of the Microsoft Foundation Classes C++ library. +// Copyright (C) Microsoft Corporation +// All rights reserved. +// +// This source code is only intended as a supplement to the +// Microsoft Foundation Classes Reference and related +// electronic documentation provided with the library. +// See these sources for detailed information regarding the +// Microsoft Foundation Classes product. + +#ifndef __AFX_HH_H__ +#define __AFX_HH_H__ + +#pragma once + +#ifdef _AFX_MINREBUILD +#pragma component(minrebuild, off) +#endif + +// Non-Client HitTest help IDs +#define HID_HT_NOWHERE 0x40000 +#define HID_HT_CAPTION 0x40002 +#define HID_HT_HSCROLL 0x40006 +#define HID_HT_VSCROLL 0x40007 +#define HID_HT_MINBUTTON 0x40008 +#define HID_HT_MAXBUTTON 0x40009 +#define HID_HT_SIZE 0x40012 // alias: ID_HT_BORDER +#define HID_HT_OBJECT 0x40013 +#define HID_HT_CLOSE 0x40014 +#define HID_HT_HELP 0x40015 + +// WM_SYSCOMMAND help IDs +#define HID_SC_SIZE 0x1EF00 +#define HID_SC_MOVE 0x1EF01 +#define HID_SC_MINIMIZE 0x1EF02 +#define HID_SC_MAXIMIZE 0x1EF03 +#define HID_SC_NEXTWINDOW 0x1EF04 +#define HID_SC_PREVWINDOW 0x1EF05 +#define HID_SC_CLOSE 0x1EF06 +#define HID_SC_RESTORE 0x1EF12 +#define HID_SC_TASKLIST 0x1EF13 + +// File MRU and aliases +#define HID_FILE_MRU_FILE1 0x1E11F + +// Window menu list +#define HID_WINDOW_ALL 0x1EF1F + +// OLE menu and aliases +#define HID_OLE_VERB_1 0x1E21F + +// Commands (HID_*) +#define HID_FILE_NEW 0x1E100 +#define HID_FILE_OPEN 0x1E101 +#define HID_FILE_CLOSE 0x1E102 +#define HID_FILE_SAVE 0x1E103 +#define HID_FILE_SAVE_AS 0x1E104 +#define HID_FILE_PAGE_SETUP 0x1E105 +#define HID_FILE_PRINT_SETUP 0x1E106 +#define HID_FILE_PRINT 0x1E107 +#define HID_FILE_PRINT_DIRECT 0x1E108 +#define HID_FILE_PRINT_PREVIEW 0x1E109 +#define HID_FILE_UPDATE 0x1E10A +#define HID_FILE_SAVE_COPY_AS 0x1E10B +#define HID_FILE_SEND_MAIL 0x1E10C +#define HID_EDIT_CLEAR 0x1E120 +#define HID_EDIT_CLEAR_ALL 0x1E121 +#define HID_EDIT_COPY 0x1E122 +#define HID_EDIT_CUT 0x1E123 +#define HID_EDIT_FIND 0x1E124 +#define HID_EDIT_PASTE 0x1E125 +#define HID_EDIT_PASTE_LINK 0x1E126 +#define HID_EDIT_PASTE_SPECIAL 0x1E127 +#define HID_EDIT_REPEAT 0x1E128 +#define HID_EDIT_REPLACE 0x1E129 +#define HID_EDIT_SELECT_ALL 0x1E12A +#define HID_EDIT_UNDO 0x1E12B +#define HID_EDIT_REDO 0x1E12C +#define HID_WINDOW_NEW 0x1E130 +#define HID_WINDOW_ARRANGE 0x1E131 +#define HID_WINDOW_CASCADE 0x1E132 +#define HID_WINDOW_TILE_HORZ 0x1E133 +#define HID_WINDOW_TILE_VERT 0x1E134 +#define HID_WINDOW_SPLIT 0x1E135 +#define HID_APP_ABOUT 0x1E140 +#define HID_APP_EXIT 0x1E141 +#define HID_HELP_INDEX 0x1E142 +#define HID_HELP_FINDER 0x1E143 +#define HID_HELP_USING 0x1E144 +#define HID_CONTEXT_HELP 0x1E145 +#define HID_NEXT_PANE 0x1E150 +#define HID_PREV_PANE 0x1E151 +#define HID_FORMAT_FONT 0x1E160 +#define HID_OLE_INSERT_NEW 0x1E200 +#define HID_OLE_EDIT_LINKS 0x1E201 +#define HID_OLE_EDIT_CONVERT 0x1E202 +#define HID_OLE_EDIT_CHANGE_ICON 0x1E203 +#define HID_OLE_EDIT_PROPERTIES 0x1E204 +#define HID_VIEW_TOOLBAR 0x1E800 +#define HID_VIEW_STATUS_BAR 0x1E801 +#define HID_RECORD_FIRST 0x1E900 +#define HID_RECORD_LAST 0x1E901 +#define HID_RECORD_NEXT 0x1E902 +#define HID_RECORD_PREV 0x1E903 +#define HID_WIZBACK 0x13023 +#define HID_WIZNEXT 0x13024 +#define HID_WIZFINISH 0x13025 + +// Dialogs (AFX_HIDD_*) +#define AFX_HIDD_FILEOPEN 0x27004 +#define AFX_HIDD_FILESAVE 0x27005 +#define AFX_HIDD_FONT 0x27006 +#define AFX_HIDD_COLOR 0x27007 +#define AFX_HIDD_PRINT 0x27008 +#define AFX_HIDD_PRINTSETUP 0x27009 +#define AFX_HIDD_FIND 0x2700A +#define AFX_HIDD_REPLACE 0x2700B +#define AFX_HIDD_NEWTYPEDLG 0x27801 +#define AFX_HIDD_PRINTDLG 0x27802 +#define AFX_HIDD_PREVIEW_TOOLBAR 0x27803 +#define AFX_HIDD_PREVIEW_SHORTTOOLBAR 0x2780B +#define AFX_HIDD_INSERTOBJECT 0x27804 +#define AFX_HIDD_CHANGEICON 0x27805 +#define AFX_HIDD_CONVERT 0x27806 +#define AFX_HIDD_PASTESPECIAL 0x27807 +#define AFX_HIDD_EDITLINKS 0x27808 +#define AFX_HIDD_FILEBROWSE 0x27809 +#define AFX_HIDD_BUSY 0x2780A +#define AFX_HIDD_OBJECTPROPERTIES 0x2780C +#define AFX_HIDD_CHANGESOURCE 0x2780D + +// Prompts/Errors (AFX_HIDP_*) +#define AFX_HIDP_NO_ERROR_AVAILABLE 0x3F020 +#define AFX_HIDP_INVALID_FILENAME 0x3F100 +#define AFX_HIDP_FAILED_TO_OPEN_DOC 0x3F101 +#define AFX_HIDP_FAILED_TO_SAVE_DOC 0x3F102 +#define AFX_HIDP_ASK_TO_SAVE 0x3F103 +#define AFX_HIDP_FAILED_TO_CREATE_DOC 0x3F104 +#define AFX_HIDP_FILE_TOO_LARGE 0x3F105 +#define AFX_HIDP_FAILED_TO_START_PRINT 0x3F106 +#define AFX_HIDP_FAILED_TO_LAUNCH_HELP 0x3F107 +#define AFX_HIDP_INTERNAL_FAILURE 0x3F108 +#define AFX_HIDP_COMMAND_FAILURE 0x3F109 +#define AFX_HIDP_FAILED_MEMORY_ALLOC 0x3F10A +#define AFX_HIDP_UNREG_DONE 0x3F10B +#define AFX_HIDP_UNREG_FAILURE 0x3F10C +#define AFX_HIDP_DLL_LOAD_FAILED 0x3F10D +#define AFX_HIDP_DLL_BAD_VERSION 0x3F10E +#define AFX_HIDP_PARSE_INT 0x3F110 +#define AFX_HIDP_PARSE_REAL 0x3F111 +#define AFX_HIDP_PARSE_INT_RANGE 0x3F112 +#define AFX_HIDP_PARSE_REAL_RANGE 0x3F113 +#define AFX_HIDP_PARSE_STRING_SIZE 0x3F114 +#define AFX_HIDP_PARSE_RADIO_BUTTON 0x3F115 +#define AFX_HIDP_PARSE_BYTE 0x3F116 +#define AFX_HIDP_PARSE_UINT 0x3F117 +#define AFX_HIDP_PARSE_DATETIME 0x3F118 +#define AFX_HIDP_PARSE_CURRENCY 0x3F119 +#define AFX_HIDP_FAILED_INVALID_FORMAT 0x3F120 +#define AFX_HIDP_FAILED_INVALID_PATH 0x3F121 +#define AFX_HIDP_FAILED_DISK_FULL 0x3F122 +#define AFX_HIDP_FAILED_ACCESS_READ 0x3F123 +#define AFX_HIDP_FAILED_ACCESS_WRITE 0x3F124 +#define AFX_HIDP_FAILED_IO_ERROR_READ 0x3F125 +#define AFX_HIDP_FAILED_IO_ERROR_WRITE 0x3F126 +#define AFX_HIDP_STATIC_OBJECT 0x3F180 +#define AFX_HIDP_FAILED_TO_CONNECT 0x3F181 +#define AFX_HIDP_SERVER_BUSY 0x3F182 +#define AFX_HIDP_BAD_VERB 0x3F183 +#define AFX_HIDP_FAILED_TO_NOTIFY 0x3F185 +#define AFX_HIDP_FAILED_TO_LAUNCH 0x3F186 +#define AFX_HIDP_ASK_TO_UPDATE 0x3F187 +#define AFX_HIDP_FAILED_TO_UPDATE 0x3F188 +#define AFX_HIDP_FAILED_TO_REGISTER 0x3F189 +#define AFX_HIDP_FAILED_TO_AUTO_REGISTER 0x3F18A +#define AFX_HIDP_FAILED_TO_CONVERT 0x3F18B +#define AFX_HIDP_GET_NOT_SUPPORTED 0x3F18C +#define AFX_HIDP_SET_NOT_SUPPORTED 0x3F18D +#define AFX_HIDP_ASK_TO_DISCARD 0x3F18E +#define AFX_HIDP_FAILED_TO_CREATE 0x3F18F +#define AFX_HIDP_FAILED_MAPI_LOAD 0x3F190 +#define AFX_HIDP_INVALID_MAPI_DLL 0x3F191 +#define AFX_HIDP_FAILED_MAPI_SEND 0x3F192 +#define AFX_HIDP_FILE_NONE 0x3F1A0 +#define AFX_HIDP_FILE_GENERIC 0x3F1A1 +#define AFX_HIDP_FILE_NOT_FOUND 0x3F1A2 +#define AFX_HIDP_FILE_BAD_PATH 0x3F1A3 +#define AFX_HIDP_FILE_TOO_MANY_OPEN 0x3F1A4 +#define AFX_HIDP_FILE_ACCESS_DENIED 0x3F1A5 +#define AFX_HIDP_FILE_INVALID_FILE 0x3F1A6 +#define AFX_HIDP_FILE_REMOVE_CURRENT 0x3F1A7 +#define AFX_HIDP_FILE_DIR_FULL 0x3F1A8 +#define AFX_HIDP_FILE_BAD_SEEK 0x3F1A9 +#define AFX_HIDP_FILE_HARD_IO 0x3F1AA +#define AFX_HIDP_FILE_SHARING 0x3F1AB +#define AFX_HIDP_FILE_LOCKING 0x3F1AC +#define AFX_HIDP_FILE_DISKFULL 0x3F1AD +#define AFX_HIDP_FILE_EOF 0x3F1AE +#define AFX_HIDP_ARCH_NONE 0x3F1B0 +#define AFX_HIDP_ARCH_GENERIC 0x3F1B1 +#define AFX_HIDP_ARCH_READONLY 0x3F1B2 +#define AFX_HIDP_ARCH_ENDOFFILE 0x3F1B3 +#define AFX_HIDP_ARCH_WRITEONLY 0x3F1B4 +#define AFX_HIDP_ARCH_BADINDEX 0x3F1B5 +#define AFX_HIDP_ARCH_BADCLASS 0x3F1B6 +#define AFX_HIDP_ARCH_BADSCHEMA 0x3F1B7 +#define AFX_HIDP_SQL_CONNECT_FAIL 0x3F281 +#define AFX_HIDP_SQL_RECORDSET_FORWARD_ONLY 0x3F282 +#define AFX_HIDP_SQL_EMPTY_COLUMN_LIST 0x3F283 +#define AFX_HIDP_SQL_FIELD_SCHEMA_MISMATCH 0x3F284 +#define AFX_HIDP_SQL_ILLEGAL_MODE 0x3F285 +#define AFX_HIDP_SQL_MULTIPLE_ROWS_AFFECTED 0x3F286 +#define AFX_HIDP_SQL_NO_CURRENT_RECORD 0x3F287 +#define AFX_HIDP_SQL_NO_ROWS_AFFECTED 0x3F288 +#define AFX_HIDP_SQL_RECORDSET_READONLY 0x3F289 +#define AFX_HIDP_SQL_SQL_NO_TOTAL 0x3F28A +#define AFX_HIDP_SQL_ODBC_LOAD_FAILED 0x3F28B +#define AFX_HIDP_SQL_DYNASET_NOT_SUPPORTED 0x3F28C +#define AFX_HIDP_SQL_SNAPSHOT_NOT_SUPPORTED 0x3F28D +#define AFX_HIDP_SQL_API_CONFORMANCE 0x3F28E +#define AFX_HIDP_SQL_SQL_CONFORMANCE 0x3F28F +#define AFX_HIDP_SQL_NO_DATA_FOUND 0x3F290 +#define AFX_HIDP_SQL_ROW_UPDATE_NOT_SUPPORTED 0x3F291 +#define AFX_HIDP_SQL_ODBC_V2_REQUIRED 0x3F292 +#define AFX_HIDP_SQL_NO_POSITIONED_UPDATES 0x3F293 +#define AFX_HIDP_SQL_LOCK_MODE_NOT_SUPPORTED 0x3F294 +#define AFX_HIDP_SQL_DATA_TRUNCATED 0x3F295 +#define AFX_HIDP_SQL_ROW_FETCH 0x3F296 +#define AFX_HIDP_SQL_INCORRECT_ODBC 0x3F297 +#define AFX_HIDP_SQL_UPDATE_DELETE_FAILED 0x3F298 +#define AFX_HIDP_SQL_DYNAMIC_CURSOR_NOT_SUPPORTED 0x3F299 +#define AFX_HIDP_SQL_FIELD_NOT_FOUND 0x3F29A +#define AFX_HIDP_SQL_BOOKMARKS_NOT_SUPPORTED 0x3F29B +#define AFX_HIDP_SQL_BOOKMARKS_NOT_ENABLED 0x3F29C +#define AFX_HIDP_DAO_ENGINE_INITIALIZATION 0x3F2B0 +#define AFX_HIDP_DAO_DFX_BIND 0x3F2B1 +#define AFX_HIDP_DAO_OBJECT_NOT_OPEN 0x3F2B2 +#define AFX_HIDP_DAO_ROWTOOSHORT 0x3F2B3 +#define AFX_HIDP_DAO_BADBINDINFO 0x3F2B4 +#define AFX_HIDP_DAO_COLUMNUNAVAILABLE 0x3F2B5 + +// Frame Controls (AFX_HIDW_*) +#define AFX_HIDW_TOOLBAR 0x5E800 +#define AFX_HIDW_STATUS_BAR 0x5E801 +#define AFX_HIDW_PREVIEW_BAR 0x5E802 +#define AFX_HIDW_RESIZE_BAR 0x5E803 +#define AFX_HIDW_DOCKBAR_TOP 0x5E81B +#define AFX_HIDW_DOCKBAR_LEFT 0x5E81C +#define AFX_HIDW_DOCKBAR_RIGHT 0x5E81D +#define AFX_HIDW_DOCKBAR_BOTTOM 0x5E81E +#define AFX_HIDW_DOCKBAR_FLOAT 0x5E81F + +///////////////////////////////////////////////////////////////////////////// + +#ifdef _AFX_MINREBUILD +#pragma component(minrebuild, on) +#endif + +#endif // __AFX_HH_H__ diff --git a/LaipuDrawing/hlp/Images/Bullet.gif b/LaipuDrawing/hlp/Images/Bullet.gif new file mode 100644 index 0000000..090f96c Binary files /dev/null and b/LaipuDrawing/hlp/Images/Bullet.gif differ diff --git a/LaipuDrawing/hlp/LaiPuLaser.hhc b/LaipuDrawing/hlp/LaiPuLaser.hhc new file mode 100644 index 0000000..5589537 --- /dev/null +++ b/LaipuDrawing/hlp/LaiPuLaser.hhc @@ -0,0 +1,46 @@ + + + + + + +
    +
  • + + + +
  • + + +
      +
    • + + + +
    • + + + +
    • + + + +
    • + + + +
    • + + + +
    +
  • + + + +
  • + + + +
+ diff --git a/LaipuDrawing/hlp/LaiPuLaser.hhk b/LaipuDrawing/hlp/LaiPuLaser.hhk new file mode 100644 index 0000000..c0ba08a --- /dev/null +++ b/LaipuDrawing/hlp/LaiPuLaser.hhk @@ -0,0 +1,9 @@ + + + + + + +
    +
+ diff --git a/LaipuDrawing/hlp/LaiPuLaser.hhp b/LaipuDrawing/hlp/LaiPuLaser.hhp new file mode 100644 index 0000000..4df1d2e --- /dev/null +++ b/LaipuDrawing/hlp/LaiPuLaser.hhp @@ -0,0 +1,214 @@ +[OPTIONS] +Auto Index=Yes +Compatibility=1.1 or later +Compiled file=LaiPuLaser.chm +Contents file=LaiPuLaser.hhc +Index file=LaiPuLaser.hhk +Default topic=main_index.htm +Display compile progress=No +Full-text search=Yes +Language=0x0804 (壬й) + + +[FILES] +afx_hidd_color.htm +afx_hidd_fileopen.htm +afx_hidd_filesave.htm +afx_hidd_find.htm +afx_hidd_font.htm +afx_hidd_newtypedlg.htm +afx_hidd_replace.htm +afx_hidp_default.htm +afx_hidw_dockbar_top.htm +afx_hidw_status_bar.htm +afx_hidw_toolbar.htm +hidr_doc1type.htm +hid_app_about.htm +hid_app_exit.htm +hid_context_help.htm +hid_edit_clear.htm +hid_edit_clear_all.htm +hid_edit_copy.htm +hid_edit_cut.htm +hid_edit_find.htm +hid_edit_paste.htm +hid_edit_redo.htm +hid_edit_repeat.htm +hid_edit_replace.htm +hid_edit_undo.htm +hid_file_close.htm +hid_file_mru_file1.htm +hid_file_new.htm +hid_file_open.htm +hid_file_save.htm +hid_file_save_as.htm +hid_file_send_mail.htm +hid_help_index.htm +hid_help_using.htm +hid_ht_caption.htm +hid_ht_nowhere.htm +hid_next_pane.htm +hid_prev_pane.htm +hid_sc_close.htm +hid_sc_maximize.htm +hid_sc_minimize.htm +hid_sc_move.htm +hid_sc_nextwindow.htm +hid_sc_prevwindow.htm +hid_sc_restore.htm +hid_sc_size.htm +hid_sc_tasklist.htm +hid_view_ruler.htm +hid_view_status_bar.htm +hid_view_toolbar.htm +hid_window_all.htm +hid_window_arrange.htm +hid_window_cascade.htm +hid_window_new.htm +hid_window_split.htm +hid_window_tile.htm +hid_window_tile_horz.htm +hid_window_tile_vert.htm +main_index.htm +menu_edit.htm +menu_file.htm +menu_help.htm +menu_view.htm +menu_window.htm +scrollbars.htm +afx_hidd_print.htm +afx_hidd_printdlg.htm +afx_hidd_printsetup.htm +afx_hidw_preview_bar.htm +hid_file_page_setup.htm +hid_file_print.htm +hid_file_print_preview.htm +hid_file_print_setup.htm + +[ALIAS] +HIDR_MAINFRAME = main_index.htm +HIDR_LaiPuLaserTYPE = HIDR_DOC1TYPE.htm + +main_index = main_index.htm +afx_hidd_color = afx_hidd_color.htm +afx_hidd_fileopen = afx_hidd_fileopen.htm +afx_hidd_filesave = afx_hidd_filesave.htm +afx_hidd_find = afx_hidd_find.htm +afx_hidd_font = afx_hidd_font.htm +afx_hidd_newtypedlg = afx_hidd_newtypedlg.htm +afx_hidd_replace = afx_hidd_replace.htm +AFX_HIDP_DEFAULT = AFX_HIDP_DEFAULT.htm +afx_hidw_dockbar_top = afx_hidw_dockbar_top.htm +afx_hidw_status_bar = afx_hidw_status_bar.htm +afx_hidw_toolbar = afx_hidw_toolbar.htm +hid_app_about = hid_app_about.htm +hid_app_exit = hid_app_exit.htm +hid_context_help = hid_context_help.htm +hid_edit_clear = hid_edit_clear.htm +hid_edit_clear_all = hid_edit_clear_all.htm +hid_edit_copy = hid_edit_copy.htm +hid_edit_cut = hid_edit_cut.htm +hid_edit_find = hid_edit_find.htm +hid_edit_paste = hid_edit_paste.htm +hid_edit_redo = hid_edit_redo.htm +hid_edit_repeat = hid_edit_repeat.htm +hid_edit_replace = hid_edit_replace.htm +hid_edit_undo = hid_edit_undo.htm +hid_file_close = hid_file_close.htm +hid_file_mru_file1 = hid_file_mru_file1.htm +hid_file_new = hid_file_new.htm +hid_file_open = hid_file_open.htm +hid_file_save = hid_file_save.htm +hid_file_save_as = hid_file_save_as.htm +hid_file_send_mail = hid_file_send_mail.htm +hid_help_index = hid_help_index.htm +hid_help_using = hid_help_using.htm +hid_ht_caption = hid_ht_caption.htm +hid_ht_nowhere = hid_ht_nowhere.htm +hid_next_pane = hid_next_pane.htm +hid_prev_pane = hid_prev_pane.htm +hid_sc_close = hid_sc_close.htm +hid_sc_maximize = hid_sc_maximize.htm +hid_sc_minimize = hid_sc_minimize.htm +hid_sc_move = hid_sc_move.htm +hid_sc_nextwindow = hid_sc_nextwindow.htm +hid_sc_prevwindow = hid_sc_prevwindow.htm +hid_sc_restore = hid_sc_restore.htm +hid_sc_size = hid_sc_size.htm +hid_sc_tasklist = hid_sc_tasklist.htm +hid_view_ruler = hid_view_ruler.htm +hid_view_status_bar = hid_view_status_bar.htm +hid_view_toolbar = hid_view_toolbar.htm +hid_window_all = hid_window_all.htm +hid_window_arrange = hid_window_arrange.htm +hid_window_cascade = hid_window_cascade.htm +hid_window_new = hid_window_new.htm +hid_window_split = hid_window_split.htm +hid_window_tile = hid_window_tile.htm +hid_window_tile_horz = hid_window_tile_horz.htm +hid_window_tile_vert = hid_window_tile_vert.htm +hidr_doc1type = hidr_doc1type.htm +menu_edit = menu_edit.htm +menu_file = menu_file.htm +menu_help = menu_help.htm +menu_view = menu_view.htm +menu_window = menu_window.htm +scrollbars = scrollbars.htm +afx_hidd_print = afx_hidd_print.htm +afx_hidd_printdlg = afx_hidd_printdlg.htm +afx_hidd_printsetup = afx_hidd_printsetup.htm +afx_hidw_preview_bar = afx_hidw_preview_bar.htm +hid_file_page_setup = hid_file_page_setup.htm +hid_file_print = hid_file_print.htm +hid_file_print_preview = hid_file_print_preview.htm +hid_file_print_setup = hid_file_print_setup.htm +HIDD_ABOUTBOX = HID_APP_ABOUT.htm +HID_HT_SIZE = HID_SC_SIZE.htm +HID_HT_HSCROLL = scrollbars.htm +HID_HT_VSCROLL = scrollbars.htm +HID_HT_MINBUTTON = HID_SC_MINIMIZE.htm +HID_HT_MAXBUTTON = HID_SC_MAXIMIZE.htm +AFX_HIDP_INVALID_FILENAME = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_OPEN_DOC = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_SAVE_DOC = AFX_HIDP_DEFAULT.htm +AFX_HIDP_ASK_TO_SAVE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_CREATE_DOC = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FILE_TOO_LARGE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_START_PRINT = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_LAUNCH_HELP = AFX_HIDP_DEFAULT.htm +AFX_HIDP_INTERNAL_FAILURE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_COMMAND_FAILURE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_PARSE_INT = AFX_HIDP_DEFAULT.htm +AFX_HIDP_PARSE_REAL = AFX_HIDP_DEFAULT.htm +AFX_HIDP_PARSE_INT_RANGE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_PARSE_REAL_RANGE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_PARSE_STRING_SIZE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_INVALID_FORMAT = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_INVALID_PATH = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_DISK_FULL = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_ACCESS_READ = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_ACCESS_WRITE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_IO_ERROR_READ = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_IO_ERROR_WRITE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_STATIC_OBJECT = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_CONNECT = AFX_HIDP_DEFAULT.htm +AFX_HIDP_SERVER_BUSY = AFX_HIDP_DEFAULT.htm +AFX_HIDP_BAD_VERB = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_MEMORY_ALLOC = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_NOTIFY = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_LAUNCH = AFX_HIDP_DEFAULT.htm +AFX_HIDP_ASK_TO_UPDATE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_UPDATE = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_REGISTER = AFX_HIDP_DEFAULT.htm +AFX_HIDP_FAILED_TO_AUTO_REGISTER = AFX_HIDP_DEFAULT.htm +AFX_HIDW_DOCKBAR_BOTTOM = AFX_HIDW_DOCKBAR_TOP.HTM ; Same topic, 4 different possible hit tests +AFX_HIDW_DOCKBAR_LEFT = AFX_HIDW_DOCKBAR_TOP.HTM ; Same topic, 4 different possible hit tests +AFX_HIDW_DOCKBAR_RIGHT = AFX_HIDW_DOCKBAR_TOP.HTM ; Same topic, 4 different possible hit tests + +[MAP] +#include HTMLDefines.h + +[TEXT POPUPS] +HTMLDefines.h + +[INFOTYPES] diff --git a/LaipuDrawing/lib/Mfc_dll/mfc100d.dll b/LaipuDrawing/lib/Mfc_dll/mfc100d.dll new file mode 100644 index 0000000..3e66b2f Binary files /dev/null and b/LaipuDrawing/lib/Mfc_dll/mfc100d.dll differ diff --git a/LaipuDrawing/lib/Mfc_dll/msvcp100d.dll b/LaipuDrawing/lib/Mfc_dll/msvcp100d.dll new file mode 100644 index 0000000..3251ecc Binary files /dev/null and b/LaipuDrawing/lib/Mfc_dll/msvcp100d.dll differ diff --git a/LaipuDrawing/lib/Mfc_dll/msvcr100d.dll b/LaipuDrawing/lib/Mfc_dll/msvcr100d.dll new file mode 100644 index 0000000..395da79 Binary files /dev/null and b/LaipuDrawing/lib/Mfc_dll/msvcr100d.dll differ diff --git a/LaipuDrawing/res/BtnImg1.bmp b/LaipuDrawing/res/BtnImg1.bmp new file mode 100644 index 0000000..6611318 Binary files /dev/null and b/LaipuDrawing/res/BtnImg1.bmp differ diff --git a/LaipuDrawing/res/BtnImg10.bmp b/LaipuDrawing/res/BtnImg10.bmp new file mode 100644 index 0000000..ebab88f Binary files /dev/null and b/LaipuDrawing/res/BtnImg10.bmp differ diff --git a/LaipuDrawing/res/BtnImg11.bmp b/LaipuDrawing/res/BtnImg11.bmp new file mode 100644 index 0000000..33a804c Binary files /dev/null and b/LaipuDrawing/res/BtnImg11.bmp differ diff --git a/LaipuDrawing/res/BtnImg12.bmp b/LaipuDrawing/res/BtnImg12.bmp new file mode 100644 index 0000000..a69ad52 Binary files /dev/null and b/LaipuDrawing/res/BtnImg12.bmp differ diff --git a/LaipuDrawing/res/BtnImg13.bmp b/LaipuDrawing/res/BtnImg13.bmp new file mode 100644 index 0000000..0847daa Binary files /dev/null and b/LaipuDrawing/res/BtnImg13.bmp differ diff --git a/LaipuDrawing/res/BtnImg14.bmp b/LaipuDrawing/res/BtnImg14.bmp new file mode 100644 index 0000000..e80a5b9 Binary files /dev/null and b/LaipuDrawing/res/BtnImg14.bmp differ diff --git a/LaipuDrawing/res/BtnImg15.bmp b/LaipuDrawing/res/BtnImg15.bmp new file mode 100644 index 0000000..43311a8 Binary files /dev/null and b/LaipuDrawing/res/BtnImg15.bmp differ diff --git a/LaipuDrawing/res/BtnImg2.bmp b/LaipuDrawing/res/BtnImg2.bmp new file mode 100644 index 0000000..3586728 Binary files /dev/null and b/LaipuDrawing/res/BtnImg2.bmp differ diff --git a/LaipuDrawing/res/BtnImg3.bmp b/LaipuDrawing/res/BtnImg3.bmp new file mode 100644 index 0000000..47bee0d Binary files /dev/null and b/LaipuDrawing/res/BtnImg3.bmp differ diff --git a/LaipuDrawing/res/BtnImg4.bmp b/LaipuDrawing/res/BtnImg4.bmp new file mode 100644 index 0000000..3e68e1c Binary files /dev/null and b/LaipuDrawing/res/BtnImg4.bmp differ diff --git a/LaipuDrawing/res/BtnImg5.bmp b/LaipuDrawing/res/BtnImg5.bmp new file mode 100644 index 0000000..43311a8 Binary files /dev/null and b/LaipuDrawing/res/BtnImg5.bmp differ diff --git a/LaipuDrawing/res/CheckLaser.bmp b/LaipuDrawing/res/CheckLaser.bmp new file mode 100644 index 0000000..ceeb518 Binary files /dev/null and b/LaipuDrawing/res/CheckLaser.bmp differ diff --git a/LaipuDrawing/res/CheckLaserDown.bmp b/LaipuDrawing/res/CheckLaserDown.bmp new file mode 100644 index 0000000..8e7411a Binary files /dev/null and b/LaipuDrawing/res/CheckLaserDown.bmp differ diff --git a/LaipuDrawing/res/Down_Botton.bmp b/LaipuDrawing/res/Down_Botton.bmp new file mode 100644 index 0000000..d9b0465 Binary files /dev/null and b/LaipuDrawing/res/Down_Botton.bmp differ diff --git a/LaipuDrawing/res/Down_BottonDown.bmp b/LaipuDrawing/res/Down_BottonDown.bmp new file mode 100644 index 0000000..ef6e029 Binary files /dev/null and b/LaipuDrawing/res/Down_BottonDown.bmp differ diff --git a/LaipuDrawing/res/IniDevice.bmp b/LaipuDrawing/res/IniDevice.bmp new file mode 100644 index 0000000..168af8c Binary files /dev/null and b/LaipuDrawing/res/IniDevice.bmp differ diff --git a/LaipuDrawing/res/IniDeviceDown.bmp b/LaipuDrawing/res/IniDeviceDown.bmp new file mode 100644 index 0000000..6d1d7e8 Binary files /dev/null and b/LaipuDrawing/res/IniDeviceDown.bmp differ diff --git a/LaipuDrawing/res/LaiPuLaser---.ico b/LaipuDrawing/res/LaiPuLaser---.ico new file mode 100644 index 0000000..d56fbcd Binary files /dev/null and b/LaipuDrawing/res/LaiPuLaser---.ico differ diff --git a/LaipuDrawing/res/LaiPuLaser.ico b/LaipuDrawing/res/LaiPuLaser.ico new file mode 100644 index 0000000..07ad7d2 Binary files /dev/null and b/LaipuDrawing/res/LaiPuLaser.ico differ diff --git a/LaipuDrawing/res/LaiPuLaser.rc2 b/LaipuDrawing/res/LaiPuLaser.rc2 new file mode 100644 index 0000000..35ef057 Binary files /dev/null and b/LaipuDrawing/res/LaiPuLaser.rc2 differ diff --git a/LaipuDrawing/res/LaiPuLaserDoc.ico b/LaipuDrawing/res/LaiPuLaserDoc.ico new file mode 100644 index 0000000..96365d4 Binary files /dev/null and b/LaipuDrawing/res/LaiPuLaserDoc.ico differ diff --git a/LaipuDrawing/res/LaiPuLogo1.bmp b/LaipuDrawing/res/LaiPuLogo1.bmp new file mode 100644 index 0000000..cb6aecd Binary files /dev/null and b/LaipuDrawing/res/LaiPuLogo1.bmp differ diff --git a/LaipuDrawing/res/Left_Botton.bmp b/LaipuDrawing/res/Left_Botton.bmp new file mode 100644 index 0000000..ed9b7fa Binary files /dev/null and b/LaipuDrawing/res/Left_Botton.bmp differ diff --git a/LaipuDrawing/res/Left_BottonDown.bmp b/LaipuDrawing/res/Left_BottonDown.bmp new file mode 100644 index 0000000..01c4150 Binary files /dev/null and b/LaipuDrawing/res/Left_BottonDown.bmp differ diff --git a/LaipuDrawing/res/Lock.bmp b/LaipuDrawing/res/Lock.bmp new file mode 100644 index 0000000..d25810f Binary files /dev/null and b/LaipuDrawing/res/Lock.bmp differ diff --git a/LaipuDrawing/res/ModifPar.bmp b/LaipuDrawing/res/ModifPar.bmp new file mode 100644 index 0000000..fc64695 Binary files /dev/null and b/LaipuDrawing/res/ModifPar.bmp differ diff --git a/LaipuDrawing/res/ModifParDown.bmp b/LaipuDrawing/res/ModifParDown.bmp new file mode 100644 index 0000000..c88967b Binary files /dev/null and b/LaipuDrawing/res/ModifParDown.bmp differ diff --git a/LaipuDrawing/res/OpenFile - 副本.bmp b/LaipuDrawing/res/OpenFile - 副本.bmp new file mode 100644 index 0000000..b5003a0 Binary files /dev/null and b/LaipuDrawing/res/OpenFile - 副本.bmp differ diff --git a/LaipuDrawing/res/OpenFile.bmp b/LaipuDrawing/res/OpenFile.bmp new file mode 100644 index 0000000..fa40caa Binary files /dev/null and b/LaipuDrawing/res/OpenFile.bmp differ diff --git a/LaipuDrawing/res/OpenFileDown.bmp b/LaipuDrawing/res/OpenFileDown.bmp new file mode 100644 index 0000000..bdba7ec Binary files /dev/null and b/LaipuDrawing/res/OpenFileDown.bmp differ diff --git a/LaipuDrawing/res/OriginPt - 副本.bmp b/LaipuDrawing/res/OriginPt - 副本.bmp new file mode 100644 index 0000000..cef64cf Binary files /dev/null and b/LaipuDrawing/res/OriginPt - 副本.bmp differ diff --git a/LaipuDrawing/res/OriginPt.bmp b/LaipuDrawing/res/OriginPt.bmp new file mode 100644 index 0000000..98e8b76 Binary files /dev/null and b/LaipuDrawing/res/OriginPt.bmp differ diff --git a/LaipuDrawing/res/OriginPtDown - 副本.bmp b/LaipuDrawing/res/OriginPtDown - 副本.bmp new file mode 100644 index 0000000..273976c Binary files /dev/null and b/LaipuDrawing/res/OriginPtDown - 副本.bmp differ diff --git a/LaipuDrawing/res/OriginPtDown.bmp b/LaipuDrawing/res/OriginPtDown.bmp new file mode 100644 index 0000000..7c2d8e0 Binary files /dev/null and b/LaipuDrawing/res/OriginPtDown.bmp differ diff --git a/LaipuDrawing/res/Point2.cur b/LaipuDrawing/res/Point2.cur new file mode 100644 index 0000000..a1c950f Binary files /dev/null and b/LaipuDrawing/res/Point2.cur differ diff --git a/LaipuDrawing/res/ProductPt.bmp b/LaipuDrawing/res/ProductPt.bmp new file mode 100644 index 0000000..4a00e75 Binary files /dev/null and b/LaipuDrawing/res/ProductPt.bmp differ diff --git a/LaipuDrawing/res/ProductPtDown.bmp b/LaipuDrawing/res/ProductPtDown.bmp new file mode 100644 index 0000000..fb9d49f Binary files /dev/null and b/LaipuDrawing/res/ProductPtDown.bmp differ diff --git a/LaipuDrawing/res/Right_Botton.bmp b/LaipuDrawing/res/Right_Botton.bmp new file mode 100644 index 0000000..6adaa20 Binary files /dev/null and b/LaipuDrawing/res/Right_Botton.bmp differ diff --git a/LaipuDrawing/res/Right_BottonDown.bmp b/LaipuDrawing/res/Right_BottonDown.bmp new file mode 100644 index 0000000..292bda0 Binary files /dev/null and b/LaipuDrawing/res/Right_BottonDown.bmp differ diff --git a/LaipuDrawing/res/SaveFile.bmp b/LaipuDrawing/res/SaveFile.bmp new file mode 100644 index 0000000..b75da47 Binary files /dev/null and b/LaipuDrawing/res/SaveFile.bmp differ diff --git a/LaipuDrawing/res/SaveFileDown.bmp b/LaipuDrawing/res/SaveFileDown.bmp new file mode 100644 index 0000000..2ddaf4b Binary files /dev/null and b/LaipuDrawing/res/SaveFileDown.bmp differ diff --git a/LaipuDrawing/res/Start.bmp b/LaipuDrawing/res/Start.bmp new file mode 100644 index 0000000..379c8f1 Binary files /dev/null and b/LaipuDrawing/res/Start.bmp differ diff --git a/LaipuDrawing/res/Start_Down.bmp b/LaipuDrawing/res/Start_Down.bmp new file mode 100644 index 0000000..e8b119e Binary files /dev/null and b/LaipuDrawing/res/Start_Down.bmp differ diff --git a/LaipuDrawing/res/Stop.bmp b/LaipuDrawing/res/Stop.bmp new file mode 100644 index 0000000..22216bb Binary files /dev/null and b/LaipuDrawing/res/Stop.bmp differ diff --git a/LaipuDrawing/res/Stop_Down.bmp b/LaipuDrawing/res/Stop_Down.bmp new file mode 100644 index 0000000..016998b Binary files /dev/null and b/LaipuDrawing/res/Stop_Down.bmp differ diff --git a/LaipuDrawing/res/SursorMove.cur b/LaipuDrawing/res/SursorMove.cur new file mode 100644 index 0000000..1fe6705 Binary files /dev/null and b/LaipuDrawing/res/SursorMove.cur differ diff --git a/LaipuDrawing/res/Toolbar.bmp b/LaipuDrawing/res/Toolbar.bmp new file mode 100644 index 0000000..0556e00 Binary files /dev/null and b/LaipuDrawing/res/Toolbar.bmp differ diff --git a/LaipuDrawing/res/Toolbar256.bmp b/LaipuDrawing/res/Toolbar256.bmp new file mode 100644 index 0000000..27c6856 Binary files /dev/null and b/LaipuDrawing/res/Toolbar256.bmp differ diff --git a/LaipuDrawing/res/Top_Botton.bmp b/LaipuDrawing/res/Top_Botton.bmp new file mode 100644 index 0000000..ad9d066 Binary files /dev/null and b/LaipuDrawing/res/Top_Botton.bmp differ diff --git a/LaipuDrawing/res/Top_BottonDown.bmp b/LaipuDrawing/res/Top_BottonDown.bmp new file mode 100644 index 0000000..4c3fed8 Binary files /dev/null and b/LaipuDrawing/res/Top_BottonDown.bmp differ diff --git a/LaipuDrawing/res/Vacuum.bmp b/LaipuDrawing/res/Vacuum.bmp new file mode 100644 index 0000000..6a9047d Binary files /dev/null and b/LaipuDrawing/res/Vacuum.bmp differ diff --git a/LaipuDrawing/res/VacuumClose.bmp b/LaipuDrawing/res/VacuumClose.bmp new file mode 100644 index 0000000..cdd1957 Binary files /dev/null and b/LaipuDrawing/res/VacuumClose.bmp differ diff --git a/LaipuDrawing/res/VacuumCloseDown.bmp b/LaipuDrawing/res/VacuumCloseDown.bmp new file mode 100644 index 0000000..8abd200 Binary files /dev/null and b/LaipuDrawing/res/VacuumCloseDown.bmp differ diff --git a/LaipuDrawing/res/VacuumDown.bmp b/LaipuDrawing/res/VacuumDown.bmp new file mode 100644 index 0000000..2fc2557 Binary files /dev/null and b/LaipuDrawing/res/VacuumDown.bmp differ diff --git a/LaipuDrawing/res/aero_arrow.cur b/LaipuDrawing/res/aero_arrow.cur new file mode 100644 index 0000000..d37f2f1 Binary files /dev/null and b/LaipuDrawing/res/aero_arrow.cur differ diff --git a/LaipuDrawing/res/aero_link.cur b/LaipuDrawing/res/aero_link.cur new file mode 100644 index 0000000..ac10a54 Binary files /dev/null and b/LaipuDrawing/res/aero_link.cur differ diff --git a/LaipuDrawing/res/aero_move.cur b/LaipuDrawing/res/aero_move.cur new file mode 100644 index 0000000..98b2a3f Binary files /dev/null and b/LaipuDrawing/res/aero_move.cur differ diff --git a/LaipuDrawing/res/beam_im.cur b/LaipuDrawing/res/beam_im.cur new file mode 100644 index 0000000..9fc62ef Binary files /dev/null and b/LaipuDrawing/res/beam_im.cur differ diff --git a/LaipuDrawing/res/bitmap1.bmp b/LaipuDrawing/res/bitmap1.bmp new file mode 100644 index 0000000..d442868 Binary files /dev/null and b/LaipuDrawing/res/bitmap1.bmp differ diff --git a/LaipuDrawing/res/bitmap6.bmp b/LaipuDrawing/res/bitmap6.bmp new file mode 100644 index 0000000..6e8e840 Binary files /dev/null and b/LaipuDrawing/res/bitmap6.bmp differ diff --git a/LaipuDrawing/res/bmp00001.bmp b/LaipuDrawing/res/bmp00001.bmp new file mode 100644 index 0000000..6a21551 Binary files /dev/null and b/LaipuDrawing/res/bmp00001.bmp differ diff --git a/LaipuDrawing/res/bmp00002.bmp b/LaipuDrawing/res/bmp00002.bmp new file mode 100644 index 0000000..01c7d7f Binary files /dev/null and b/LaipuDrawing/res/bmp00002.bmp differ diff --git a/LaipuDrawing/res/bmp00003.bmp b/LaipuDrawing/res/bmp00003.bmp new file mode 100644 index 0000000..f477206 Binary files /dev/null and b/LaipuDrawing/res/bmp00003.bmp differ diff --git a/LaipuDrawing/res/bmp00004.bmp b/LaipuDrawing/res/bmp00004.bmp new file mode 100644 index 0000000..c5a7b2f Binary files /dev/null and b/LaipuDrawing/res/bmp00004.bmp differ diff --git a/LaipuDrawing/res/bmp00005.bmp b/LaipuDrawing/res/bmp00005.bmp new file mode 100644 index 0000000..296b4f3 Binary files /dev/null and b/LaipuDrawing/res/bmp00005.bmp differ diff --git a/LaipuDrawing/res/bmp00006.bmp b/LaipuDrawing/res/bmp00006.bmp new file mode 100644 index 0000000..6865773 Binary files /dev/null and b/LaipuDrawing/res/bmp00006.bmp differ diff --git a/LaipuDrawing/res/bmp00007.bmp b/LaipuDrawing/res/bmp00007.bmp new file mode 100644 index 0000000..d42f2e7 Binary files /dev/null and b/LaipuDrawing/res/bmp00007.bmp differ diff --git a/LaipuDrawing/res/bmp00008.bmp b/LaipuDrawing/res/bmp00008.bmp new file mode 100644 index 0000000..f90873b Binary files /dev/null and b/LaipuDrawing/res/bmp00008.bmp differ diff --git a/LaipuDrawing/res/bmp00009.bmp b/LaipuDrawing/res/bmp00009.bmp new file mode 100644 index 0000000..2fc38fb Binary files /dev/null and b/LaipuDrawing/res/bmp00009.bmp differ diff --git a/LaipuDrawing/res/bmp00010.bmp b/LaipuDrawing/res/bmp00010.bmp new file mode 100644 index 0000000..4006a76 Binary files /dev/null and b/LaipuDrawing/res/bmp00010.bmp differ diff --git a/LaipuDrawing/res/bmp00011.bmp b/LaipuDrawing/res/bmp00011.bmp new file mode 100644 index 0000000..c104d15 Binary files /dev/null and b/LaipuDrawing/res/bmp00011.bmp differ diff --git a/LaipuDrawing/res/bmp00012.bmp b/LaipuDrawing/res/bmp00012.bmp new file mode 100644 index 0000000..526b323 Binary files /dev/null and b/LaipuDrawing/res/bmp00012.bmp differ diff --git a/LaipuDrawing/res/bmp00013.bmp b/LaipuDrawing/res/bmp00013.bmp new file mode 100644 index 0000000..1ecf986 Binary files /dev/null and b/LaipuDrawing/res/bmp00013.bmp differ diff --git a/LaipuDrawing/res/bmp00014.bmp b/LaipuDrawing/res/bmp00014.bmp new file mode 100644 index 0000000..9c6f1ff Binary files /dev/null and b/LaipuDrawing/res/bmp00014.bmp differ diff --git a/LaipuDrawing/res/bmp00015.bmp b/LaipuDrawing/res/bmp00015.bmp new file mode 100644 index 0000000..61d2492 Binary files /dev/null and b/LaipuDrawing/res/bmp00015.bmp differ diff --git a/LaipuDrawing/res/bmp00016.bmp b/LaipuDrawing/res/bmp00016.bmp new file mode 100644 index 0000000..3c402c5 Binary files /dev/null and b/LaipuDrawing/res/bmp00016.bmp differ diff --git a/LaipuDrawing/res/bmp00017.bmp b/LaipuDrawing/res/bmp00017.bmp new file mode 100644 index 0000000..b071cd6 Binary files /dev/null and b/LaipuDrawing/res/bmp00017.bmp differ diff --git a/LaipuDrawing/res/bmp00018.bmp b/LaipuDrawing/res/bmp00018.bmp new file mode 100644 index 0000000..fc5e11a Binary files /dev/null and b/LaipuDrawing/res/bmp00018.bmp differ diff --git a/LaipuDrawing/res/bmp00019.bmp b/LaipuDrawing/res/bmp00019.bmp new file mode 100644 index 0000000..4ed45a4 Binary files /dev/null and b/LaipuDrawing/res/bmp00019.bmp differ diff --git a/LaipuDrawing/res/bmp00020.bmp b/LaipuDrawing/res/bmp00020.bmp new file mode 100644 index 0000000..016998b Binary files /dev/null and b/LaipuDrawing/res/bmp00020.bmp differ diff --git a/LaipuDrawing/res/bmp00021.bmp b/LaipuDrawing/res/bmp00021.bmp new file mode 100644 index 0000000..30f6a31 Binary files /dev/null and b/LaipuDrawing/res/bmp00021.bmp differ diff --git a/LaipuDrawing/res/bmp00022.bmp b/LaipuDrawing/res/bmp00022.bmp new file mode 100644 index 0000000..b88e12d Binary files /dev/null and b/LaipuDrawing/res/bmp00022.bmp differ diff --git a/LaipuDrawing/res/bmp00023.bmp b/LaipuDrawing/res/bmp00023.bmp new file mode 100644 index 0000000..b673b43 Binary files /dev/null and b/LaipuDrawing/res/bmp00023.bmp differ diff --git a/LaipuDrawing/res/bmp00024.bmp b/LaipuDrawing/res/bmp00024.bmp new file mode 100644 index 0000000..4d5cc37 Binary files /dev/null and b/LaipuDrawing/res/bmp00024.bmp differ diff --git a/LaipuDrawing/res/bmp00025.bmp b/LaipuDrawing/res/bmp00025.bmp new file mode 100644 index 0000000..be3f313 Binary files /dev/null and b/LaipuDrawing/res/bmp00025.bmp differ diff --git a/LaipuDrawing/res/bmp00026.bmp b/LaipuDrawing/res/bmp00026.bmp new file mode 100644 index 0000000..3f5448b Binary files /dev/null and b/LaipuDrawing/res/bmp00026.bmp differ diff --git a/LaipuDrawing/res/bmp00027.bmp b/LaipuDrawing/res/bmp00027.bmp new file mode 100644 index 0000000..16d415a Binary files /dev/null and b/LaipuDrawing/res/bmp00027.bmp differ diff --git a/LaipuDrawing/res/bmp00028.bmp b/LaipuDrawing/res/bmp00028.bmp new file mode 100644 index 0000000..502f0fb Binary files /dev/null and b/LaipuDrawing/res/bmp00028.bmp differ diff --git a/LaipuDrawing/res/bmp00029.bmp b/LaipuDrawing/res/bmp00029.bmp new file mode 100644 index 0000000..3c4dcbd Binary files /dev/null and b/LaipuDrawing/res/bmp00029.bmp differ diff --git a/LaipuDrawing/res/bmp00030.bmp b/LaipuDrawing/res/bmp00030.bmp new file mode 100644 index 0000000..78c785a Binary files /dev/null and b/LaipuDrawing/res/bmp00030.bmp differ diff --git a/LaipuDrawing/res/bmp00031.bmp b/LaipuDrawing/res/bmp00031.bmp new file mode 100644 index 0000000..d5df660 Binary files /dev/null and b/LaipuDrawing/res/bmp00031.bmp differ diff --git a/LaipuDrawing/res/bmp00032.bmp b/LaipuDrawing/res/bmp00032.bmp new file mode 100644 index 0000000..ddf5531 Binary files /dev/null and b/LaipuDrawing/res/bmp00032.bmp differ diff --git a/LaipuDrawing/res/bmp00033.bmp b/LaipuDrawing/res/bmp00033.bmp new file mode 100644 index 0000000..d6c0e60 Binary files /dev/null and b/LaipuDrawing/res/bmp00033.bmp differ diff --git a/LaipuDrawing/res/bmp00034.bmp b/LaipuDrawing/res/bmp00034.bmp new file mode 100644 index 0000000..18ce6a0 Binary files /dev/null and b/LaipuDrawing/res/bmp00034.bmp differ diff --git a/LaipuDrawing/res/bmp00035.bmp b/LaipuDrawing/res/bmp00035.bmp new file mode 100644 index 0000000..5282fdc Binary files /dev/null and b/LaipuDrawing/res/bmp00035.bmp differ diff --git a/LaipuDrawing/res/bmp00036.bmp b/LaipuDrawing/res/bmp00036.bmp new file mode 100644 index 0000000..bd68137 Binary files /dev/null and b/LaipuDrawing/res/bmp00036.bmp differ diff --git a/LaipuDrawing/res/bmp00037.bmp b/LaipuDrawing/res/bmp00037.bmp new file mode 100644 index 0000000..b902aea Binary files /dev/null and b/LaipuDrawing/res/bmp00037.bmp differ diff --git a/LaipuDrawing/res/bmp00038.bmp b/LaipuDrawing/res/bmp00038.bmp new file mode 100644 index 0000000..e3d3fc1 Binary files /dev/null and b/LaipuDrawing/res/bmp00038.bmp differ diff --git a/LaipuDrawing/res/bmp00039.bmp b/LaipuDrawing/res/bmp00039.bmp new file mode 100644 index 0000000..b005484 Binary files /dev/null and b/LaipuDrawing/res/bmp00039.bmp differ diff --git a/LaipuDrawing/res/bmp00040.bmp b/LaipuDrawing/res/bmp00040.bmp new file mode 100644 index 0000000..6611318 Binary files /dev/null and b/LaipuDrawing/res/bmp00040.bmp differ diff --git a/LaipuDrawing/res/bmp00041.bmp b/LaipuDrawing/res/bmp00041.bmp new file mode 100644 index 0000000..f5ef72f Binary files /dev/null and b/LaipuDrawing/res/bmp00041.bmp differ diff --git a/LaipuDrawing/res/bmp00042.bmp b/LaipuDrawing/res/bmp00042.bmp new file mode 100644 index 0000000..5ccca6d Binary files /dev/null and b/LaipuDrawing/res/bmp00042.bmp differ diff --git a/LaipuDrawing/res/bmp00043.bmp b/LaipuDrawing/res/bmp00043.bmp new file mode 100644 index 0000000..0c98118 Binary files /dev/null and b/LaipuDrawing/res/bmp00043.bmp differ diff --git a/LaipuDrawing/res/bmp00044.bmp b/LaipuDrawing/res/bmp00044.bmp new file mode 100644 index 0000000..8a5bdeb Binary files /dev/null and b/LaipuDrawing/res/bmp00044.bmp differ diff --git a/LaipuDrawing/res/bmp00045.bmp b/LaipuDrawing/res/bmp00045.bmp new file mode 100644 index 0000000..fe74b97 Binary files /dev/null and b/LaipuDrawing/res/bmp00045.bmp differ diff --git a/LaipuDrawing/res/bmp00046.bmp b/LaipuDrawing/res/bmp00046.bmp new file mode 100644 index 0000000..4dd7ff9 Binary files /dev/null and b/LaipuDrawing/res/bmp00046.bmp differ diff --git a/LaipuDrawing/res/bmp00047.bmp b/LaipuDrawing/res/bmp00047.bmp new file mode 100644 index 0000000..d490820 Binary files /dev/null and b/LaipuDrawing/res/bmp00047.bmp differ diff --git a/LaipuDrawing/res/bmp00048.bmp b/LaipuDrawing/res/bmp00048.bmp new file mode 100644 index 0000000..52159e1 Binary files /dev/null and b/LaipuDrawing/res/bmp00048.bmp differ diff --git a/LaipuDrawing/res/bmp00049.bmp b/LaipuDrawing/res/bmp00049.bmp new file mode 100644 index 0000000..57cccb7 Binary files /dev/null and b/LaipuDrawing/res/bmp00049.bmp differ diff --git a/LaipuDrawing/res/bmp00050.bmp b/LaipuDrawing/res/bmp00050.bmp new file mode 100644 index 0000000..4f68f16 Binary files /dev/null and b/LaipuDrawing/res/bmp00050.bmp differ diff --git a/LaipuDrawing/res/bmp00051.bmp b/LaipuDrawing/res/bmp00051.bmp new file mode 100644 index 0000000..8d92094 Binary files /dev/null and b/LaipuDrawing/res/bmp00051.bmp differ diff --git a/LaipuDrawing/res/bmp00052.bmp b/LaipuDrawing/res/bmp00052.bmp new file mode 100644 index 0000000..4725ae9 Binary files /dev/null and b/LaipuDrawing/res/bmp00052.bmp differ diff --git a/LaipuDrawing/res/bmp00053.bmp b/LaipuDrawing/res/bmp00053.bmp new file mode 100644 index 0000000..22a7083 Binary files /dev/null and b/LaipuDrawing/res/bmp00053.bmp differ diff --git a/LaipuDrawing/res/bmp00054.bmp b/LaipuDrawing/res/bmp00054.bmp new file mode 100644 index 0000000..d78af03 Binary files /dev/null and b/LaipuDrawing/res/bmp00054.bmp differ diff --git a/LaipuDrawing/res/bmp00055.bmp b/LaipuDrawing/res/bmp00055.bmp new file mode 100644 index 0000000..bbba3c0 Binary files /dev/null and b/LaipuDrawing/res/bmp00055.bmp differ diff --git a/LaipuDrawing/res/bmp00056.bmp b/LaipuDrawing/res/bmp00056.bmp new file mode 100644 index 0000000..0d19319 Binary files /dev/null and b/LaipuDrawing/res/bmp00056.bmp differ diff --git a/LaipuDrawing/res/bmp00057.bmp b/LaipuDrawing/res/bmp00057.bmp new file mode 100644 index 0000000..cda0702 Binary files /dev/null and b/LaipuDrawing/res/bmp00057.bmp differ diff --git a/LaipuDrawing/res/bmp00058.bmp b/LaipuDrawing/res/bmp00058.bmp new file mode 100644 index 0000000..f0cfd3d Binary files /dev/null and b/LaipuDrawing/res/bmp00058.bmp differ diff --git a/LaipuDrawing/res/bmp00059.bmp b/LaipuDrawing/res/bmp00059.bmp new file mode 100644 index 0000000..0424ec9 Binary files /dev/null and b/LaipuDrawing/res/bmp00059.bmp differ diff --git a/LaipuDrawing/res/bmp00060.bmp b/LaipuDrawing/res/bmp00060.bmp new file mode 100644 index 0000000..4d07275 Binary files /dev/null and b/LaipuDrawing/res/bmp00060.bmp differ diff --git a/LaipuDrawing/res/bmp00061.bmp b/LaipuDrawing/res/bmp00061.bmp new file mode 100644 index 0000000..35b6430 Binary files /dev/null and b/LaipuDrawing/res/bmp00061.bmp differ diff --git a/LaipuDrawing/res/bmp00062.bmp b/LaipuDrawing/res/bmp00062.bmp new file mode 100644 index 0000000..bf91dda Binary files /dev/null and b/LaipuDrawing/res/bmp00062.bmp differ diff --git a/LaipuDrawing/res/bmp00063.bmp b/LaipuDrawing/res/bmp00063.bmp new file mode 100644 index 0000000..5355e4f Binary files /dev/null and b/LaipuDrawing/res/bmp00063.bmp differ diff --git a/LaipuDrawing/res/bmp00064.bmp b/LaipuDrawing/res/bmp00064.bmp new file mode 100644 index 0000000..32402d8 Binary files /dev/null and b/LaipuDrawing/res/bmp00064.bmp differ diff --git a/LaipuDrawing/res/bmp00065.bmp b/LaipuDrawing/res/bmp00065.bmp new file mode 100644 index 0000000..276f5db Binary files /dev/null and b/LaipuDrawing/res/bmp00065.bmp differ diff --git a/LaipuDrawing/res/bmp00066.bmp b/LaipuDrawing/res/bmp00066.bmp new file mode 100644 index 0000000..7b6866f Binary files /dev/null and b/LaipuDrawing/res/bmp00066.bmp differ diff --git a/LaipuDrawing/res/bmp00067.bmp b/LaipuDrawing/res/bmp00067.bmp new file mode 100644 index 0000000..90ad97f Binary files /dev/null and b/LaipuDrawing/res/bmp00067.bmp differ diff --git a/LaipuDrawing/res/bmp00068.bmp b/LaipuDrawing/res/bmp00068.bmp new file mode 100644 index 0000000..2090025 Binary files /dev/null and b/LaipuDrawing/res/bmp00068.bmp differ diff --git a/LaipuDrawing/res/bmp00069.bmp b/LaipuDrawing/res/bmp00069.bmp new file mode 100644 index 0000000..27bb9fb Binary files /dev/null and b/LaipuDrawing/res/bmp00069.bmp differ diff --git a/LaipuDrawing/res/bmp00070.bmp b/LaipuDrawing/res/bmp00070.bmp new file mode 100644 index 0000000..8d8845c Binary files /dev/null and b/LaipuDrawing/res/bmp00070.bmp differ diff --git a/LaipuDrawing/res/bmp00071.bmp b/LaipuDrawing/res/bmp00071.bmp new file mode 100644 index 0000000..39227a7 Binary files /dev/null and b/LaipuDrawing/res/bmp00071.bmp differ diff --git a/LaipuDrawing/res/bmp00072.bmp b/LaipuDrawing/res/bmp00072.bmp new file mode 100644 index 0000000..17740a9 Binary files /dev/null and b/LaipuDrawing/res/bmp00072.bmp differ diff --git a/LaipuDrawing/res/bmp00073.bmp b/LaipuDrawing/res/bmp00073.bmp new file mode 100644 index 0000000..57a4877 Binary files /dev/null and b/LaipuDrawing/res/bmp00073.bmp differ diff --git a/LaipuDrawing/res/bmp00074.bmp b/LaipuDrawing/res/bmp00074.bmp new file mode 100644 index 0000000..8ee4764 Binary files /dev/null and b/LaipuDrawing/res/bmp00074.bmp differ diff --git a/LaipuDrawing/res/bmp00075.bmp b/LaipuDrawing/res/bmp00075.bmp new file mode 100644 index 0000000..bfae3c6 Binary files /dev/null and b/LaipuDrawing/res/bmp00075.bmp differ diff --git a/LaipuDrawing/res/bmp00076.bmp b/LaipuDrawing/res/bmp00076.bmp new file mode 100644 index 0000000..fb43060 Binary files /dev/null and b/LaipuDrawing/res/bmp00076.bmp differ diff --git a/LaipuDrawing/res/bmp00077.bmp b/LaipuDrawing/res/bmp00077.bmp new file mode 100644 index 0000000..08c0e31 Binary files /dev/null and b/LaipuDrawing/res/bmp00077.bmp differ diff --git a/LaipuDrawing/res/bmp00078.bmp b/LaipuDrawing/res/bmp00078.bmp new file mode 100644 index 0000000..bb3f1c1 Binary files /dev/null and b/LaipuDrawing/res/bmp00078.bmp differ diff --git a/LaipuDrawing/res/bmp00079.bmp b/LaipuDrawing/res/bmp00079.bmp new file mode 100644 index 0000000..bb1dafc Binary files /dev/null and b/LaipuDrawing/res/bmp00079.bmp differ diff --git a/LaipuDrawing/res/bmp00080.bmp b/LaipuDrawing/res/bmp00080.bmp new file mode 100644 index 0000000..8a5a865 Binary files /dev/null and b/LaipuDrawing/res/bmp00080.bmp differ diff --git a/LaipuDrawing/res/bmp00081.bmp b/LaipuDrawing/res/bmp00081.bmp new file mode 100644 index 0000000..1ee3145 Binary files /dev/null and b/LaipuDrawing/res/bmp00081.bmp differ diff --git a/LaipuDrawing/res/bmp00082.bmp b/LaipuDrawing/res/bmp00082.bmp new file mode 100644 index 0000000..bcdbb7a Binary files /dev/null and b/LaipuDrawing/res/bmp00082.bmp differ diff --git a/LaipuDrawing/res/bmp00083.bmp b/LaipuDrawing/res/bmp00083.bmp new file mode 100644 index 0000000..f244836 Binary files /dev/null and b/LaipuDrawing/res/bmp00083.bmp differ diff --git a/LaipuDrawing/res/bmp00084.bmp b/LaipuDrawing/res/bmp00084.bmp new file mode 100644 index 0000000..61d3ccc Binary files /dev/null and b/LaipuDrawing/res/bmp00084.bmp differ diff --git a/LaipuDrawing/res/bmp00085.bmp b/LaipuDrawing/res/bmp00085.bmp new file mode 100644 index 0000000..3e96d09 Binary files /dev/null and b/LaipuDrawing/res/bmp00085.bmp differ diff --git a/LaipuDrawing/res/bmp00086.bmp b/LaipuDrawing/res/bmp00086.bmp new file mode 100644 index 0000000..2a4a6ea Binary files /dev/null and b/LaipuDrawing/res/bmp00086.bmp differ diff --git a/LaipuDrawing/res/bmp00087.bmp b/LaipuDrawing/res/bmp00087.bmp new file mode 100644 index 0000000..27ba1dc Binary files /dev/null and b/LaipuDrawing/res/bmp00087.bmp differ diff --git a/LaipuDrawing/res/bmp00088.bmp b/LaipuDrawing/res/bmp00088.bmp new file mode 100644 index 0000000..24e812f Binary files /dev/null and b/LaipuDrawing/res/bmp00088.bmp differ diff --git a/LaipuDrawing/res/bmp00089.bmp b/LaipuDrawing/res/bmp00089.bmp new file mode 100644 index 0000000..787fd3b Binary files /dev/null and b/LaipuDrawing/res/bmp00089.bmp differ diff --git a/LaipuDrawing/res/bmp00090.bmp b/LaipuDrawing/res/bmp00090.bmp new file mode 100644 index 0000000..8ccb258 Binary files /dev/null and b/LaipuDrawing/res/bmp00090.bmp differ diff --git a/LaipuDrawing/res/bmp00091.bmp b/LaipuDrawing/res/bmp00091.bmp new file mode 100644 index 0000000..dff5dda Binary files /dev/null and b/LaipuDrawing/res/bmp00091.bmp differ diff --git a/LaipuDrawing/res/bmp00092.bmp b/LaipuDrawing/res/bmp00092.bmp new file mode 100644 index 0000000..c2b7a65 Binary files /dev/null and b/LaipuDrawing/res/bmp00092.bmp differ diff --git a/LaipuDrawing/res/bmp00093.bmp b/LaipuDrawing/res/bmp00093.bmp new file mode 100644 index 0000000..37ac350 Binary files /dev/null and b/LaipuDrawing/res/bmp00093.bmp differ diff --git a/LaipuDrawing/res/bmp00094.bmp b/LaipuDrawing/res/bmp00094.bmp new file mode 100644 index 0000000..e6d438e Binary files /dev/null and b/LaipuDrawing/res/bmp00094.bmp differ diff --git a/LaipuDrawing/res/bmp00095.bmp b/LaipuDrawing/res/bmp00095.bmp new file mode 100644 index 0000000..452436f Binary files /dev/null and b/LaipuDrawing/res/bmp00095.bmp differ diff --git a/LaipuDrawing/res/bmp00096.bmp b/LaipuDrawing/res/bmp00096.bmp new file mode 100644 index 0000000..69b172c Binary files /dev/null and b/LaipuDrawing/res/bmp00096.bmp differ diff --git a/LaipuDrawing/res/bmp00097.bmp b/LaipuDrawing/res/bmp00097.bmp new file mode 100644 index 0000000..6170477 Binary files /dev/null and b/LaipuDrawing/res/bmp00097.bmp differ diff --git a/LaipuDrawing/res/bmp00098.bmp b/LaipuDrawing/res/bmp00098.bmp new file mode 100644 index 0000000..5355e4f Binary files /dev/null and b/LaipuDrawing/res/bmp00098.bmp differ diff --git a/LaipuDrawing/res/bmp00099.bmp b/LaipuDrawing/res/bmp00099.bmp new file mode 100644 index 0000000..a55fbaf Binary files /dev/null and b/LaipuDrawing/res/bmp00099.bmp differ diff --git a/LaipuDrawing/res/bmp00100.bmp b/LaipuDrawing/res/bmp00100.bmp new file mode 100644 index 0000000..9223ab9 Binary files /dev/null and b/LaipuDrawing/res/bmp00100.bmp differ diff --git a/LaipuDrawing/res/bmp00101.bmp b/LaipuDrawing/res/bmp00101.bmp new file mode 100644 index 0000000..463b259 Binary files /dev/null and b/LaipuDrawing/res/bmp00101.bmp differ diff --git a/LaipuDrawing/res/bmp00102.bmp b/LaipuDrawing/res/bmp00102.bmp new file mode 100644 index 0000000..71033f3 Binary files /dev/null and b/LaipuDrawing/res/bmp00102.bmp differ diff --git a/LaipuDrawing/res/bmp00103.bmp b/LaipuDrawing/res/bmp00103.bmp new file mode 100644 index 0000000..7cb2c06 Binary files /dev/null and b/LaipuDrawing/res/bmp00103.bmp differ diff --git a/LaipuDrawing/res/bmp00104.bmp b/LaipuDrawing/res/bmp00104.bmp new file mode 100644 index 0000000..f3e7824 Binary files /dev/null and b/LaipuDrawing/res/bmp00104.bmp differ diff --git a/LaipuDrawing/res/bmp00105.bmp b/LaipuDrawing/res/bmp00105.bmp new file mode 100644 index 0000000..0d2b86b Binary files /dev/null and b/LaipuDrawing/res/bmp00105.bmp differ diff --git a/LaipuDrawing/res/bmp00106.bmp b/LaipuDrawing/res/bmp00106.bmp new file mode 100644 index 0000000..b563c46 Binary files /dev/null and b/LaipuDrawing/res/bmp00106.bmp differ diff --git a/LaipuDrawing/res/bmp00107.bmp b/LaipuDrawing/res/bmp00107.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00107.bmp differ diff --git a/LaipuDrawing/res/bmp00108.bmp b/LaipuDrawing/res/bmp00108.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00108.bmp differ diff --git a/LaipuDrawing/res/bmp00109.bmp b/LaipuDrawing/res/bmp00109.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00109.bmp differ diff --git a/LaipuDrawing/res/bmp00110.bmp b/LaipuDrawing/res/bmp00110.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00110.bmp differ diff --git a/LaipuDrawing/res/bmp00111.bmp b/LaipuDrawing/res/bmp00111.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00111.bmp differ diff --git a/LaipuDrawing/res/bmp00112.bmp b/LaipuDrawing/res/bmp00112.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00112.bmp differ diff --git a/LaipuDrawing/res/bmp00113.bmp b/LaipuDrawing/res/bmp00113.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00113.bmp differ diff --git a/LaipuDrawing/res/bmp00114.bmp b/LaipuDrawing/res/bmp00114.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00114.bmp differ diff --git a/LaipuDrawing/res/bmp00115.bmp b/LaipuDrawing/res/bmp00115.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00115.bmp differ diff --git a/LaipuDrawing/res/bmp00116.bmp b/LaipuDrawing/res/bmp00116.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00116.bmp differ diff --git a/LaipuDrawing/res/bmp00117.bmp b/LaipuDrawing/res/bmp00117.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00117.bmp differ diff --git a/LaipuDrawing/res/bmp00118.bmp b/LaipuDrawing/res/bmp00118.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00118.bmp differ diff --git a/LaipuDrawing/res/bmp00119.bmp b/LaipuDrawing/res/bmp00119.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00119.bmp differ diff --git a/LaipuDrawing/res/bmp00120.bmp b/LaipuDrawing/res/bmp00120.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00120.bmp differ diff --git a/LaipuDrawing/res/bmp00121.bmp b/LaipuDrawing/res/bmp00121.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00121.bmp differ diff --git a/LaipuDrawing/res/bmp00122.bmp b/LaipuDrawing/res/bmp00122.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00122.bmp differ diff --git a/LaipuDrawing/res/bmp00123.bmp b/LaipuDrawing/res/bmp00123.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00123.bmp differ diff --git a/LaipuDrawing/res/bmp00124.bmp b/LaipuDrawing/res/bmp00124.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00124.bmp differ diff --git a/LaipuDrawing/res/bmp00125.bmp b/LaipuDrawing/res/bmp00125.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00125.bmp differ diff --git a/LaipuDrawing/res/bmp00126.bmp b/LaipuDrawing/res/bmp00126.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00126.bmp differ diff --git a/LaipuDrawing/res/bmp00127.bmp b/LaipuDrawing/res/bmp00127.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00127.bmp differ diff --git a/LaipuDrawing/res/bmp00128.bmp b/LaipuDrawing/res/bmp00128.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00128.bmp differ diff --git a/LaipuDrawing/res/bmp00129.bmp b/LaipuDrawing/res/bmp00129.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00129.bmp differ diff --git a/LaipuDrawing/res/bmp00130.bmp b/LaipuDrawing/res/bmp00130.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00130.bmp differ diff --git a/LaipuDrawing/res/bmp00131.bmp b/LaipuDrawing/res/bmp00131.bmp new file mode 100644 index 0000000..473f03e Binary files /dev/null and b/LaipuDrawing/res/bmp00131.bmp differ diff --git a/LaipuDrawing/res/btn_img1.bmp b/LaipuDrawing/res/btn_img1.bmp new file mode 100644 index 0000000..7883d6b Binary files /dev/null and b/LaipuDrawing/res/btn_img1.bmp differ diff --git a/LaipuDrawing/res/btn_img2.bmp b/LaipuDrawing/res/btn_img2.bmp new file mode 100644 index 0000000..43311a8 Binary files /dev/null and b/LaipuDrawing/res/btn_img2.bmp differ diff --git a/LaipuDrawing/res/btn_img3.bmp b/LaipuDrawing/res/btn_img3.bmp new file mode 100644 index 0000000..793e546 Binary files /dev/null and b/LaipuDrawing/res/btn_img3.bmp differ diff --git a/LaipuDrawing/res/btn_img4.bmp b/LaipuDrawing/res/btn_img4.bmp new file mode 100644 index 0000000..b5b4b69 Binary files /dev/null and b/LaipuDrawing/res/btn_img4.bmp differ diff --git a/LaipuDrawing/res/btn_img5.bmp b/LaipuDrawing/res/btn_img5.bmp new file mode 100644 index 0000000..79f8ee8 Binary files /dev/null and b/LaipuDrawing/res/btn_img5.bmp differ diff --git a/LaipuDrawing/res/btn_img6.bmp b/LaipuDrawing/res/btn_img6.bmp new file mode 100644 index 0000000..544b00a Binary files /dev/null and b/LaipuDrawing/res/btn_img6.bmp differ diff --git a/LaipuDrawing/res/btn_img7.bmp b/LaipuDrawing/res/btn_img7.bmp new file mode 100644 index 0000000..c8f4d21 Binary files /dev/null and b/LaipuDrawing/res/btn_img7.bmp differ diff --git a/LaipuDrawing/res/btn_img8.bmp b/LaipuDrawing/res/btn_img8.bmp new file mode 100644 index 0000000..af78059 Binary files /dev/null and b/LaipuDrawing/res/btn_img8.bmp differ diff --git a/LaipuDrawing/res/btn_img9.bmp b/LaipuDrawing/res/btn_img9.bmp new file mode 100644 index 0000000..f380396 Binary files /dev/null and b/LaipuDrawing/res/btn_img9.bmp differ diff --git a/LaipuDrawing/res/center/IniDevice.bmp b/LaipuDrawing/res/center/IniDevice.bmp new file mode 100644 index 0000000..7de25c6 Binary files /dev/null and b/LaipuDrawing/res/center/IniDevice.bmp differ diff --git a/LaipuDrawing/res/center/IniDeviceDown.bmp b/LaipuDrawing/res/center/IniDeviceDown.bmp new file mode 100644 index 0000000..8da4c69 Binary files /dev/null and b/LaipuDrawing/res/center/IniDeviceDown.bmp differ diff --git a/LaipuDrawing/res/center/OpenFile.bmp b/LaipuDrawing/res/center/OpenFile.bmp new file mode 100644 index 0000000..fc5e827 Binary files /dev/null and b/LaipuDrawing/res/center/OpenFile.bmp differ diff --git a/LaipuDrawing/res/center/OpenFileDown.bmp b/LaipuDrawing/res/center/OpenFileDown.bmp new file mode 100644 index 0000000..d54d41b Binary files /dev/null and b/LaipuDrawing/res/center/OpenFileDown.bmp differ diff --git a/LaipuDrawing/res/center/OriginPt.bmp b/LaipuDrawing/res/center/OriginPt.bmp new file mode 100644 index 0000000..35633ef Binary files /dev/null and b/LaipuDrawing/res/center/OriginPt.bmp differ diff --git a/LaipuDrawing/res/center/OriginPtDown.bmp b/LaipuDrawing/res/center/OriginPtDown.bmp new file mode 100644 index 0000000..9c0e9e7 Binary files /dev/null and b/LaipuDrawing/res/center/OriginPtDown.bmp differ diff --git a/LaipuDrawing/res/center/ProductPt.bmp b/LaipuDrawing/res/center/ProductPt.bmp new file mode 100644 index 0000000..c866c33 Binary files /dev/null and b/LaipuDrawing/res/center/ProductPt.bmp differ diff --git a/LaipuDrawing/res/center/ProductPtDown.bmp b/LaipuDrawing/res/center/ProductPtDown.bmp new file mode 100644 index 0000000..8169975 Binary files /dev/null and b/LaipuDrawing/res/center/ProductPtDown.bmp differ diff --git a/LaipuDrawing/res/center/Start.bmp b/LaipuDrawing/res/center/Start.bmp new file mode 100644 index 0000000..376547b Binary files /dev/null and b/LaipuDrawing/res/center/Start.bmp differ diff --git a/LaipuDrawing/res/center/Start_Down.bmp b/LaipuDrawing/res/center/Start_Down.bmp new file mode 100644 index 0000000..42dda9e Binary files /dev/null and b/LaipuDrawing/res/center/Start_Down.bmp differ diff --git a/LaipuDrawing/res/center/Stop.bmp b/LaipuDrawing/res/center/Stop.bmp new file mode 100644 index 0000000..669ca50 Binary files /dev/null and b/LaipuDrawing/res/center/Stop.bmp differ diff --git a/LaipuDrawing/res/center/Stop_Down.bmp b/LaipuDrawing/res/center/Stop_Down.bmp new file mode 100644 index 0000000..c4785fd Binary files /dev/null and b/LaipuDrawing/res/center/Stop_Down.bmp differ diff --git a/LaipuDrawing/res/center/Vacuum.bmp b/LaipuDrawing/res/center/Vacuum.bmp new file mode 100644 index 0000000..6796a61 Binary files /dev/null and b/LaipuDrawing/res/center/Vacuum.bmp differ diff --git a/LaipuDrawing/res/center/VacuumClose.bmp b/LaipuDrawing/res/center/VacuumClose.bmp new file mode 100644 index 0000000..df0b686 Binary files /dev/null and b/LaipuDrawing/res/center/VacuumClose.bmp differ diff --git a/LaipuDrawing/res/center/VacuumCloseDown.bmp b/LaipuDrawing/res/center/VacuumCloseDown.bmp new file mode 100644 index 0000000..08b1247 Binary files /dev/null and b/LaipuDrawing/res/center/VacuumCloseDown.bmp differ diff --git a/LaipuDrawing/res/center/VacuumDown.bmp b/LaipuDrawing/res/center/VacuumDown.bmp new file mode 100644 index 0000000..9b78a37 Binary files /dev/null and b/LaipuDrawing/res/center/VacuumDown.bmp differ diff --git a/LaipuDrawing/res/center/exit.bmp b/LaipuDrawing/res/center/exit.bmp new file mode 100644 index 0000000..12bbb31 Binary files /dev/null and b/LaipuDrawing/res/center/exit.bmp differ diff --git a/LaipuDrawing/res/center/exit_down.bmp b/LaipuDrawing/res/center/exit_down.bmp new file mode 100644 index 0000000..0b08f75 Binary files /dev/null and b/LaipuDrawing/res/center/exit_down.bmp differ diff --git a/LaipuDrawing/res/center/login.bmp b/LaipuDrawing/res/center/login.bmp new file mode 100644 index 0000000..04aaa28 Binary files /dev/null and b/LaipuDrawing/res/center/login.bmp differ diff --git a/LaipuDrawing/res/center/login_Down.bmp b/LaipuDrawing/res/center/login_Down.bmp new file mode 100644 index 0000000..8670733 Binary files /dev/null and b/LaipuDrawing/res/center/login_Down.bmp differ diff --git a/LaipuDrawing/res/cur00001.cur b/LaipuDrawing/res/cur00001.cur new file mode 100644 index 0000000..34c01ef Binary files /dev/null and b/LaipuDrawing/res/cur00001.cur differ diff --git a/LaipuDrawing/res/cur00002.cur b/LaipuDrawing/res/cur00002.cur new file mode 100644 index 0000000..589b32b Binary files /dev/null and b/LaipuDrawing/res/cur00002.cur differ diff --git a/LaipuDrawing/res/cur00003.cur b/LaipuDrawing/res/cur00003.cur new file mode 100644 index 0000000..1a91efe Binary files /dev/null and b/LaipuDrawing/res/cur00003.cur differ diff --git a/LaipuDrawing/res/cursor0.cur b/LaipuDrawing/res/cursor0.cur new file mode 100644 index 0000000..2289c30 Binary files /dev/null and b/LaipuDrawing/res/cursor0.cur differ diff --git a/LaipuDrawing/res/cursor1.cur b/LaipuDrawing/res/cursor1.cur new file mode 100644 index 0000000..39171fb Binary files /dev/null and b/LaipuDrawing/res/cursor1.cur differ diff --git a/LaipuDrawing/res/cursor2.cur b/LaipuDrawing/res/cursor2.cur new file mode 100644 index 0000000..850ce01 Binary files /dev/null and b/LaipuDrawing/res/cursor2.cur differ diff --git a/LaipuDrawing/res/exit.bmp b/LaipuDrawing/res/exit.bmp new file mode 100644 index 0000000..30bcfc6 Binary files /dev/null and b/LaipuDrawing/res/exit.bmp differ diff --git a/LaipuDrawing/res/exit_down - 副本.bmp b/LaipuDrawing/res/exit_down - 副本.bmp new file mode 100644 index 0000000..28f28b8 Binary files /dev/null and b/LaipuDrawing/res/exit_down - 副本.bmp differ diff --git a/LaipuDrawing/res/exit_down.bmp b/LaipuDrawing/res/exit_down.bmp new file mode 100644 index 0000000..bfe754c Binary files /dev/null and b/LaipuDrawing/res/exit_down.bmp differ diff --git a/LaipuDrawing/res/green.bmp b/LaipuDrawing/res/green.bmp new file mode 100644 index 0000000..e143f6c Binary files /dev/null and b/LaipuDrawing/res/green.bmp differ diff --git a/LaipuDrawing/res/icon1.ico b/LaipuDrawing/res/icon1.ico new file mode 100644 index 0000000..f1282c6 Binary files /dev/null and b/LaipuDrawing/res/icon1.ico differ diff --git a/LaipuDrawing/res/info.bmp b/LaipuDrawing/res/info.bmp new file mode 100644 index 0000000..08b705b Binary files /dev/null and b/LaipuDrawing/res/info.bmp differ diff --git a/LaipuDrawing/res/left/IniDevice.bmp b/LaipuDrawing/res/left/IniDevice.bmp new file mode 100644 index 0000000..0845629 Binary files /dev/null and b/LaipuDrawing/res/left/IniDevice.bmp differ diff --git a/LaipuDrawing/res/left/IniDeviceDown.bmp b/LaipuDrawing/res/left/IniDeviceDown.bmp new file mode 100644 index 0000000..29545d8 Binary files /dev/null and b/LaipuDrawing/res/left/IniDeviceDown.bmp differ diff --git a/LaipuDrawing/res/left/OpenFile.bmp b/LaipuDrawing/res/left/OpenFile.bmp new file mode 100644 index 0000000..74cba3a Binary files /dev/null and b/LaipuDrawing/res/left/OpenFile.bmp differ diff --git a/LaipuDrawing/res/left/OpenFileDown.bmp b/LaipuDrawing/res/left/OpenFileDown.bmp new file mode 100644 index 0000000..6d83593 Binary files /dev/null and b/LaipuDrawing/res/left/OpenFileDown.bmp differ diff --git a/LaipuDrawing/res/left/OriginPt.bmp b/LaipuDrawing/res/left/OriginPt.bmp new file mode 100644 index 0000000..4fb7c09 Binary files /dev/null and b/LaipuDrawing/res/left/OriginPt.bmp differ diff --git a/LaipuDrawing/res/left/OriginPtDown.bmp b/LaipuDrawing/res/left/OriginPtDown.bmp new file mode 100644 index 0000000..2c1242c Binary files /dev/null and b/LaipuDrawing/res/left/OriginPtDown.bmp differ diff --git a/LaipuDrawing/res/left/ProductPt.bmp b/LaipuDrawing/res/left/ProductPt.bmp new file mode 100644 index 0000000..2ef4327 Binary files /dev/null and b/LaipuDrawing/res/left/ProductPt.bmp differ diff --git a/LaipuDrawing/res/left/ProductPtDown.bmp b/LaipuDrawing/res/left/ProductPtDown.bmp new file mode 100644 index 0000000..24658f5 Binary files /dev/null and b/LaipuDrawing/res/left/ProductPtDown.bmp differ diff --git a/LaipuDrawing/res/left/Start.bmp b/LaipuDrawing/res/left/Start.bmp new file mode 100644 index 0000000..2a6af6d Binary files /dev/null and b/LaipuDrawing/res/left/Start.bmp differ diff --git a/LaipuDrawing/res/left/Start_Down.bmp b/LaipuDrawing/res/left/Start_Down.bmp new file mode 100644 index 0000000..4c211b9 Binary files /dev/null and b/LaipuDrawing/res/left/Start_Down.bmp differ diff --git a/LaipuDrawing/res/left/Stop.bmp b/LaipuDrawing/res/left/Stop.bmp new file mode 100644 index 0000000..227bfb9 Binary files /dev/null and b/LaipuDrawing/res/left/Stop.bmp differ diff --git a/LaipuDrawing/res/left/Stop_Down.bmp b/LaipuDrawing/res/left/Stop_Down.bmp new file mode 100644 index 0000000..a100a0d Binary files /dev/null and b/LaipuDrawing/res/left/Stop_Down.bmp differ diff --git a/LaipuDrawing/res/left/Vacuum.bmp b/LaipuDrawing/res/left/Vacuum.bmp new file mode 100644 index 0000000..b926d20 Binary files /dev/null and b/LaipuDrawing/res/left/Vacuum.bmp differ diff --git a/LaipuDrawing/res/left/VacuumClose.bmp b/LaipuDrawing/res/left/VacuumClose.bmp new file mode 100644 index 0000000..5c65411 Binary files /dev/null and b/LaipuDrawing/res/left/VacuumClose.bmp differ diff --git a/LaipuDrawing/res/left/VacuumCloseDown.bmp b/LaipuDrawing/res/left/VacuumCloseDown.bmp new file mode 100644 index 0000000..738a42c Binary files /dev/null and b/LaipuDrawing/res/left/VacuumCloseDown.bmp differ diff --git a/LaipuDrawing/res/left/VacuumDown.bmp b/LaipuDrawing/res/left/VacuumDown.bmp new file mode 100644 index 0000000..f8d99b1 Binary files /dev/null and b/LaipuDrawing/res/left/VacuumDown.bmp differ diff --git a/LaipuDrawing/res/left/exit.bmp b/LaipuDrawing/res/left/exit.bmp new file mode 100644 index 0000000..128e972 Binary files /dev/null and b/LaipuDrawing/res/left/exit.bmp differ diff --git a/LaipuDrawing/res/left/exit_down.bmp b/LaipuDrawing/res/left/exit_down.bmp new file mode 100644 index 0000000..fa5f4ff Binary files /dev/null and b/LaipuDrawing/res/left/exit_down.bmp differ diff --git a/LaipuDrawing/res/left/login.bmp b/LaipuDrawing/res/left/login.bmp new file mode 100644 index 0000000..6d94ae4 Binary files /dev/null and b/LaipuDrawing/res/left/login.bmp differ diff --git a/LaipuDrawing/res/left/login_Down.bmp b/LaipuDrawing/res/left/login_Down.bmp new file mode 100644 index 0000000..e8ec951 Binary files /dev/null and b/LaipuDrawing/res/left/login_Down.bmp differ diff --git a/LaipuDrawing/res/login.bmp b/LaipuDrawing/res/login.bmp new file mode 100644 index 0000000..26ff741 Binary files /dev/null and b/LaipuDrawing/res/login.bmp differ diff --git a/LaipuDrawing/res/login_Down.bmp b/LaipuDrawing/res/login_Down.bmp new file mode 100644 index 0000000..74308b3 Binary files /dev/null and b/LaipuDrawing/res/login_Down.bmp differ diff --git a/LaipuDrawing/res/logo.bmp b/LaipuDrawing/res/logo.bmp new file mode 100644 index 0000000..2a02dbd Binary files /dev/null and b/LaipuDrawing/res/logo.bmp differ diff --git a/LaipuDrawing/res/logo111.bmp b/LaipuDrawing/res/logo111.bmp new file mode 100644 index 0000000..a733de8 Binary files /dev/null and b/LaipuDrawing/res/logo111.bmp differ diff --git a/LaipuDrawing/res/lp.png b/LaipuDrawing/res/lp.png new file mode 100644 index 0000000..5f642a4 Binary files /dev/null and b/LaipuDrawing/res/lp.png differ diff --git a/LaipuDrawing/res/mainfram.bmp b/LaipuDrawing/res/mainfram.bmp new file mode 100644 index 0000000..5a91597 Binary files /dev/null and b/LaipuDrawing/res/mainfram.bmp differ diff --git a/LaipuDrawing/res/mouse_dr.cur b/LaipuDrawing/res/mouse_dr.cur new file mode 100644 index 0000000..69de8de Binary files /dev/null and b/LaipuDrawing/res/mouse_dr.cur differ diff --git a/LaipuDrawing/res/mouse_ha.cur b/LaipuDrawing/res/mouse_ha.cur new file mode 100644 index 0000000..c50d0c9 Binary files /dev/null and b/LaipuDrawing/res/mouse_ha.cur differ diff --git a/LaipuDrawing/res/mouse_mo.cur b/LaipuDrawing/res/mouse_mo.cur new file mode 100644 index 0000000..d8efc38 Binary files /dev/null and b/LaipuDrawing/res/mouse_mo.cur differ diff --git a/LaipuDrawing/res/mouse_no.cur b/LaipuDrawing/res/mouse_no.cur new file mode 100644 index 0000000..2d49305 Binary files /dev/null and b/LaipuDrawing/res/mouse_no.cur differ diff --git a/LaipuDrawing/res/mouse_po.cur b/LaipuDrawing/res/mouse_po.cur new file mode 100644 index 0000000..73454e7 Binary files /dev/null and b/LaipuDrawing/res/mouse_po.cur differ diff --git a/LaipuDrawing/res/nav_large.bmp b/LaipuDrawing/res/nav_large.bmp new file mode 100644 index 0000000..a081e17 Binary files /dev/null and b/LaipuDrawing/res/nav_large.bmp differ diff --git a/LaipuDrawing/res/nav_large_hc.bmp b/LaipuDrawing/res/nav_large_hc.bmp new file mode 100644 index 0000000..6607b55 Binary files /dev/null and b/LaipuDrawing/res/nav_large_hc.bmp differ diff --git a/LaipuDrawing/res/output_wnd.ico b/LaipuDrawing/res/output_wnd.ico new file mode 100644 index 0000000..d14f991 Binary files /dev/null and b/LaipuDrawing/res/output_wnd.ico differ diff --git a/LaipuDrawing/res/output_wnd_hc.ico b/LaipuDrawing/res/output_wnd_hc.ico new file mode 100644 index 0000000..fdd27e8 Binary files /dev/null and b/LaipuDrawing/res/output_wnd_hc.ico differ diff --git a/LaipuDrawing/res/pages.bmp b/LaipuDrawing/res/pages.bmp new file mode 100644 index 0000000..28c7202 Binary files /dev/null and b/LaipuDrawing/res/pages.bmp differ diff --git a/LaipuDrawing/res/pages_hc.bmp b/LaipuDrawing/res/pages_hc.bmp new file mode 100644 index 0000000..d5850bc Binary files /dev/null and b/LaipuDrawing/res/pages_hc.bmp differ diff --git a/LaipuDrawing/res/pages_small.bmp b/LaipuDrawing/res/pages_small.bmp new file mode 100644 index 0000000..f48e621 Binary files /dev/null and b/LaipuDrawing/res/pages_small.bmp differ diff --git a/LaipuDrawing/res/pages_small_hc.bmp b/LaipuDrawing/res/pages_small_hc.bmp new file mode 100644 index 0000000..b6fd7c2 Binary files /dev/null and b/LaipuDrawing/res/pages_small_hc.bmp differ diff --git a/LaipuDrawing/res/properties.bmp b/LaipuDrawing/res/properties.bmp new file mode 100644 index 0000000..9906cc8 Binary files /dev/null and b/LaipuDrawing/res/properties.bmp differ diff --git a/LaipuDrawing/res/properties_hc.bmp b/LaipuDrawing/res/properties_hc.bmp new file mode 100644 index 0000000..6e90ff4 Binary files /dev/null and b/LaipuDrawing/res/properties_hc.bmp differ diff --git a/LaipuDrawing/res/properties_wnd.ico b/LaipuDrawing/res/properties_wnd.ico new file mode 100644 index 0000000..3611766 Binary files /dev/null and b/LaipuDrawing/res/properties_wnd.ico differ diff --git a/LaipuDrawing/res/properties_wnd_hc.ico b/LaipuDrawing/res/properties_wnd_hc.ico new file mode 100644 index 0000000..1e06b64 Binary files /dev/null and b/LaipuDrawing/res/properties_wnd_hc.ico differ diff --git a/LaipuDrawing/res/red.bmp b/LaipuDrawing/res/red.bmp new file mode 100644 index 0000000..ed07ddf Binary files /dev/null and b/LaipuDrawing/res/red.bmp differ diff --git a/LaipuDrawing/res/toolbar1.bmp b/LaipuDrawing/res/toolbar1.bmp new file mode 100644 index 0000000..6a12354 Binary files /dev/null and b/LaipuDrawing/res/toolbar1.bmp differ diff --git a/LaipuDrawing/res/yellow.bmp b/LaipuDrawing/res/yellow.bmp new file mode 100644 index 0000000..8ba08b5 Binary files /dev/null and b/LaipuDrawing/res/yellow.bmp differ diff --git a/LaipuDrawing/res/zoom1.cur b/LaipuDrawing/res/zoom1.cur new file mode 100644 index 0000000..a6acd8f Binary files /dev/null and b/LaipuDrawing/res/zoom1.cur differ diff --git a/LaipuDrawing/res/zoom2.cur b/LaipuDrawing/res/zoom2.cur new file mode 100644 index 0000000..ed4a478 Binary files /dev/null and b/LaipuDrawing/res/zoom2.cur differ diff --git a/LaipuDrawing/res/模板.bmp b/LaipuDrawing/res/模板.bmp new file mode 100644 index 0000000..d443894 Binary files /dev/null and b/LaipuDrawing/res/模板.bmp differ diff --git a/LaipuDrawing/res/模板2.bmp b/LaipuDrawing/res/模板2.bmp new file mode 100644 index 0000000..73c5568 Binary files /dev/null and b/LaipuDrawing/res/模板2.bmp differ diff --git a/LaipuDrawing/res/模板3.bmp b/LaipuDrawing/res/模板3.bmp new file mode 100644 index 0000000..7adf341 Binary files /dev/null and b/LaipuDrawing/res/模板3.bmp differ diff --git a/LaipuDrawing/res/模板4.bmp b/LaipuDrawing/res/模板4.bmp new file mode 100644 index 0000000..032c935 Binary files /dev/null and b/LaipuDrawing/res/模板4.bmp differ diff --git a/LaipuDrawing/resource.h b/LaipuDrawing/resource.h new file mode 100644 index 0000000..7f0887e Binary files /dev/null and b/LaipuDrawing/resource.h differ diff --git a/LaipuDrawing/stdafx.cpp b/LaipuDrawing/stdafx.cpp new file mode 100644 index 0000000..955ae49 --- /dev/null +++ b/LaipuDrawing/stdafx.cpp @@ -0,0 +1,10 @@ + +// stdafx.cpp : ֻ׼ļԴļ +// LaiPuLaser.pch ΪԤͷ +// stdafx.obj ԤϢ + +#include "stdafx.h" + +bool gExitApp = false;//Ƿ˳ +bool gbFactoryMode = false;//ģʽ +bool gbSimpleParMode = false;//ģʽ \ No newline at end of file diff --git a/LaipuDrawing/stdafx.h b/LaipuDrawing/stdafx.h new file mode 100644 index 0000000..31bfe5e --- /dev/null +++ b/LaipuDrawing/stdafx.h @@ -0,0 +1,283 @@ + +// stdafx.h : ׼ϵͳļİļ +// Ǿʹõĵ +// ضĿİļ + +#pragma once + +#ifndef _SECURE_ATL +#define _SECURE_ATL 1 +#endif + +#ifndef VC_EXTRALEAN +#define VC_EXTRALEAN // Windows ͷųʹõ +#endif + +#include "targetver.h" + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // ijЩ CString 캯ʽ + +// ر MFC ijЩɷĺԵľϢ +#define _AFX_ALL_WARNINGS +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers + +#include // MFC ͱ׼ +#include // MFC չ + + +#include // MFC Զ + +#include // MFC core and standard components +#include // MFC extensions +#include // MFC Automation classes +#include // MFC support for Internet Explorer 4 Common Controls +#ifdef _UNICODE +#if defined _M_IX86 +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") +#elif defined _M_X64 +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"") +#else +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") +#endif +#endif +#ifndef _AFX_NO_OLE_SUPPORT +#include // MFC Internet Explorer 4 ؼ֧ +#endif +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include // MFC Windows ؼ֧ +#endif // _AFX_NO_AFXCMN_SUPPORT +#include // Ϳؼ MFC ֧ +#include // MFC ׽չ +#include "resource.h" + + +//#define __LASER_DEVICE_INNOLAS__ //innolasLaser ̹⼤ +//#define __LASER_DEVICE_SPECTRA_PHYSICS__ // + +//Ŀƿ(ͬʱֻܴһ) +//#define __PROGRAM_XM_SA_NO1__ // (1Ż) +//#define __PROGRAM_HZ_SL_2__ //ʿŻ +//#define __PROGRAM_BJ_BDT_MANUAL__ //ֶ豸 +//#define __PROGRAM_CQ_WTS_MANUAL__ //ɭ +//#define __PROGRAM_SH_XJ_AUTO__ //ϺȽ(ле) +//#define __PROGRAM_SH_JT_AUTO__ //Ϻ(ле) + +//#define __PROGRAM_HZ_SL_GZ__ //ʿ(ле) +//#define __PROGRAM_WX_SH_AUTO__ //ϻ(ле) +//#define __PROGRAM_SIC__ //SIC ˻ +//#define __PROGRAM_ZZ_ZC__ //г(ле) +//#define __PROGRAM_CQ_44SUO_DEVICE_2__ //44 2Ż +#define __PROGRAM_WH_CC__ //人 + + +//__TEST__ //Ժ + + +//ú꿪 +#ifdef __PROGRAM_XM_SA_NO1__ +#define __LASER_DEVICE_PHOTONICS__ //PI +#define __USE_SUPER_DOG__ //Ƿʹüܹ +//#define __THIMBLE_DISC__ //Ƿж +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) +#define __MOTION_CTRL_ACS__ //ʹacs XYZ +#define __CHECK_GRATING_RULER__ //ƶǷդ +//#define __MOTION_CTRL_PCI1245__ //ʹл˶ƿXYZ + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ + +#endif + +#ifdef __PROGRAM_HZ_SL_2__ +#define __LASER_DEVICE_BEAMTECH__ //ر +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __CHECK_GRATING_RULER__ //ƶǷդ +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) +#define __MOTION_CTRL_PCI1245__ //ʹл˶ƿXYZ +#endif + +#ifdef __PROGRAM_BJ_BDT_MANUAL__ +#define __LASER_DEVICE_PHOTONICS__ //PI +//#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ龧Բ״̬ +#define __MOTION_CTRL_PCI1245__ //ʹл˶ƿXYZ +#endif + +#ifdef __PROGRAM_CQ_WTS_MANUAL__ +#define __LASER_DEVICE_BEAMTECH__ //ر +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __CHECK_GRATING_RULER__ //ƶǷդ +#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ +#define __MOTION_CTRL_PCI1245__ //ʹл˶ƿXYZ +#endif + +#ifdef __PROGRAM_SH_XJ_AUTO__//ϺȽ +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __THIMBLE_DISC__ //Ƿж + +//غ +//#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ +#define __MOTION_CTRL_ACS__ //ʹacs XYZ + +// +#define __LASER_DEVICE_PHOTONICS__ //PI +#define __LASER_PHOTONICS_TWO_PULSE__ //PI (˫) +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) +#define __TEK_OSCILLOSCOPE__ //TEKʾ +#define __RED_LASER_DEVICE_AMTRON__ //Amtron ⼤ +#define __TEMP_APP_XthermDemo__ //¶Ȳ + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ +//#define __JNG_SECS_OLD_DLL__ //ʹýϹϾɰ汾2020-08 ǰ +#endif + +#ifdef __PROGRAM_SH_JT_AUTO__//Ϻ +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __THIMBLE_DISC__ //Ƿж + +//غ +//#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ +#define __MOTION_CTRL_ACS__ //ʹacs XYZ + +// +#define __LASER_DEVICE_PHOTONICS__ //PI +#define __LASER_PHOTONICS_TWO_PULSE__ //PI (˫) +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) +#define __TEK_OSCILLOSCOPE__ //TEKʾ +#define __RED_LASER_DEVICE_AMTRON__ //Amtron ⼤ +//#define __TEMP_APP_LCNetTest__ //¶Ȳ + + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ +#endif + + +#ifdef __PROGRAM_WX_SH_AUTO__//ϻ +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __THIMBLE_DISC__ //Ƿж + +//غ +//#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ +#define __MOTION_CTRL_ACS__ //ʹacs XYZ + +// +#define __LASER_DEVICE_PHOTONICS__ //PI +#define __LASER_PHOTONICS_TWO_PULSE__ //PI (˫) +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) +//#define __TEK_OSCILLOSCOPE__ //TEKʾ +#define __RED_LASER_DEVICE_AMTRON__ //Amtron ⼤ + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ +#endif + + +#ifdef __PROGRAM_HZ_SL_GZ__//ʿ +#define __LASER_DEVICE_BEAMTECH__ //ر +#define __BEAMTECH_NEW_CTRL__ //رµĿЭ + +#define __RED_LASER_DEVICE_808__ //ʿ豸808 ⼤ +#define __THIMBLE_DISC__ //Ƿж + +//#define __PATH_POW_THORLABS_PM100D__ //·ʼʹThorlabs PM100D ʼ(ʹOphir ʼ) +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __CHECK_GRATING_RULER__ //ƶǷդ +//#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ +#define __MOTION_CTRL_PCI1245__ //ʹл˶ƿXYZ +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) + +#define __TRANSFER_ARM_DYH__ //պе(PC) + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ +#endif + +#ifdef __PROGRAM_ZZ_ZC__//г +//Open Cassette ˫ۻе +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __THIMBLE_DISC__ //Ƿж + +//غ +//#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ +#define __MOTION_CTRL_ACS__ //ʹacs XYZ + +// +#define __LASER_DEVICE_PHOTONICS__ //PI +#define __LASER_PHOTONICS_TWO_PULSE__ //PI (˫) +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) +#define __TEK_OSCILLOSCOPE__ //TEKʾ +#define __RED_LASER_DEVICE_AMTRON__ //Amtron ⼤ + +#define __TEMP_APP_LCNetTest__ //¶Ȳ + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ +#endif + + +#ifdef __PROGRAM_CQ_44SUO_DEVICE_2__//44 +//Open Cassette ˫ۻе +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __THIMBLE_DISC__ //Ƿж + +//غ +//#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ +#define __MOTION_CTRL_ACS__ //ʹacs XYZ + +// +#define __LASER_DEVICE_PHOTONICS__ //PI +#define __LASER_PHOTONICS_TWO_PULSE__ //PI (˫) +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) +#define __TEK_OSCILLOSCOPE__ //TEKʾ +#define __RED_LASER_DEVICE_AMTRON__ //Amtron ⼤ + +#define __TEMP_APP_LCNetTest__ //¶Ȳ + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ +#endif + + +#ifdef __PROGRAM_SIC__ //SIC ˻ +#define __LASER_DEVICE_BEAMTECH__ //ر +#define __BEAMTECH_NEW_CTRL__ //رµĿЭ + +#define __THIMBLE_DISC__ //Ƿж + +#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __CHECK_GRATING_RULER__ //ƶǷդ + +#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ + +#define __MOTION_CTRL_PCI1245__ //ʹл˶ƿXYZ +#define __CTRL_LASER_DIMMER_ //Ƽ˥(ܲãջٹ) + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ +#define __SCAN_BY_MIRROR__ //ʹ񾵵ɨ跽ʽ +#define __MIRROR_SCANLAB_RTC5__ //SCANLAB RTC5񾵿ƿ +#endif + +#ifdef __PROGRAM_WH_CC__ //人 +#define __PROGRAM_ZZ_ZC__ +//Open Cassette ˫ۻе +//#define __USE_SUPER_DOG__ //Ƿʹüܹ +#define __THIMBLE_DISC__ //Ƿж + +//غ +//#define __NO_CHECK_WAFER_SUCK_STATE__ //Ҫ +#define __MOTION_CTRL_ACS__ //ʹacs XYZ + +// +#define __LASER_DEVICE_PHOTONICS__ //PI +#define __TEK_OSCILLOSCOPE__ //TEKʾ + +#define __JNG_SEMI_SECS__ //ʹýϹϵsecs ؼ +#endif + + +#define __OFFSET_TABLE__ + + + + + + +extern bool gExitApp;//ǰǷ˳APP +extern bool gbFactoryMode;//ǰǷΪ豸άģʽ +extern bool gbSimpleParMode;//ģʽ(ģʾ) + diff --git a/LaipuDrawing/targetver.h b/LaipuDrawing/targetver.h new file mode 100644 index 0000000..0afac5b --- /dev/null +++ b/LaipuDrawing/targetver.h @@ -0,0 +1,8 @@ +#pragma once + +// SDKDDKVer.h ߰汾Ŀ Windows ƽ̨ + +// ҪΪǰ Windows ƽ̨Ӧó WinSDKVer.h +// WIN32_WINNT ΪҪֵ֧ƽ̨Ȼٰ SDKDDKVer.h + +#include diff --git a/LaipuDrawing/tbarcode51.cpp b/LaipuDrawing/tbarcode51.cpp new file mode 100644 index 0000000..357acd5 --- /dev/null +++ b/LaipuDrawing/tbarcode51.cpp @@ -0,0 +1,19 @@ +// Microsoft Visual C++ IDispatch װ + +// ע: Ҫ޸Ĵļݡ +// Microsoft Visual C++ ɣ޸Ľǡ + + +#include "stdafx.h" +#include "tbarcode51.h" + +///////////////////////////////////////////////////////////////////////////// +// CTbarcode51 + +IMPLEMENT_DYNCREATE(CTbarcode51, CWnd) + +///////////////////////////////////////////////////////////////////////////// +// CTbarcode51 + +///////////////////////////////////////////////////////////////////////////// +// CTbarcode51 diff --git a/LaipuDrawing/tbarcode51.h b/LaipuDrawing/tbarcode51.h new file mode 100644 index 0000000..45f65ca --- /dev/null +++ b/LaipuDrawing/tbarcode51.h @@ -0,0 +1,1367 @@ +#pragma once + +// Microsoft Visual C++ IDispatch װ + +// ע: Ҫ޸Ĵļݡ +// Microsoft Visual C++ ɣ޸Ľǡ + +///////////////////////////////////////////////////////////////////////////// +// CTbarcode51 װ + +class CTbarcode51 : public CWnd +{ +protected: + DECLARE_DYNCREATE(CTbarcode51) +public: + CLSID const& GetClsid() + { + static CLSID const clsid + = { 0x10ED9AE3, 0xDA1A, 0x461C, { 0x82, 0x6A, 0xCD, 0x9C, 0x85, 0xC, 0x58, 0xE2 } }; + return clsid; + } + virtual BOOL Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, + const RECT& rect, CWnd* pParentWnd, UINT nID, + CCreateContext* pContext = NULL) + { + return CreateControl(GetClsid(), lpszWindowName, dwStyle, rect, pParentWnd, nID); + } + + BOOL Create(LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, + UINT nID, CFile* pPersist = NULL, BOOL bStorage = FALSE, + BSTR bstrLicKey = NULL) + { + return CreateControl(GetClsid(), lpszWindowName, dwStyle, rect, pParentWnd, nID, + pPersist, bStorage, bstrLicKey); + } + +// +public: +enum +{ + BKS_Transparent = 0, + BKS_Opaque = 1 +}tagBKStyle; +enum +{ + eDST_Ok = 0, + eDST_Cancel = 1, + eDST_Retry = 2 +}tag_DrawStatus; +enum +{ + eInt_Default = 0, + eInt_ANSI = 1, + eInt_ByteStream = 2, + eInt_BYTE_HILO = 3, + eInt_Korean = 4, + eInt_Japanese_Shift_JIS = 5, + eInt_Simplified_Chinese = 6, + eInt_Trad_Chinese_Big5 = 7 +}tag_Interpretation; +enum +{ + eBC_None = 0, + eBC_Code11 = 1, + eBC_2OF5 = 2, + eBC_2OF5IL = 3, + eBC_2OF5IATA = 4, + eBC_2OF5M = 5, + eBC_2OF5DL = 6, + eBC_2OF5IND = 7, + eBC_3OF9 = 8, + eBC_3OF9A = 9, + eBC_EAN8 = 10, + eBC_EAN8P2 = 11, + eBC_EAN8P5 = 12, + eBC_EAN13 = 13, + eBC_EAN13P2 = 14, + eBC_EAN13P5 = 15, + eBC_EAN128 = 16, + eBC_UPC12 = 17, + eBC_CodaBar2 = 18, + eBC_CodaBar18 = 19, + eBC_Code128 = 20, + eBC_DPLeit = 21, + eBC_DPIdent = 22, + eBC_Code16K = 23, + eBC_49 = 24, + eBC_9OF3 = 25, + eBC_UPC25 = 26, + eBC_UPCD1 = 27, + eBC_Flattermarken = 28, + eBC_RSS14 = 29, + eBC_RSSLtd = 30, + eBC_RSSExp = 31, + eBC_UPCSCC = 32, + eBC_UCC128 = 33, + eBC_UPCA = 34, + eBC_UPCAP2 = 35, + eBC_UPCAP5 = 36, + eBC_UPCE = 37, + eBC_UPCEP2 = 38, + eBC_UPCEP5 = 39, + eBC_PostNet5 = 40, + eBC_PostNet6 = 41, + eBC_PostNet8 = 42, + eBC_PostNet10 = 43, + eBC_PostNet11 = 44, + eBC_PostNet12 = 45, + eBC_Plessey = 46, + eBC_MSI = 47, + eBC_SSCC18 = 48, + eBC_FIM = 49, + eBC_LOGMARS = 50, + eBC_Pharma1 = 51, + eBC_PZN = 52, + eBC_Pharma2 = 53, + eBC_GP = 54, + eBC_PDF417 = 55, + eBC_PDF417Trunc = 56, + eBC_MAXICODE = 57, + eBC_QRCode = 58, + eBC_Code128A = 59, + eBC_Code128B = 60, + eBC_Code128C = 61, + eBC_9OF3A = 62, + eBC_AusPostCustom = 63, + eBC_AusPostCustom2 = 64, + eBC_AusPostCustom3 = 65, + eBC_AusPostReplyPaid = 66, + eBC_AusPostRouting = 67, + eBC_AusPostRedirect = 68, + eBC_ISBN = 69, + eBC_RM4SCC = 70, + eBC_DataMatrix = 71, + eBC_EAN14 = 72, + eBC_CODABLOCK_E = 73, + eBC_CODABLOCK_F = 74, + eBC_NVE18 = 75 +}tag_BarCType; +enum +{ + eCDNone = 0, + eCDStandard = 1, + eCDMod10 = 2, + eCDMod43 = 3, + eCD2Mod47 = 4, + eCDDPLeit = 5, + eCDDPIdent = 6, + eCD1Code11 = 7, + eCD2Code11 = 8, + eCDPostnet = 9, + eCDMSI1 = 10, + eCDMSI2 = 11, + eCDPlessey = 12, + eCDEAN8 = 13, + eCDEAN13 = 14, + eCDUPCA = 15, + eCDUPCE = 16, + eCDEAN128 = 17, + eCDCode128 = 18, + eCDRM4SCC = 19, + eCDPZN = 20, + eCDMod11W7 = 21, + eCDEAN14 = 22 +}tag_CDMethod; +enum +{ + deg0 = 0, + deg90 = 1, + deg180 = 2, + deg270 = 3 +}tag_Degree; +enum +{ + eMUDefault = 0, + eMUPixel = 1, + eMUMM = 2 +}tag_MUnit; +enum +{ + eQZMUNone = 0, + eQZMUModules = 1, + eQZMUMM = 2, + eQZMUMils = 3, + eQZMUPixel = 4 +}tag_QZMUnit; +enum +{ + eIMBmp = 0, + eIMEmf = 1, + eIMEps = 2, + eIMGif = 3, + eIMJpg = 4, + eIMPcx = 5, + eIMPng = 6, + eIMTif = 7, + eIMPsVector = 8 +}tag_ImageType; +enum +{ + eAlDefault = 0, + eAlLeft = 1, + eAlRight = 2, + eAlCenter = 3 +}tag_Align; +enum +{ + eLicInvalid = -1, + eLicProd1D = 13, + eLicProd2D = 14 +}tag_licProduct; +enum +{ + eLicKindSingle = 1, + eLicKindSite = 2, + eLicKindDeveloper = 3 +}tag_licKind; +enum +{ + eDMSz_Default = 0, + eDMSz_10x10 = 1, + eDMSz_12x12 = 2, + eDMSz_14x14 = 3, + eDMSz_16x16 = 4, + eDMSz_18x18 = 5, + eDMSz_20x20 = 6, + eDMSz_22x22 = 7, + eDMSz_24x24 = 8, + eDMSz_26x26 = 9, + eDMSz_32x32 = 10, + eDMSz_36x36 = 11, + eDMSz_40x40 = 12, + eDMSz_44x44 = 13, + eDMSz_48x48 = 14, + eDMSz_52x52 = 15, + eDMSz_64x64 = 16, + eDMSz_72x72 = 17, + eDMSz_80x80 = 18, + eDMSz_88x88 = 19, + eDMSz_96x96 = 20, + eDMSz_104x104 = 21, + eDMSz_120x120 = 22, + eDMSz_132x132 = 23, + eDMSz_144x144 = 24, + eDMSz_8x18 = 25, + eDMSz_8x32 = 26, + eDMSz_12x26 = 27, + eDMSz_12x36 = 28, + eDMSz_16x36 = 29, + eDMSz_16x48 = 30 +}tagE_DMSizes; +enum +{ + eDMPr_Default = 0, + eDMPr_UCCEAN = 1, + eDMPr_Industry = 2, + eDMPr_Macro05 = 3, + eDMPr_Macro06 = 4 +}tagE_DMFormat; +enum +{ + eQRVers_Default = 0, + eQRVers_1 = 1, + eQRVers_2 = 2, + eQRVers_3 = 3, + eQRVers_4 = 4, + eQRVers_5 = 5, + eQRVers_6 = 6, + eQRVers_7 = 7, + eQRVers_8 = 8, + eQRVers_9 = 9, + eQRVers_10 = 10, + eQRVers_11 = 11, + eQRVers_12 = 12, + eQRVers_13 = 13, + eQRVers_14 = 14, + eQRVers_15 = 15, + eQRVers_16 = 16, + eQRVers_17 = 17, + eQRVers_18 = 18, + eQRVers_19 = 19, + eQRVers_20 = 20, + eQRVers_21 = 21, + eQRVers_22 = 22, + eQRVers_23 = 23, + eQRVers_24 = 24, + eQRVers_25 = 25, + eQRVers_26 = 26, + eQRVers_27 = 27, + eQRVers_28 = 28, + eQRVers_29 = 29, + eQRVers_30 = 30, + eQRVers_31 = 31, + eQRVers_32 = 32, + eQRVers_33 = 33, + eQRVers_34 = 34, + eQRVers_35 = 35, + eQRVers_36 = 36, + eQRVers_37 = 37, + eQRVers_38 = 38, + eQRVers_39 = 39, + eQRVers_40 = 40 +}tagE_QRVersion; +enum +{ + eQRPr_Default = 0, + eQRPr_UCCEAN = 1, + eQRPr_Industry = 2 +}tagE_QRFormat; +enum +{ + eQREC_Low = 0, + eQREC_Medium = 1, + eQREC_Quartil = 2, + eQREC_High = 3 +}tagE_QRECLevel; +enum +{ + eQRMsk_Default = -1, + eQRMsk_0 = 0, + eQRMsk_1 = 1, + eQRMsk_2 = 2, + eQRMsk_3 = 3, + eQRMsk_4 = 4, + eQRMsk_5 = 5, + eQRMsk_6 = 6, + eQRMsk_7 = 7 +}tagE_QRMask; +enum +{ + eCBFPr_Default = 0, + eCBFPr_UCCEAN = 1 +}tagE_CBFFormat; + + +// +public: + +// _ITBarCode + +// Functions +// + + void put_BackColor(unsigned long newValue) + { + static BYTE parms[] = VTS_UI4 ; + InvokeHelper(DISPID_BACKCOLOR, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + void put_BackStyle(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(DISPID_BACKSTYLE, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + void putref_Font(LPDISPATCH newValue) + { + static BYTE parms[] = VTS_DISPATCH ; + InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms, newValue); + } + void put_Font(LPDISPATCH newValue) + { + static BYTE parms[] = VTS_DISPATCH ; + InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + void put_ForeColor(unsigned long newValue) + { + static BYTE parms[] = VTS_UI4 ; + InvokeHelper(DISPID_FORECOLOR, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + void put_Enabled(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(DISPID_ENABLED, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + void put_Text(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(DISPID_TEXT, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + unsigned long get_BackColor() + { + unsigned long result; + InvokeHelper(DISPID_BACKCOLOR, DISPATCH_PROPERTYGET, VT_UI4, (void*)&result, NULL); + return result; + } + long get_BackStyle() + { + long result; + InvokeHelper(DISPID_BACKSTYLE, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + LPDISPATCH get_Font() + { + LPDISPATCH result; + InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL); + return result; + } + unsigned long get_ForeColor() + { + unsigned long result; + InvokeHelper(DISPID_FORECOLOR, DISPATCH_PROPERTYGET, VT_UI4, (void*)&result, NULL); + return result; + } + BOOL get_Enabled() + { + BOOL result; + InvokeHelper(DISPID_ENABLED, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + long get_Window() + { + long result; + InvokeHelper(DISPID_HWND, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + CString get_Text() + { + CString result; + InvokeHelper(DISPID_TEXT, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void AboutBox() + { + InvokeHelper(DISPID_ABOUTBOX, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); + } + void Refresh() + { + InvokeHelper(DISPID_REFRESH, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); + } + void BCDraw(long hDC, long nLeft, long nTop, long nWidth, long nHeight) + { + static BYTE parms[] = VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms, hDC, nLeft, nTop, nWidth, nHeight); + } + void LicenseMe(LPCTSTR sLicensee, long eKind, long nLicenses, LPCTSTR sLicenseKey, long eProductID) + { + static BYTE parms[] = VTS_BSTR VTS_I4 VTS_I4 VTS_BSTR VTS_I4 ; + InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms, sLicensee, eKind, nLicenses, sLicenseKey, eProductID); + } + void CopyToClipboard() + { + InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); + } + void CopyToClipboardEx(long hDC, long nWidth, long nHeight, LPCTSTR sFileName) + { + static BYTE parms[] = VTS_I4 VTS_I4 VTS_I4 VTS_BSTR ; + InvokeHelper(0x33, DISPATCH_METHOD, VT_EMPTY, NULL, parms, hDC, nWidth, nHeight, sFileName); + } + void SaveImage(LPCTSTR sFileName, long eImageType, long nXSize, long nYSize, long nXRes, long nYRes) + { + static BYTE parms[] = VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms, sFileName, eImageType, nXSize, nYSize, nXRes, nYRes); + } + void SaveImageEx(long hDC, LPCTSTR sFileName, long eImageType, long nQuality, long nXSize, long nYSize, long nXRes, long nYRes) + { + static BYTE parms[] = VTS_I4 VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x31, DISPATCH_METHOD, VT_EMPTY, NULL, parms, hDC, sFileName, eImageType, nQuality, nXSize, nYSize, nXRes, nYRes); + } + void Licencing() + { + InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); + } + VARIANT ConvertToStream(long eImageType, long nXSize, long nYSize, long nXRes, long nYRes) + { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x27, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, eImageType, nXSize, nYSize, nXRes, nYRes); + return result; + } + VARIANT ConvertToStreamEx(long hDC, long eImageType, long nQuality, long nXSize, long nYSize, long nXRes, long nYRes) + { + VARIANT result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x32, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, hDC, eImageType, nQuality, nXSize, nYSize, nXRes, nYRes); + return result; + } + long get_BarCode() + { + long result; + InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_BarCode(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_CDMethod() + { + long result; + InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_CDMethod(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_CountCheckDigits() + { + long result; + InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_CountCheckDigits(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + BOOL get_EscapeSequences() + { + BOOL result; + InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_EscapeSequences(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_Format() + { + CString result; + InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_Format(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_GuardWidth() + { + long result; + InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_GuardWidth(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_LastError() + { + CString result; + InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_LastError(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_LastErrorNo() + { + long result; + InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_LastErrorNo(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_ModulWidth() + { + CString result; + InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_ModulWidth(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_Orientation() + { + long result; + InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_Orientation(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + BOOL get_PrintDataText() + { + BOOL result; + InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_PrintDataText(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + BOOL get_PrintTextAbove() + { + BOOL result; + InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_PrintTextAbove(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_Ratio() + { + CString result; + InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_Ratio(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_RatioHint() + { + CString result; + InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_RatioHint(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + unsigned long get_TextColor() + { + unsigned long result; + InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_UI4, (void*)&result, NULL); + return result; + } + void put_TextColor(unsigned long newValue) + { + static BYTE parms[] = VTS_UI4 ; + InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_Columns() + { + long result; + InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_Columns(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_Rows() + { + long result; + InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_Rows(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_ECLevel() + { + long result; + InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_ECLevel(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_RowHeight() + { + long result; + InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_RowHeight(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + BOOL get_MustFit() + { + BOOL result; + InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_MustFit(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_TextDistance() + { + long result; + InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_TextDistance(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_NotchHeight() + { + long result; + InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_NotchHeight(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_RatioDefault() + { + CString result; + InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_RatioDefault(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_CheckDigits() + { + CString result; + InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_CheckDigits(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_MAXI_Mode() + { + long result; + InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_MAXI_Mode(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_MAXI_AppendIndex() + { + long result; + InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_MAXI_AppendIndex(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_MAXI_AppendCount() + { + long result; + InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_MAXI_AppendCount(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_MAXI_Undercut() + { + long result; + InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_MAXI_Undercut(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + double get_CountModules() + { + double result; + InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; + } + void put_CountModules(double newValue) + { + static BYTE parms[] = VTS_R8 ; + InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + double get_BCWidthAct(long eUnit) + { + double result; + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms, eUnit); + return result; + } + double get_BCHeightAct(long eUnit) + { + double result; + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms, eUnit); + return result; + } + double get_ModWidthAct(long eUnit) + { + double result; + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms, eUnit); + return result; + } + double get_BCWidthHdc(long hDC, long nWidth, long nHeight, long eUnit) + { + double result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms, hDC, nWidth, nHeight, eUnit); + return result; + } + double get_BCHeightHdc(long hDC, long nWidth, long nHeight, long eUnit) + { + double result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms, hDC, nWidth, nHeight, eUnit); + return result; + } + double get_ModWidthHdc(long hDC, long nWidth, long nHeight, long eUnit) + { + double result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms, hDC, nWidth, nHeight, eUnit); + return result; + } + BOOL get_MAXI_Preamble() + { + BOOL result; + InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_MAXI_Preamble(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_MAXI_PostalCode() + { + CString result; + InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_MAXI_PostalCode(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_MAXI_CountryCode() + { + CString result; + InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_MAXI_CountryCode(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_MAXI_ServiceClass() + { + CString result; + InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_MAXI_ServiceClass(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_MAXI_Date() + { + CString result; + InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_MAXI_Date(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_DrawStatus() + { + long result; + InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_DrawStatus(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x2f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + BOOL get_SuppressErrorMsg() + { + BOOL result; + InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_SuppressErrorMsg(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0x30, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + double get_CountRows() + { + double result; + InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL); + return result; + } + void put_CountRows(double newValue) + { + static BYTE parms[] = VTS_R8 ; + InvokeHelper(0x50, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_DM_Size() + { + long result; + InvokeHelper(0x51, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_DM_Size(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x51, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + BOOL get_DM_Rectangular() + { + BOOL result; + InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_DM_Rectangular(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0x52, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_DM_Format() + { + long result; + InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_DM_Format(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x53, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_DM_AppendIndex() + { + long result; + InvokeHelper(0x54, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_DM_AppendIndex(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x54, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_DM_AppendCount() + { + long result; + InvokeHelper(0x55, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_DM_AppendCount(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x55, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_DM_AppendFileID() + { + long result; + InvokeHelper(0x56, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_DM_AppendFileID(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x56, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_SegmentIndex() + { + long result; + InvokeHelper(0x57, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_SegmentIndex(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x57, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_PDF417_FileID() + { + CString result; + InvokeHelper(0x58, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_PDF417_FileID(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x58, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + BOOL get_PDF417_LastSegment() + { + BOOL result; + InvokeHelper(0x59, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_PDF417_LastSegment(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0x59, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_PDF417_FileName() + { + CString result; + InvokeHelper(0x5a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_PDF417_FileName(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x5a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_SegmentCount() + { + long result; + InvokeHelper(0x5b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_SegmentCount(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x5b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_TimeStamp() + { + long result; + InvokeHelper(0x5c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_TimeStamp(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x5c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_PDF417_Sender() + { + CString result; + InvokeHelper(0x5d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_PDF417_Sender(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x5d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_PDF417_Addressee() + { + CString result; + InvokeHelper(0x5e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_PDF417_Addressee(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x5e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_FileSize() + { + long result; + InvokeHelper(0x5f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_FileSize(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x5f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_PDF417_CheckSum() + { + long result; + InvokeHelper(0x60, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_PDF417_CheckSum(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x60, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_QR_Version() + { + long result; + InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_QR_Version(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_QR_Format() + { + long result; + InvokeHelper(0x62, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_QR_Format(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x62, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_QR_ECLevel() + { + long result; + InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_QR_ECLevel(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_QR_Mask() + { + long result; + InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_QR_Mask(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_QR_AppendIndex() + { + long result; + InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_QR_AppendIndex(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_QR_AppendCount() + { + long result; + InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_QR_AppendCount(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + short get_QR_AppendParity() + { + short result; + InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL); + return result; + } + void put_QR_AppendParity(short newValue) + { + static BYTE parms[] = VTS_I2 ; + InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_QR_FmtAppIndicator() + { + CString result; + InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_QR_FmtAppIndicator(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + short get_QR_StructAppParity(LPCTSTR sText) + { + short result; + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, parms, sText); + return result; + } + CString get_PDF417_RatioRowCol() + { + CString result; + InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_PDF417_RatioRowCol(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_InterpretInputAs() + { + long result; + InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_InterpretInputAs(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + BOOL get_OptResolution() + { + BOOL result; + InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL); + return result; + } + void put_OptResolution(BOOL newValue) + { + static BYTE parms[] = VTS_BOOL ; + InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_FontName() + { + CString result; + InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_FontName(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_FontSize() + { + long result; + InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_FontSize(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_CBF_Rows() + { + long result; + InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_CBF_Rows(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_CBF_Columns() + { + long result; + InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_CBF_Columns(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_CBF_RowHeight() + { + long result; + InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_CBF_RowHeight(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_CBF_RowSeparatorHeight() + { + long result; + InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_CBF_RowSeparatorHeight(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_CBF_Format() + { + long result; + InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_CBF_Format(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + CString get_DisplayText() + { + CString result; + InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL); + return result; + } + void put_DisplayText(LPCTSTR newValue) + { + static BYTE parms[] = VTS_BSTR ; + InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_BarWidthReduction() + { + long result; + InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_BarWidthReduction(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_TextAlignment() + { + long result; + InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_TextAlignment(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_Quality() + { + long result; + InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL); + return result; + } + void put_Quality(long newValue) + { + static BYTE parms[] = VTS_I4 ; + InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms, newValue); + } + long get_QualityHdc(long hDC, long nWidth, long nHeight) + { + long result; + static BYTE parms[] = VTS_I4 VTS_I4 VTS_I4 ; + InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms, hDC, nWidth, nHeight); + return result; + } + void PropertyDialog() + { + InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL); + } + +// Properties +// + + + +}; diff --git a/LaipuDrawing/tinystr.cpp b/LaipuDrawing/tinystr.cpp new file mode 100644 index 0000000..08ae16f --- /dev/null +++ b/LaipuDrawing/tinystr.cpp @@ -0,0 +1,113 @@ +/* +www.sourceforge.net/projects/tinyxml + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +#include "StdAfx.h" + +#ifndef TIXML_USE_STL + + +#include "tinystr.h" + +// Error value for find primitive +const TiXmlString::size_type TiXmlString::npos = static_cast< TiXmlString::size_type >(-1); + + +// Null rep. +TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } }; + + +void TiXmlString::reserve (size_type cap) +{ + if (cap > capacity()) + { + TiXmlString tmp; + tmp.init(length(), cap); + memcpy(tmp.start(), data(), length()); + swap(tmp); + } +} + + +TiXmlString& TiXmlString::assign(const char* str, size_type len) +{ + size_type cap = capacity(); + if (len > cap || cap > 3*(len + 8)) + { + TiXmlString tmp; + tmp.init(len); + memcpy(tmp.start(), str, len); + swap(tmp); + } + else + { + memmove(start(), str, len); + set_size(len); + } + return *this; +} + + +TiXmlString& TiXmlString::append(const char* str, size_type len) +{ + size_type newsize = length() + len; + if (newsize > capacity()) + { + reserve (newsize + capacity()); + } + memmove(finish(), str, len); + set_size(newsize); + return *this; +} + + +TiXmlString operator + (const TiXmlString & a, const TiXmlString & b) +{ + TiXmlString tmp; + tmp.reserve(a.length() + b.length()); + tmp += a; + tmp += b; + return tmp; +} + +TiXmlString operator + (const TiXmlString & a, const char* b) +{ + TiXmlString tmp; + TiXmlString::size_type b_len = static_cast( strlen(b) ); + tmp.reserve(a.length() + b_len); + tmp += a; + tmp.append(b, b_len); + return tmp; +} + +TiXmlString operator + (const char* a, const TiXmlString & b) +{ + TiXmlString tmp; + TiXmlString::size_type a_len = static_cast( strlen(a) ); + tmp.reserve(a_len + b.length()); + tmp.append(a, a_len); + tmp += b; + return tmp; +} + + +#endif // TIXML_USE_STL diff --git a/LaipuDrawing/tinystr.h b/LaipuDrawing/tinystr.h new file mode 100644 index 0000000..89cca33 --- /dev/null +++ b/LaipuDrawing/tinystr.h @@ -0,0 +1,305 @@ +/* +www.sourceforge.net/projects/tinyxml + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + + +#ifndef TIXML_USE_STL + +#ifndef TIXML_STRING_INCLUDED +#define TIXML_STRING_INCLUDED + +#include +#include + +/* The support for explicit isn't that universal, and it isn't really + required - it is used to check that the TiXmlString class isn't incorrectly + used. Be nice to old compilers and macro it here: +*/ +#if defined(_MSC_VER) && (_MSC_VER >= 1200 ) + // Microsoft visual studio, version 6 and higher. + #define TIXML_EXPLICIT explicit +#elif defined(__GNUC__) && (__GNUC__ >= 3 ) + // GCC version 3 and higher.s + #define TIXML_EXPLICIT explicit +#else + #define TIXML_EXPLICIT +#endif + + +/* + TiXmlString is an emulation of a subset of the std::string template. + Its purpose is to allow compiling TinyXML on compilers with no or poor STL support. + Only the member functions relevant to the TinyXML project have been implemented. + The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase + a string and there's no more room, we allocate a buffer twice as big as we need. +*/ +class TiXmlString +{ + public : + // The size type used + typedef size_t size_type; + + // Error value for find primitive + static const size_type npos; // = -1; + + + // TiXmlString empty constructor + TiXmlString () : rep_(&nullrep_) + { + } + + // TiXmlString copy constructor + TiXmlString ( const TiXmlString & copy) : rep_(0) + { + init(copy.length()); + memcpy(start(), copy.data(), length()); + } + + // TiXmlString constructor, based on a string + TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0) + { + init( static_cast( strlen(copy) )); + memcpy(start(), copy, length()); + } + + // TiXmlString constructor, based on a string + TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0) + { + init(len); + memcpy(start(), str, len); + } + + // TiXmlString destructor + ~TiXmlString () + { + quit(); + } + + TiXmlString& operator = (const char * copy) + { + return assign( copy, (size_type)strlen(copy)); + } + + TiXmlString& operator = (const TiXmlString & copy) + { + return assign(copy.start(), copy.length()); + } + + + // += operator. Maps to append + TiXmlString& operator += (const char * suffix) + { + return append(suffix, static_cast( strlen(suffix) )); + } + + // += operator. Maps to append + TiXmlString& operator += (char single) + { + return append(&single, 1); + } + + // += operator. Maps to append + TiXmlString& operator += (const TiXmlString & suffix) + { + return append(suffix.data(), suffix.length()); + } + + + // Convert a TiXmlString into a null-terminated char * + const char * c_str () const { return rep_->str; } + + // Convert a TiXmlString into a char * (need not be null terminated). + const char * data () const { return rep_->str; } + + // Return the length of a TiXmlString + size_type length () const { return rep_->size; } + + // Alias for length() + size_type size () const { return rep_->size; } + + // Checks if a TiXmlString is empty + bool empty () const { return rep_->size == 0; } + + // Return capacity of string + size_type capacity () const { return rep_->capacity; } + + + // single char extraction + const char& at (size_type index) const + { + assert( index < length() ); + return rep_->str[ index ]; + } + + // [] operator + char& operator [] (size_type index) const + { + assert( index < length() ); + return rep_->str[ index ]; + } + + // find a char in a string. Return TiXmlString::npos if not found + size_type find (char lookup) const + { + return find(lookup, 0); + } + + // find a char in a string from an offset. Return TiXmlString::npos if not found + size_type find (char tofind, size_type offset) const + { + if (offset >= length()) return npos; + + for (const char* p = c_str() + offset; *p != '\0'; ++p) + { + if (*p == tofind) return static_cast< size_type >( p - c_str() ); + } + return npos; + } + + void clear () + { + //Lee: + //The original was just too strange, though correct: + // TiXmlString().swap(*this); + //Instead use the quit & re-init: + quit(); + init(0,0); + } + + /* Function to reserve a big amount of data when we know we'll need it. Be aware that this + function DOES NOT clear the content of the TiXmlString if any exists. + */ + void reserve (size_type cap); + + TiXmlString& assign (const char* str, size_type len); + + TiXmlString& append (const char* str, size_type len); + + void swap (TiXmlString& other) + { + Rep* r = rep_; + rep_ = other.rep_; + other.rep_ = r; + } + + private: + + void init(size_type sz) { init(sz, sz); } + void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; } + char* start() const { return rep_->str; } + char* finish() const { return rep_->str + rep_->size; } + + struct Rep + { + size_type size, capacity; + char str[1]; + }; + + void init(size_type sz, size_type cap) + { + if (cap) + { + // Lee: the original form: + // rep_ = static_cast(operator new(sizeof(Rep) + cap)); + // doesn't work in some cases of new being overloaded. Switching + // to the normal allocation, although use an 'int' for systems + // that are overly picky about structure alignment. + const size_type bytesNeeded = sizeof(Rep) + cap; + const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); + rep_ = reinterpret_cast( new int[ intsNeeded ] ); + + rep_->str[ rep_->size = sz ] = '\0'; + rep_->capacity = cap; + } + else + { + rep_ = &nullrep_; + } + } + + void quit() + { + if (rep_ != &nullrep_) + { + // The rep_ is really an array of ints. (see the allocator, above). + // Cast it back before delete, so the compiler won't incorrectly call destructors. + delete [] ( reinterpret_cast( rep_ ) ); + } + } + + Rep * rep_; + static Rep nullrep_; + +} ; + + +inline bool operator == (const TiXmlString & a, const TiXmlString & b) +{ + return ( a.length() == b.length() ) // optimization on some platforms + && ( strcmp(a.c_str(), b.c_str()) == 0 ); // actual compare +} +inline bool operator < (const TiXmlString & a, const TiXmlString & b) +{ + return strcmp(a.c_str(), b.c_str()) < 0; +} + +inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); } +inline bool operator > (const TiXmlString & a, const TiXmlString & b) { return b < a; } +inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); } +inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); } + +inline bool operator == (const TiXmlString & a, const char* b) { return strcmp(a.c_str(), b) == 0; } +inline bool operator == (const char* a, const TiXmlString & b) { return b == a; } +inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); } +inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); } + +TiXmlString operator + (const TiXmlString & a, const TiXmlString & b); +TiXmlString operator + (const TiXmlString & a, const char* b); +TiXmlString operator + (const char* a, const TiXmlString & b); + + +/* + TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString. + Only the operators that we need for TinyXML have been developped. +*/ +class TiXmlOutStream : public TiXmlString +{ +public : + + // TiXmlOutStream << operator. + TiXmlOutStream & operator << (const TiXmlString & in) + { + *this += in; + return *this; + } + + // TiXmlOutStream << operator. + TiXmlOutStream & operator << (const char * in) + { + *this += in; + return *this; + } + +} ; + +#endif // TIXML_STRING_INCLUDED +#endif // TIXML_USE_STL diff --git a/LaipuDrawing/tinyxml.cpp b/LaipuDrawing/tinyxml.cpp new file mode 100644 index 0000000..3134363 --- /dev/null +++ b/LaipuDrawing/tinyxml.cpp @@ -0,0 +1,1887 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code by Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ +#include "StdAfx.h" + +#include + +#ifdef TIXML_USE_STL +#include +#include +#endif + +#include "tinyxml.h" + +FILE* TiXmlFOpen( const char* filename, const char* mode ); + +bool TiXmlBase::condenseWhiteSpace = true; + +// Microsoft compiler security +FILE* TiXmlFOpen( const char* filename, const char* mode ) +{ + #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) + FILE* fp = 0; + errno_t err = fopen_s( &fp, filename, mode ); + if ( !err && fp ) + return fp; + return 0; + #else + return fopen( filename, mode ); + #endif +} + +void TiXmlBase::EncodeString( const TIXML_STRING& str, TIXML_STRING* outString ) +{ + int i=0; + + while( i<(int)str.length() ) + { + unsigned char c = (unsigned char) str[i]; + + if ( c == '&' + && i < ( (int)str.length() - 2 ) + && str[i+1] == '#' + && str[i+2] == 'x' ) + { + // Hexadecimal character reference. + // Pass through unchanged. + // © -- copyright symbol, for example. + // + // The -1 is a bug fix from Rob Laveaux. It keeps + // an overflow from happening if there is no ';'. + // There are actually 2 ways to exit this loop - + // while fails (error case) and break (semicolon found). + // However, there is no mechanism (currently) for + // this function to return an error. + while ( i<(int)str.length()-1 ) + { + outString->append( str.c_str() + i, 1 ); + ++i; + if ( str[i] == ';' ) + break; + } + } + else if ( c == '&' ) + { + outString->append( entity[0].str, entity[0].strLength ); + ++i; + } + else if ( c == '<' ) + { + outString->append( entity[1].str, entity[1].strLength ); + ++i; + } + else if ( c == '>' ) + { + outString->append( entity[2].str, entity[2].strLength ); + ++i; + } + else if ( c == '\"' ) + { + outString->append( entity[3].str, entity[3].strLength ); + ++i; + } + else if ( c == '\'' ) + { + outString->append( entity[4].str, entity[4].strLength ); + ++i; + } + else if ( c < 32 ) + { + // Easy pass at non-alpha/numeric/symbol + // Below 32 is symbolic. + char buf[ 32 ]; + + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF( buf, sizeof(buf), "&#x%02X;", (unsigned) ( c & 0xff ) ); + #else + sprintf( buf, "&#x%02X;", (unsigned) ( c & 0xff ) ); + #endif + + //*ME: warning C4267: convert 'size_t' to 'int' + //*ME: Int-Cast to make compiler happy ... + outString->append( buf, (int)strlen( buf ) ); + ++i; + } + else + { + //char realc = (char) c; + //outString->append( &realc, 1 ); + *outString += (char) c; // somewhat more efficient function call. + ++i; + } + } +} + + +TiXmlNode::TiXmlNode( NodeType _type ) : TiXmlBase() +{ + parent = 0; + type = _type; + firstChild = 0; + lastChild = 0; + prev = 0; + next = 0; +} + + +TiXmlNode::~TiXmlNode() +{ + TiXmlNode* node = firstChild; + TiXmlNode* temp = 0; + + while ( node ) + { + temp = node; + node = node->next; + delete temp; + } +} + + +void TiXmlNode::CopyTo( TiXmlNode* target ) const +{ + target->SetValue (value.c_str() ); + target->userData = userData; + target->location = location; +} + + +void TiXmlNode::Clear() +{ + TiXmlNode* node = firstChild; + TiXmlNode* temp = 0; + + while ( node ) + { + temp = node; + node = node->next; + delete temp; + } + + firstChild = 0; + lastChild = 0; +} + + +TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node ) +{ + assert( node->parent == 0 || node->parent == this ); + assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() ); + + if ( node->Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + delete node; + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + node->parent = this; + + node->prev = lastChild; + node->next = 0; + + if ( lastChild ) + lastChild->next = node; + else + firstChild = node; // it was an empty list. + + lastChild = node; + return node; +} + + +TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis ) +{ + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + + return LinkEndChild( node ); +} + + +TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis ) +{ + if ( !beforeThis || beforeThis->parent != this ) { + return 0; + } + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + node->parent = this; + + node->next = beforeThis; + node->prev = beforeThis->prev; + if ( beforeThis->prev ) + { + beforeThis->prev->next = node; + } + else + { + assert( firstChild == beforeThis ); + firstChild = node; + } + beforeThis->prev = node; + return node; +} + + +TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis ) +{ + if ( !afterThis || afterThis->parent != this ) { + return 0; + } + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + node->parent = this; + + node->prev = afterThis; + node->next = afterThis->next; + if ( afterThis->next ) + { + afterThis->next->prev = node; + } + else + { + assert( lastChild == afterThis ); + lastChild = node; + } + afterThis->next = node; + return node; +} + + +TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis ) +{ + if ( !replaceThis ) + return 0; + + if ( replaceThis->parent != this ) + return 0; + + if ( withThis.ToDocument() ) { + // A document can never be a child. Thanks to Noam. + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = withThis.Clone(); + if ( !node ) + return 0; + + node->next = replaceThis->next; + node->prev = replaceThis->prev; + + if ( replaceThis->next ) + replaceThis->next->prev = node; + else + lastChild = node; + + if ( replaceThis->prev ) + replaceThis->prev->next = node; + else + firstChild = node; + + delete replaceThis; + node->parent = this; + return node; +} + + +bool TiXmlNode::RemoveChild( TiXmlNode* removeThis ) +{ + if ( !removeThis ) { + return false; + } + + if ( removeThis->parent != this ) + { + assert( 0 ); + return false; + } + + if ( removeThis->next ) + removeThis->next->prev = removeThis->prev; + else + lastChild = removeThis->prev; + + if ( removeThis->prev ) + removeThis->prev->next = removeThis->next; + else + firstChild = removeThis->next; + + delete removeThis; + return true; +} + +const TiXmlNode* TiXmlNode::FirstChild( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = firstChild; node; node = node->next ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = lastChild; node; node = node->prev ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const +{ + if ( !previous ) + { + return FirstChild(); + } + else + { + assert( previous->parent == this ); + return previous->NextSibling(); + } +} + + +const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const +{ + if ( !previous ) + { + return FirstChild( val ); + } + else + { + assert( previous->parent == this ); + return previous->NextSibling( val ); + } +} + + +const TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = next; node; node = node->next ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = prev; node; node = node->prev ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +void TiXmlElement::RemoveAttribute( const char * name ) +{ + #ifdef TIXML_USE_STL + TIXML_STRING str( name ); + TiXmlAttribute* node = attributeSet.Find( str ); + #else + TiXmlAttribute* node = attributeSet.Find( name ); + #endif + if ( node ) + { + attributeSet.Remove( node ); + delete node; + } +} + +const TiXmlElement* TiXmlNode::FirstChildElement() const +{ + const TiXmlNode* node; + + for ( node = FirstChild(); + node; + node = node->NextSibling() ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const +{ + const TiXmlNode* node; + + for ( node = FirstChild( _value ); + node; + node = node->NextSibling( _value ) ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::NextSiblingElement() const +{ + const TiXmlNode* node; + + for ( node = NextSibling(); + node; + node = node->NextSibling() ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const +{ + const TiXmlNode* node; + + for ( node = NextSibling( _value ); + node; + node = node->NextSibling( _value ) ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlDocument* TiXmlNode::GetDocument() const +{ + const TiXmlNode* node; + + for( node = this; node; node = node->parent ) + { + if ( node->ToDocument() ) + return node->ToDocument(); + } + return 0; +} + + +TiXmlElement::TiXmlElement (const char * _value) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + value = _value; +} + + +#ifdef TIXML_USE_STL +TiXmlElement::TiXmlElement( const std::string& _value ) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + value = _value; +} +#endif + + +TiXmlElement::TiXmlElement( const TiXmlElement& copy) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + copy.CopyTo( this ); +} + + +TiXmlElement& TiXmlElement::operator=( const TiXmlElement& base ) +{ + ClearThis(); + base.CopyTo( this ); + return *this; +} + + +TiXmlElement::~TiXmlElement() +{ + ClearThis(); +} + + +void TiXmlElement::ClearThis() +{ + Clear(); + while( attributeSet.First() ) + { + TiXmlAttribute* node = attributeSet.First(); + attributeSet.Remove( node ); + delete node; + } +} + + +const char* TiXmlElement::Attribute( const char* name ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( node ) + return node->Value(); + return 0; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( attrib ) + return &attrib->ValueStr(); + return 0; +} +#endif + + +const char* TiXmlElement::Attribute( const char* name, int* i ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const char* result = 0; + + if ( attrib ) { + result = attrib->Value(); + if ( i ) { + attrib->QueryIntValue( i ); + } + } + return result; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name, int* i ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const std::string* result = 0; + + if ( attrib ) { + result = &attrib->ValueStr(); + if ( i ) { + attrib->QueryIntValue( i ); + } + } + return result; +} +#endif + + +const char* TiXmlElement::Attribute( const char* name, double* d ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const char* result = 0; + + if ( attrib ) { + result = attrib->Value(); + if ( d ) { + attrib->QueryDoubleValue( d ); + } + } + return result; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name, double* d ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const std::string* result = 0; + + if ( attrib ) { + result = &attrib->ValueStr(); + if ( d ) { + attrib->QueryDoubleValue( d ); + } + } + return result; +} +#endif + + +int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryIntValue( ival ); +} + + +int TiXmlElement::QueryUnsignedAttribute( const char* name, unsigned* value ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( !node ) + return TIXML_NO_ATTRIBUTE; + + int ival = 0; + int result = node->QueryIntValue( &ival ); + *value = (unsigned)ival; + return result; +} + + +int TiXmlElement::QueryBoolAttribute( const char* name, bool* bval ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( !node ) + return TIXML_NO_ATTRIBUTE; + + int result = TIXML_WRONG_TYPE; + if ( StringEqual( node->Value(), "true", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "yes", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "1", true, TIXML_ENCODING_UNKNOWN ) ) + { + *bval = true; + result = TIXML_SUCCESS; + } + else if ( StringEqual( node->Value(), "false", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "no", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "0", true, TIXML_ENCODING_UNKNOWN ) ) + { + *bval = false; + result = TIXML_SUCCESS; + } + return result; +} + + + +#ifdef TIXML_USE_STL +int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryIntValue( ival ); +} +#endif + + +int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryDoubleValue( dval ); +} + + +#ifdef TIXML_USE_STL +int TiXmlElement::QueryDoubleAttribute( const std::string& name, double* dval ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryDoubleValue( dval ); +} +#endif + + +void TiXmlElement::SetAttribute( const char * name, int val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetIntValue( val ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetAttribute( const std::string& name, int val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetIntValue( val ); + } +} +#endif + + +void TiXmlElement::SetDoubleAttribute( const char * name, double val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetDoubleValue( val ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetDoubleAttribute( const std::string& name, double val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetDoubleValue( val ); + } +} +#endif + + +void TiXmlElement::SetAttribute( const char * cname, const char * cvalue ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( cname ); + if ( attrib ) { + attrib->SetValue( cvalue ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetAttribute( const std::string& _name, const std::string& _value ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( _name ); + if ( attrib ) { + attrib->SetValue( _value ); + } +} +#endif + + +void TiXmlElement::Print( FILE* cfile, int depth ) const +{ + int i; + assert( cfile ); + for ( i=0; iNext() ) + { + fprintf( cfile, " " ); + attrib->Print( cfile, depth ); + } + + // There are 3 different formatting approaches: + // 1) An element without children is printed as a node + // 2) An element with only a text child is printed as text + // 3) An element with children is printed on multiple lines. + TiXmlNode* node; + if ( !firstChild ) + { + fprintf( cfile, " />" ); + } + else if ( firstChild == lastChild && firstChild->ToText() ) + { + fprintf( cfile, ">" ); + firstChild->Print( cfile, depth + 1 ); + fprintf( cfile, "", value.c_str() ); + } + else + { + fprintf( cfile, ">" ); + + for ( node = firstChild; node; node=node->NextSibling() ) + { + if ( !node->ToText() ) + { + fprintf( cfile, "\n" ); + } + node->Print( cfile, depth+1 ); + } + fprintf( cfile, "\n" ); + for( i=0; i", value.c_str() ); + } +} + + +void TiXmlElement::CopyTo( TiXmlElement* target ) const +{ + // superclass: + TiXmlNode::CopyTo( target ); + + // Element class: + // Clone the attributes, then clone the children. + const TiXmlAttribute* attribute = 0; + for( attribute = attributeSet.First(); + attribute; + attribute = attribute->Next() ) + { + target->SetAttribute( attribute->Name(), attribute->Value() ); + } + + TiXmlNode* node = 0; + for ( node = firstChild; node; node = node->NextSibling() ) + { + target->LinkEndChild( node->Clone() ); + } +} + +bool TiXmlElement::Accept( TiXmlVisitor* visitor ) const +{ + if ( visitor->VisitEnter( *this, attributeSet.First() ) ) + { + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + if ( !node->Accept( visitor ) ) + break; + } + } + return visitor->VisitExit( *this ); +} + + +TiXmlNode* TiXmlElement::Clone() const +{ + TiXmlElement* clone = new TiXmlElement( Value() ); + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +const char* TiXmlElement::GetText() const +{ + const TiXmlNode* child = this->FirstChild(); + if ( child ) { + const TiXmlText* childText = child->ToText(); + if ( childText ) { + return childText->Value(); + } + } + return 0; +} + + +TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + ClearError(); +} + +TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + value = documentName; + ClearError(); +} + + +#ifdef TIXML_USE_STL +TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + value = documentName; + ClearError(); +} +#endif + + +TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + copy.CopyTo( this ); +} + + +TiXmlDocument& TiXmlDocument::operator=( const TiXmlDocument& copy ) +{ + Clear(); + copy.CopyTo( this ); + return *this; +} + + +bool TiXmlDocument::LoadFile( TiXmlEncoding encoding ) +{ + return LoadFile( Value(), encoding ); +} + + +bool TiXmlDocument::SaveFile() const +{ + return SaveFile( Value() ); +} + +bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding ) +{ + TIXML_STRING filename( _filename ); + value = filename; + + // reading in binary mode so that tinyxml can normalize the EOL + FILE* file = TiXmlFOpen( value.c_str (), "rb" ); + + if ( file ) + { + bool result = LoadFile( file, encoding ); + fclose( file ); + return result; + } + else + { + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } +} + +bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding ) +{ + if ( !file ) + { + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Delete the existing data: + Clear(); + location.Clear(); + + // Get the file size, so we can pre-allocate the string. HUGE speed impact. + long length = 0; + fseek( file, 0, SEEK_END ); + length = ftell( file ); + fseek( file, 0, SEEK_SET ); + + // Strange case, but good to handle up front. + if ( length <= 0 ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Subtle bug here. TinyXml did use fgets. But from the XML spec: + // 2.11 End-of-Line Handling + // + // + // ...the XML processor MUST behave as if it normalized all line breaks in external + // parsed entities (including the document entity) on input, before parsing, by translating + // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to + // a single #xA character. + // + // + // It is not clear fgets does that, and certainly isn't clear it works cross platform. + // Generally, you expect fgets to translate from the convention of the OS to the c/unix + // convention, and not work generally. + + /* + while( fgets( buf, sizeof(buf), file ) ) + { + data += buf; + } + */ + + char* buf = new char[ length+1 ]; + buf[0] = 0; + + if ( fread( buf, length, 1, file ) != 1 ) { + delete [] buf; + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Process the buffer in place to normalize new lines. (See comment above.) + // Copies from the 'p' to 'q' pointer, where p can advance faster if + // a newline-carriage return is hit. + // + // Wikipedia: + // Systems based on ASCII or a compatible character set use either LF (Line feed, '\n', 0x0A, 10 in decimal) or + // CR (Carriage return, '\r', 0x0D, 13 in decimal) individually, or CR followed by LF (CR+LF, 0x0D 0x0A)... + // * LF: Multics, Unix and Unix-like systems (GNU/Linux, AIX, Xenix, Mac OS X, FreeBSD, etc.), BeOS, Amiga, RISC OS, and others + // * CR+LF: DEC RT-11 and most other early non-Unix, non-IBM OSes, CP/M, MP/M, DOS, OS/2, Microsoft Windows, Symbian OS + // * CR: Commodore 8-bit machines, Apple II family, Mac OS up to version 9 and OS-9 + + const char* p = buf; // the read head + char* q = buf; // the write head + const char CR = 0x0d; + const char LF = 0x0a; + + buf[length] = 0; + while( *p ) { + assert( p < (buf+length) ); + assert( q <= (buf+length) ); + assert( q <= p ); + + if ( *p == CR ) { + *q++ = LF; + p++; + if ( *p == LF ) { // check for CR+LF (and skip LF) + p++; + } + } + else { + *q++ = *p++; + } + } + assert( q <= (buf+length) ); + *q = 0; + + Parse( buf, 0, encoding ); + + delete [] buf; + return !Error(); +} + + +bool TiXmlDocument::SaveFile( const char * filename ) const +{ + // The old c stuff lives on... + FILE* fp = TiXmlFOpen( filename, "w" ); + if ( fp ) + { + bool result = SaveFile( fp ); + fclose( fp ); + return result; + } + return false; +} + + +bool TiXmlDocument::SaveFile( FILE* fp ) const +{ + if ( useMicrosoftBOM ) + { + const unsigned char TIXML_UTF_LEAD_0 = 0xefU; + const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; + const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; + + fputc( TIXML_UTF_LEAD_0, fp ); + fputc( TIXML_UTF_LEAD_1, fp ); + fputc( TIXML_UTF_LEAD_2, fp ); + } + Print( fp, 0 ); + return (ferror(fp) == 0); +} + + +void TiXmlDocument::CopyTo( TiXmlDocument* target ) const +{ + TiXmlNode::CopyTo( target ); + + target->error = error; + target->errorId = errorId; + target->errorDesc = errorDesc; + target->tabsize = tabsize; + target->errorLocation = errorLocation; + target->useMicrosoftBOM = useMicrosoftBOM; + + TiXmlNode* node = 0; + for ( node = firstChild; node; node = node->NextSibling() ) + { + target->LinkEndChild( node->Clone() ); + } +} + + +TiXmlNode* TiXmlDocument::Clone() const +{ + TiXmlDocument* clone = new TiXmlDocument(); + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlDocument::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + node->Print( cfile, depth ); + fprintf( cfile, "\n" ); + } +} + + +bool TiXmlDocument::Accept( TiXmlVisitor* visitor ) const +{ + if ( visitor->VisitEnter( *this ) ) + { + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + if ( !node->Accept( visitor ) ) + break; + } + } + return visitor->VisitExit( *this ); +} + + +const TiXmlAttribute* TiXmlAttribute::Next() const +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( next->value.empty() && next->name.empty() ) + return 0; + return next; +} + +/* +TiXmlAttribute* TiXmlAttribute::Next() +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( next->value.empty() && next->name.empty() ) + return 0; + return next; +} +*/ + +const TiXmlAttribute* TiXmlAttribute::Previous() const +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( prev->value.empty() && prev->name.empty() ) + return 0; + return prev; +} + +/* +TiXmlAttribute* TiXmlAttribute::Previous() +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( prev->value.empty() && prev->name.empty() ) + return 0; + return prev; +} +*/ + +void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const +{ + TIXML_STRING n, v; + + EncodeString( name, &n ); + EncodeString( value, &v ); + + if (value.find ('\"') == TIXML_STRING::npos) { + if ( cfile ) { + fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() ); + } + if ( str ) { + (*str) += n; (*str) += "=\""; (*str) += v; (*str) += "\""; + } + } + else { + if ( cfile ) { + fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() ); + } + if ( str ) { + (*str) += n; (*str) += "='"; (*str) += v; (*str) += "'"; + } + } +} + + +int TiXmlAttribute::QueryIntValue( int* ival ) const +{ + if ( TIXML_SSCANF( value.c_str(), "%d", ival ) == 1 ) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; +} + +int TiXmlAttribute::QueryDoubleValue( double* dval ) const +{ + if ( TIXML_SSCANF( value.c_str(), "%lf", dval ) == 1 ) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; +} + +void TiXmlAttribute::SetIntValue( int _value ) +{ + char buf [64]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF(buf, sizeof(buf), "%d", _value); + #else + sprintf (buf, "%d", _value); + #endif + SetValue (buf); +} + +void TiXmlAttribute::SetDoubleValue( double _value ) +{ + char buf [256]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF( buf, sizeof(buf), "%g", _value); + #else + sprintf (buf, "%g", _value); + #endif + SetValue (buf); +} + +int TiXmlAttribute::IntValue() const +{ + return atoi (value.c_str ()); +} + +double TiXmlAttribute::DoubleValue() const +{ + return atof (value.c_str ()); +} + + +TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) +{ + copy.CopyTo( this ); +} + + +TiXmlComment& TiXmlComment::operator=( const TiXmlComment& base ) +{ + Clear(); + base.CopyTo( this ); + return *this; +} + + +void TiXmlComment::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + for ( int i=0; i", value.c_str() ); +} + + +void TiXmlComment::CopyTo( TiXmlComment* target ) const +{ + TiXmlNode::CopyTo( target ); +} + + +bool TiXmlComment::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlComment::Clone() const +{ + TiXmlComment* clone = new TiXmlComment(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlText::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + if ( cdata ) + { + int i; + fprintf( cfile, "\n" ); + for ( i=0; i\n", value.c_str() ); // unformatted output + } + else + { + TIXML_STRING buffer; + EncodeString( value, &buffer ); + fprintf( cfile, "%s", buffer.c_str() ); + } +} + + +void TiXmlText::CopyTo( TiXmlText* target ) const +{ + TiXmlNode::CopyTo( target ); + target->cdata = cdata; +} + + +bool TiXmlText::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlText::Clone() const +{ + TiXmlText* clone = 0; + clone = new TiXmlText( "" ); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +TiXmlDeclaration::TiXmlDeclaration( const char * _version, + const char * _encoding, + const char * _standalone ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + version = _version; + encoding = _encoding; + standalone = _standalone; +} + + +#ifdef TIXML_USE_STL +TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, + const std::string& _encoding, + const std::string& _standalone ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + version = _version; + encoding = _encoding; + standalone = _standalone; +} +#endif + + +TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + copy.CopyTo( this ); +} + + +TiXmlDeclaration& TiXmlDeclaration::operator=( const TiXmlDeclaration& copy ) +{ + Clear(); + copy.CopyTo( this ); + return *this; +} + + +void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const +{ + if ( cfile ) fprintf( cfile, "" ); + if ( str ) (*str) += "?>"; +} + + +void TiXmlDeclaration::CopyTo( TiXmlDeclaration* target ) const +{ + TiXmlNode::CopyTo( target ); + + target->version = version; + target->encoding = encoding; + target->standalone = standalone; +} + + +bool TiXmlDeclaration::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlDeclaration::Clone() const +{ + TiXmlDeclaration* clone = new TiXmlDeclaration(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlUnknown::Print( FILE* cfile, int depth ) const +{ + for ( int i=0; i", value.c_str() ); +} + + +void TiXmlUnknown::CopyTo( TiXmlUnknown* target ) const +{ + TiXmlNode::CopyTo( target ); +} + + +bool TiXmlUnknown::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlUnknown::Clone() const +{ + TiXmlUnknown* clone = new TiXmlUnknown(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +TiXmlAttributeSet::TiXmlAttributeSet() +{ + sentinel.next = &sentinel; + sentinel.prev = &sentinel; +} + + +TiXmlAttributeSet::~TiXmlAttributeSet() +{ + assert( sentinel.next == &sentinel ); + assert( sentinel.prev == &sentinel ); +} + + +void TiXmlAttributeSet::Add( TiXmlAttribute* addMe ) +{ + #ifdef TIXML_USE_STL + assert( !Find( TIXML_STRING( addMe->Name() ) ) ); // Shouldn't be multiply adding to the set. + #else + assert( !Find( addMe->Name() ) ); // Shouldn't be multiply adding to the set. + #endif + + addMe->next = &sentinel; + addMe->prev = sentinel.prev; + + sentinel.prev->next = addMe; + sentinel.prev = addMe; +} + +void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe ) +{ + TiXmlAttribute* node; + + for( node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( node == removeMe ) + { + node->prev->next = node->next; + node->next->prev = node->prev; + node->next = 0; + node->prev = 0; + return; + } + } + assert( 0 ); // we tried to remove a non-linked attribute. +} + + +#ifdef TIXML_USE_STL +TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const +{ + for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( node->name == name ) + return node; + } + return 0; +} + +TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const std::string& _name ) +{ + TiXmlAttribute* attrib = Find( _name ); + if ( !attrib ) { + attrib = new TiXmlAttribute(); + Add( attrib ); + attrib->SetName( _name ); + } + return attrib; +} +#endif + + +TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const +{ + for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( strcmp( node->name.c_str(), name ) == 0 ) + return node; + } + return 0; +} + + +TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const char* _name ) +{ + TiXmlAttribute* attrib = Find( _name ); + if ( !attrib ) { + attrib = new TiXmlAttribute(); + Add( attrib ); + attrib->SetName( _name ); + } + return attrib; +} + + +#ifdef TIXML_USE_STL +std::istream& operator>> (std::istream & in, TiXmlNode & base) +{ + TIXML_STRING tag; + tag.reserve( 8 * 1000 ); + base.StreamIn( &in, &tag ); + + base.Parse( tag.c_str(), 0, TIXML_DEFAULT_ENCODING ); + return in; +} +#endif + + +#ifdef TIXML_USE_STL +std::ostream& operator<< (std::ostream & out, const TiXmlNode & base) +{ + TiXmlPrinter printer; + printer.SetStreamPrinting(); + base.Accept( &printer ); + out << printer.Str(); + + return out; +} + + +std::string& operator<< (std::string& out, const TiXmlNode& base ) +{ + TiXmlPrinter printer; + printer.SetStreamPrinting(); + base.Accept( &printer ); + out.append( printer.Str() ); + + return out; +} +#endif + + +TiXmlHandle TiXmlHandle::FirstChild() const +{ + if ( node ) + { + TiXmlNode* child = node->FirstChild(); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChild( const char * value ) const +{ + if ( node ) + { + TiXmlNode* child = node->FirstChild( value ); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChildElement() const +{ + if ( node ) + { + TiXmlElement* child = node->FirstChildElement(); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChildElement( const char * value ) const +{ + if ( node ) + { + TiXmlElement* child = node->FirstChildElement( value ); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::Child( int count ) const +{ + if ( node ) + { + int i; + TiXmlNode* child = node->FirstChild(); + for ( i=0; + child && iNextSibling(), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::Child( const char* value, int count ) const +{ + if ( node ) + { + int i; + TiXmlNode* child = node->FirstChild( value ); + for ( i=0; + child && iNextSibling( value ), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::ChildElement( int count ) const +{ + if ( node ) + { + int i; + TiXmlElement* child = node->FirstChildElement(); + for ( i=0; + child && iNextSiblingElement(), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::ChildElement( const char* value, int count ) const +{ + if ( node ) + { + int i; + TiXmlElement* child = node->FirstChildElement( value ); + for ( i=0; + child && iNextSiblingElement( value ), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +bool TiXmlPrinter::VisitEnter( const TiXmlDocument& ) +{ + return true; +} + +bool TiXmlPrinter::VisitExit( const TiXmlDocument& ) +{ + return true; +} + +bool TiXmlPrinter::VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute ) +{ + DoIndent(); + buffer += "<"; + buffer += element.Value(); + + for( const TiXmlAttribute* attrib = firstAttribute; attrib; attrib = attrib->Next() ) + { + buffer += " "; + attrib->Print( 0, 0, &buffer ); + } + + if ( !element.FirstChild() ) + { + buffer += " />"; + DoLineBreak(); + } + else + { + buffer += ">"; + if ( element.FirstChild()->ToText() + && element.LastChild() == element.FirstChild() + && element.FirstChild()->ToText()->CDATA() == false ) + { + simpleTextPrint = true; + // no DoLineBreak()! + } + else + { + DoLineBreak(); + } + } + ++depth; + return true; +} + + +bool TiXmlPrinter::VisitExit( const TiXmlElement& element ) +{ + --depth; + if ( !element.FirstChild() ) + { + // nothing. + } + else + { + if ( simpleTextPrint ) + { + simpleTextPrint = false; + } + else + { + DoIndent(); + } + buffer += ""; + DoLineBreak(); + } + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlText& text ) +{ + if ( text.CDATA() ) + { + DoIndent(); + buffer += ""; + DoLineBreak(); + } + else if ( simpleTextPrint ) + { + TIXML_STRING str; + TiXmlBase::EncodeString( text.ValueTStr(), &str ); + buffer += str; + } + else + { + DoIndent(); + TIXML_STRING str; + TiXmlBase::EncodeString( text.ValueTStr(), &str ); + buffer += str; + DoLineBreak(); + } + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlDeclaration& declaration ) +{ + DoIndent(); + declaration.Print( 0, 0, &buffer ); + DoLineBreak(); + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlComment& comment ) +{ + DoIndent(); + buffer += ""; + DoLineBreak(); + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlUnknown& unknown ) +{ + DoIndent(); + buffer += "<"; + buffer += unknown.Value(); + buffer += ">"; + DoLineBreak(); + return true; +} + diff --git a/LaipuDrawing/tinyxml.h b/LaipuDrawing/tinyxml.h new file mode 100644 index 0000000..a3589e5 --- /dev/null +++ b/LaipuDrawing/tinyxml.h @@ -0,0 +1,1805 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code by Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + + +#ifndef TINYXML_INCLUDED +#define TINYXML_INCLUDED + +#ifdef _MSC_VER +#pragma warning( push ) +#pragma warning( disable : 4530 ) +#pragma warning( disable : 4786 ) +#endif + +#include +#include +#include +#include +#include + +// Help out windows: +#if defined( _DEBUG ) && !defined( DEBUG ) +#define DEBUG +#endif + +#ifdef TIXML_USE_STL + #include + #include + #include + #define TIXML_STRING std::string +#else + #include "tinystr.h" + #define TIXML_STRING TiXmlString +#endif + +// Deprecated library function hell. Compilers want to use the +// new safe versions. This probably doesn't fully address the problem, +// but it gets closer. There are too many compilers for me to fully +// test. If you get compilation troubles, undefine TIXML_SAFE +#define TIXML_SAFE + +#ifdef TIXML_SAFE + #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) + // Microsoft visual studio, version 2005 and higher. + #define TIXML_SNPRINTF _snprintf_s + #define TIXML_SSCANF sscanf_s + #elif defined(_MSC_VER) && (_MSC_VER >= 1200 ) + // Microsoft visual studio, version 6 and higher. + //#pragma message( "Using _sn* functions." ) + #define TIXML_SNPRINTF _snprintf + #define TIXML_SSCANF sscanf + #elif defined(__GNUC__) && (__GNUC__ >= 3 ) + // GCC version 3 and higher.s + //#warning( "Using sn* functions." ) + #define TIXML_SNPRINTF snprintf + #define TIXML_SSCANF sscanf + #else + #define TIXML_SNPRINTF snprintf + #define TIXML_SSCANF sscanf + #endif +#endif + +class TiXmlDocument; +class TiXmlElement; +class TiXmlComment; +class TiXmlUnknown; +class TiXmlAttribute; +class TiXmlText; +class TiXmlDeclaration; +class TiXmlParsingData; + +const int TIXML_MAJOR_VERSION = 2; +const int TIXML_MINOR_VERSION = 6; +const int TIXML_PATCH_VERSION = 2; + +/* Internal structure for tracking location of items + in the XML file. +*/ +struct TiXmlCursor +{ + TiXmlCursor() { Clear(); } + void Clear() { row = col = -1; } + + int row; // 0 based. + int col; // 0 based. +}; + + +/** + Implements the interface to the "Visitor pattern" (see the Accept() method.) + If you call the Accept() method, it requires being passed a TiXmlVisitor + class to handle callbacks. For nodes that contain other nodes (Document, Element) + you will get called with a VisitEnter/VisitExit pair. Nodes that are always leaves + are simply called with Visit(). + + If you return 'true' from a Visit method, recursive parsing will continue. If you return + false, no children of this node or its sibilings will be Visited. + + All flavors of Visit methods have a default implementation that returns 'true' (continue + visiting). You need to only override methods that are interesting to you. + + Generally Accept() is called on the TiXmlDocument, although all nodes suppert Visiting. + + You should never change the document from a callback. + + @sa TiXmlNode::Accept() +*/ +class TiXmlVisitor +{ +public: + virtual ~TiXmlVisitor() {} + + /// Visit a document. + virtual bool VisitEnter( const TiXmlDocument& /*doc*/ ) { return true; } + /// Visit a document. + virtual bool VisitExit( const TiXmlDocument& /*doc*/ ) { return true; } + + /// Visit an element. + virtual bool VisitEnter( const TiXmlElement& /*element*/, const TiXmlAttribute* /*firstAttribute*/ ) { return true; } + /// Visit an element. + virtual bool VisitExit( const TiXmlElement& /*element*/ ) { return true; } + + /// Visit a declaration + virtual bool Visit( const TiXmlDeclaration& /*declaration*/ ) { return true; } + /// Visit a text node + virtual bool Visit( const TiXmlText& /*text*/ ) { return true; } + /// Visit a comment node + virtual bool Visit( const TiXmlComment& /*comment*/ ) { return true; } + /// Visit an unknown node + virtual bool Visit( const TiXmlUnknown& /*unknown*/ ) { return true; } +}; + +// Only used by Attribute::Query functions +enum +{ + TIXML_SUCCESS, + TIXML_NO_ATTRIBUTE, + TIXML_WRONG_TYPE +}; + + +// Used by the parsing routines. +enum TiXmlEncoding +{ + TIXML_ENCODING_UNKNOWN, + TIXML_ENCODING_UTF8, + TIXML_ENCODING_LEGACY +}; + +const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN; + +/** TiXmlBase is a base class for every class in TinyXml. + It does little except to establish that TinyXml classes + can be printed and provide some utility functions. + + In XML, the document and elements can contain + other elements and other types of nodes. + + @verbatim + A Document can contain: Element (container or leaf) + Comment (leaf) + Unknown (leaf) + Declaration( leaf ) + + An Element can contain: Element (container or leaf) + Text (leaf) + Attributes (not on tree) + Comment (leaf) + Unknown (leaf) + + A Decleration contains: Attributes (not on tree) + @endverbatim +*/ +class TiXmlBase +{ + friend class TiXmlNode; + friend class TiXmlElement; + friend class TiXmlDocument; + +public: + TiXmlBase() : userData(0) {} + virtual ~TiXmlBase() {} + + /** All TinyXml classes can print themselves to a filestream + or the string class (TiXmlString in non-STL mode, std::string + in STL mode.) Either or both cfile and str can be null. + + This is a formatted print, and will insert + tabs and newlines. + + (For an unformatted stream, use the << operator.) + */ + virtual void Print( FILE* cfile, int depth ) const = 0; + + /** The world does not agree on whether white space should be kept or + not. In order to make everyone happy, these global, static functions + are provided to set whether or not TinyXml will condense all white space + into a single space or not. The default is to condense. Note changing this + value is not thread safe. + */ + static void SetCondenseWhiteSpace( bool condense ) { condenseWhiteSpace = condense; } + + /// Return the current white space setting. + static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; } + + /** Return the position, in the original source file, of this node or attribute. + The row and column are 1-based. (That is the first row and first column is + 1,1). If the returns values are 0 or less, then the parser does not have + a row and column value. + + Generally, the row and column value will be set when the TiXmlDocument::Load(), + TiXmlDocument::LoadFile(), or any TiXmlNode::Parse() is called. It will NOT be set + when the DOM was created from operator>>. + + The values reflect the initial load. Once the DOM is modified programmatically + (by adding or changing nodes and attributes) the new values will NOT update to + reflect changes in the document. + + There is a minor performance cost to computing the row and column. Computation + can be disabled if TiXmlDocument::SetTabSize() is called with 0 as the value. + + @sa TiXmlDocument::SetTabSize() + */ + int Row() const { return location.row + 1; } + int Column() const { return location.col + 1; } ///< See Row() + + void SetUserData( void* user ) { userData = user; } ///< Set a pointer to arbitrary user data. + void* GetUserData() { return userData; } ///< Get a pointer to arbitrary user data. + const void* GetUserData() const { return userData; } ///< Get a pointer to arbitrary user data. + + // Table that returs, for a given lead byte, the total number of bytes + // in the UTF-8 sequence. + static const int utf8ByteTable[256]; + + virtual const char* Parse( const char* p, + TiXmlParsingData* data, + TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0; + + /** Expands entities in a string. Note this should not contian the tag's '<', '>', etc, + or they will be transformed into entities! + */ + static void EncodeString( const TIXML_STRING& str, TIXML_STRING* out ); + + enum + { + TIXML_NO_ERROR = 0, + TIXML_ERROR, + TIXML_ERROR_OPENING_FILE, + TIXML_ERROR_PARSING_ELEMENT, + TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, + TIXML_ERROR_READING_ELEMENT_VALUE, + TIXML_ERROR_READING_ATTRIBUTES, + TIXML_ERROR_PARSING_EMPTY, + TIXML_ERROR_READING_END_TAG, + TIXML_ERROR_PARSING_UNKNOWN, + TIXML_ERROR_PARSING_COMMENT, + TIXML_ERROR_PARSING_DECLARATION, + TIXML_ERROR_DOCUMENT_EMPTY, + TIXML_ERROR_EMBEDDED_NULL, + TIXML_ERROR_PARSING_CDATA, + TIXML_ERROR_DOCUMENT_TOP_ONLY, + + TIXML_ERROR_STRING_COUNT + }; + +protected: + + static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding ); + + inline static bool IsWhiteSpace( char c ) + { + return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); + } + inline static bool IsWhiteSpace( int c ) + { + if ( c < 256 ) + return IsWhiteSpace( (char) c ); + return false; // Again, only truly correct for English/Latin...but usually works. + } + + #ifdef TIXML_USE_STL + static bool StreamWhiteSpace( std::istream * in, TIXML_STRING * tag ); + static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag ); + #endif + + /* Reads an XML name into the string provided. Returns + a pointer just past the last character of the name, + or 0 if the function has an error. + */ + static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding ); + + /* Reads text. Returns a pointer past the given end tag. + Wickedly complex options, but it keeps the (sensitive) code in one place. + */ + static const char* ReadText( const char* in, // where to start + TIXML_STRING* text, // the string read + bool ignoreWhiteSpace, // whether to keep the white space + const char* endTag, // what ends this text + bool ignoreCase, // whether to ignore case in the end tag + TiXmlEncoding encoding ); // the current encoding + + // If an entity has been found, transform it into a character. + static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding ); + + // Get a character, while interpreting entities. + // The length can be from 0 to 4 bytes. + inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding ) + { + assert( p ); + if ( encoding == TIXML_ENCODING_UTF8 ) + { + *length = utf8ByteTable[ *((const unsigned char*)p) ]; + assert( *length >= 0 && *length < 5 ); + } + else + { + *length = 1; + } + + if ( *length == 1 ) + { + if ( *p == '&' ) + return GetEntity( p, _value, length, encoding ); + *_value = *p; + return p+1; + } + else if ( *length ) + { + //strncpy( _value, p, *length ); // lots of compilers don't like this function (unsafe), + // and the null terminator isn't needed + for( int i=0; p[i] && i<*length; ++i ) { + _value[i] = p[i]; + } + return p + (*length); + } + else + { + // Not valid text. + return 0; + } + } + + // Return true if the next characters in the stream are any of the endTag sequences. + // Ignore case only works for english, and should only be relied on when comparing + // to English words: StringEqual( p, "version", true ) is fine. + static bool StringEqual( const char* p, + const char* endTag, + bool ignoreCase, + TiXmlEncoding encoding ); + + static const char* errorString[ TIXML_ERROR_STRING_COUNT ]; + + TiXmlCursor location; + + /// Field containing a generic user pointer + void* userData; + + // None of these methods are reliable for any language except English. + // Good for approximation, not great for accuracy. + static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding ); + static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding ); + inline static int ToLower( int v, TiXmlEncoding encoding ) + { + if ( encoding == TIXML_ENCODING_UTF8 ) + { + if ( v < 128 ) return tolower( v ); + return v; + } + else + { + return tolower( v ); + } + } + static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length ); + +private: + TiXmlBase( const TiXmlBase& ); // not implemented. + void operator=( const TiXmlBase& base ); // not allowed. + + struct Entity + { + const char* str; + unsigned int strLength; + char chr; + }; + enum + { + NUM_ENTITY = 5, + MAX_ENTITY_LENGTH = 6 + + }; + static Entity entity[ NUM_ENTITY ]; + static bool condenseWhiteSpace; +}; + + +/** The parent class for everything in the Document Object Model. + (Except for attributes). + Nodes have siblings, a parent, and children. A node can be + in a document, or stand on its own. The type of a TiXmlNode + can be queried, and it can be cast to its more defined type. +*/ +class TiXmlNode : public TiXmlBase +{ + friend class TiXmlDocument; + friend class TiXmlElement; + +public: + #ifdef TIXML_USE_STL + + /** An input stream operator, for every class. Tolerant of newlines and + formatting, but doesn't expect them. + */ + friend std::istream& operator >> (std::istream& in, TiXmlNode& base); + + /** An output stream operator, for every class. Note that this outputs + without any newlines or formatting, as opposed to Print(), which + includes tabs and new lines. + + The operator<< and operator>> are not completely symmetric. Writing + a node to a stream is very well defined. You'll get a nice stream + of output, without any extra whitespace or newlines. + + But reading is not as well defined. (As it always is.) If you create + a TiXmlElement (for example) and read that from an input stream, + the text needs to define an element or junk will result. This is + true of all input streams, but it's worth keeping in mind. + + A TiXmlDocument will read nodes until it reads a root element, and + all the children of that root element. + */ + friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base); + + /// Appends the XML node or attribute to a std::string. + friend std::string& operator<< (std::string& out, const TiXmlNode& base ); + + #endif + + /** The types of XML nodes supported by TinyXml. (All the + unsupported types are picked up by UNKNOWN.) + */ + enum NodeType + { + TINYXML_DOCUMENT, + TINYXML_ELEMENT, + TINYXML_COMMENT, + TINYXML_UNKNOWN, + TINYXML_TEXT, + TINYXML_DECLARATION, + TINYXML_TYPECOUNT + }; + + virtual ~TiXmlNode(); + + /** The meaning of 'value' changes for the specific type of + TiXmlNode. + @verbatim + Document: filename of the xml file + Element: name of the element + Comment: the comment text + Unknown: the tag contents + Text: the text string + @endverbatim + + The subclasses will wrap this function. + */ + const char *Value() const { return value.c_str (); } + + #ifdef TIXML_USE_STL + /** Return Value() as a std::string. If you only use STL, + this is more efficient than calling Value(). + Only available in STL mode. + */ + const std::string& ValueStr() const { return value; } + #endif + + const TIXML_STRING& ValueTStr() const { return value; } + + /** Changes the value of the node. Defined as: + @verbatim + Document: filename of the xml file + Element: name of the element + Comment: the comment text + Unknown: the tag contents + Text: the text string + @endverbatim + */ + void SetValue(const char * _value) { value = _value;} + + #ifdef TIXML_USE_STL + /// STL std::string form. + void SetValue( const std::string& _value ) { value = _value; } + #endif + + /// Delete all the children of this node. Does not affect 'this'. + void Clear(); + + /// One step up the DOM. + TiXmlNode* Parent() { return parent; } + const TiXmlNode* Parent() const { return parent; } + + const TiXmlNode* FirstChild() const { return firstChild; } ///< The first child of this node. Will be null if there are no children. + TiXmlNode* FirstChild() { return firstChild; } + const TiXmlNode* FirstChild( const char * value ) const; ///< The first child of this node with the matching 'value'. Will be null if none found. + /// The first child of this node with the matching 'value'. Will be null if none found. + TiXmlNode* FirstChild( const char * _value ) { + // Call through to the const version - safe since nothing is changed. Exiting syntax: cast this to a const (always safe) + // call the method, cast the return back to non-const. + return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild( _value )); + } + const TiXmlNode* LastChild() const { return lastChild; } /// The last child of this node. Will be null if there are no children. + TiXmlNode* LastChild() { return lastChild; } + + const TiXmlNode* LastChild( const char * value ) const; /// The last child of this node matching 'value'. Will be null if there are no children. + TiXmlNode* LastChild( const char * _value ) { + return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild( _value )); + } + + #ifdef TIXML_USE_STL + const TiXmlNode* FirstChild( const std::string& _value ) const { return FirstChild (_value.c_str ()); } ///< STL std::string form. + TiXmlNode* FirstChild( const std::string& _value ) { return FirstChild (_value.c_str ()); } ///< STL std::string form. + const TiXmlNode* LastChild( const std::string& _value ) const { return LastChild (_value.c_str ()); } ///< STL std::string form. + TiXmlNode* LastChild( const std::string& _value ) { return LastChild (_value.c_str ()); } ///< STL std::string form. + #endif + + /** An alternate way to walk the children of a node. + One way to iterate over nodes is: + @verbatim + for( child = parent->FirstChild(); child; child = child->NextSibling() ) + @endverbatim + + IterateChildren does the same thing with the syntax: + @verbatim + child = 0; + while( child = parent->IterateChildren( child ) ) + @endverbatim + + IterateChildren takes the previous child as input and finds + the next one. If the previous child is null, it returns the + first. IterateChildren will return null when done. + */ + const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const; + TiXmlNode* IterateChildren( const TiXmlNode* previous ) { + return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( previous ) ); + } + + /// This flavor of IterateChildren searches for children with a particular 'value' + const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const; + TiXmlNode* IterateChildren( const char * _value, const TiXmlNode* previous ) { + return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( _value, previous ) ); + } + + #ifdef TIXML_USE_STL + const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const { return IterateChildren (_value.c_str (), previous); } ///< STL std::string form. + TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) { return IterateChildren (_value.c_str (), previous); } ///< STL std::string form. + #endif + + /** Add a new node related to this. Adds a child past the LastChild. + Returns a pointer to the new object or NULL if an error occured. + */ + TiXmlNode* InsertEndChild( const TiXmlNode& addThis ); + + + /** Add a new node related to this. Adds a child past the LastChild. + + NOTE: the node to be added is passed by pointer, and will be + henceforth owned (and deleted) by tinyXml. This method is efficient + and avoids an extra copy, but should be used with care as it + uses a different memory model than the other insert functions. + + @sa InsertEndChild + */ + TiXmlNode* LinkEndChild( TiXmlNode* addThis ); + + /** Add a new node related to this. Adds a child before the specified child. + Returns a pointer to the new object or NULL if an error occured. + */ + TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis ); + + /** Add a new node related to this. Adds a child after the specified child. + Returns a pointer to the new object or NULL if an error occured. + */ + TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis ); + + /** Replace a child of this node. + Returns a pointer to the new object or NULL if an error occured. + */ + TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis ); + + /// Delete a child of this node. + bool RemoveChild( TiXmlNode* removeThis ); + + /// Navigate to a sibling node. + const TiXmlNode* PreviousSibling() const { return prev; } + TiXmlNode* PreviousSibling() { return prev; } + + /// Navigate to a sibling node. + const TiXmlNode* PreviousSibling( const char * ) const; + TiXmlNode* PreviousSibling( const char *_prev ) { + return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->PreviousSibling( _prev ) ); + } + + #ifdef TIXML_USE_STL + const TiXmlNode* PreviousSibling( const std::string& _value ) const { return PreviousSibling (_value.c_str ()); } ///< STL std::string form. + TiXmlNode* PreviousSibling( const std::string& _value ) { return PreviousSibling (_value.c_str ()); } ///< STL std::string form. + const TiXmlNode* NextSibling( const std::string& _value) const { return NextSibling (_value.c_str ()); } ///< STL std::string form. + TiXmlNode* NextSibling( const std::string& _value) { return NextSibling (_value.c_str ()); } ///< STL std::string form. + #endif + + /// Navigate to a sibling node. + const TiXmlNode* NextSibling() const { return next; } + TiXmlNode* NextSibling() { return next; } + + /// Navigate to a sibling node with the given 'value'. + const TiXmlNode* NextSibling( const char * ) const; + TiXmlNode* NextSibling( const char* _next ) { + return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->NextSibling( _next ) ); + } + + /** Convenience function to get through elements. + Calls NextSibling and ToElement. Will skip all non-Element + nodes. Returns 0 if there is not another element. + */ + const TiXmlElement* NextSiblingElement() const; + TiXmlElement* NextSiblingElement() { + return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() ); + } + + /** Convenience function to get through elements. + Calls NextSibling and ToElement. Will skip all non-Element + nodes. Returns 0 if there is not another element. + */ + const TiXmlElement* NextSiblingElement( const char * ) const; + TiXmlElement* NextSiblingElement( const char *_next ) { + return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement( _next ) ); + } + + #ifdef TIXML_USE_STL + const TiXmlElement* NextSiblingElement( const std::string& _value) const { return NextSiblingElement (_value.c_str ()); } ///< STL std::string form. + TiXmlElement* NextSiblingElement( const std::string& _value) { return NextSiblingElement (_value.c_str ()); } ///< STL std::string form. + #endif + + /// Convenience function to get through elements. + const TiXmlElement* FirstChildElement() const; + TiXmlElement* FirstChildElement() { + return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() ); + } + + /// Convenience function to get through elements. + const TiXmlElement* FirstChildElement( const char * _value ) const; + TiXmlElement* FirstChildElement( const char * _value ) { + return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement( _value ) ); + } + + #ifdef TIXML_USE_STL + const TiXmlElement* FirstChildElement( const std::string& _value ) const { return FirstChildElement (_value.c_str ()); } ///< STL std::string form. + TiXmlElement* FirstChildElement( const std::string& _value ) { return FirstChildElement (_value.c_str ()); } ///< STL std::string form. + #endif + + /** Query the type (as an enumerated value, above) of this node. + The possible types are: TINYXML_DOCUMENT, TINYXML_ELEMENT, TINYXML_COMMENT, + TINYXML_UNKNOWN, TINYXML_TEXT, and TINYXML_DECLARATION. + */ + int Type() const { return type; } + + /** Return a pointer to the Document this node lives in. + Returns null if not in a document. + */ + const TiXmlDocument* GetDocument() const; + TiXmlDocument* GetDocument() { + return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() ); + } + + /// Returns true if this node has no children. + bool NoChildren() const { return !firstChild; } + + virtual const TiXmlDocument* ToDocument() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlElement* ToElement() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlComment* ToComment() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlUnknown* ToUnknown() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlText* ToText() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + + virtual TiXmlDocument* ToDocument() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlElement* ToElement() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlComment* ToComment() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlUnknown* ToUnknown() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlText* ToText() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + virtual TiXmlDeclaration* ToDeclaration() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. + + /** Create an exact duplicate of this node and return it. The memory must be deleted + by the caller. + */ + virtual TiXmlNode* Clone() const = 0; + + /** Accept a hierchical visit the nodes in the TinyXML DOM. Every node in the + XML tree will be conditionally visited and the host will be called back + via the TiXmlVisitor interface. + + This is essentially a SAX interface for TinyXML. (Note however it doesn't re-parse + the XML for the callbacks, so the performance of TinyXML is unchanged by using this + interface versus any other.) + + The interface has been based on ideas from: + + - http://www.saxproject.org/ + - http://c2.com/cgi/wiki?HierarchicalVisitorPattern + + Which are both good references for "visiting". + + An example of using Accept(): + @verbatim + TiXmlPrinter printer; + tinyxmlDoc.Accept( &printer ); + const char* xmlcstr = printer.CStr(); + @endverbatim + */ + virtual bool Accept( TiXmlVisitor* visitor ) const = 0; + +protected: + TiXmlNode( NodeType _type ); + + // Copy to the allocated object. Shared functionality between Clone, Copy constructor, + // and the assignment operator. + void CopyTo( TiXmlNode* target ) const; + + #ifdef TIXML_USE_STL + // The real work of the input operator. + virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0; + #endif + + // Figure out what is at *p, and parse it. Returns null if it is not an xml node. + TiXmlNode* Identify( const char* start, TiXmlEncoding encoding ); + + TiXmlNode* parent; + NodeType type; + + TiXmlNode* firstChild; + TiXmlNode* lastChild; + + TIXML_STRING value; + + TiXmlNode* prev; + TiXmlNode* next; + +private: + TiXmlNode( const TiXmlNode& ); // not implemented. + void operator=( const TiXmlNode& base ); // not allowed. +}; + + +/** An attribute is a name-value pair. Elements have an arbitrary + number of attributes, each with a unique name. + + @note The attributes are not TiXmlNodes, since they are not + part of the tinyXML document object model. There are other + suggested ways to look at this problem. +*/ +class TiXmlAttribute : public TiXmlBase +{ + friend class TiXmlAttributeSet; + +public: + /// Construct an empty attribute. + TiXmlAttribute() : TiXmlBase() + { + document = 0; + prev = next = 0; + } + + #ifdef TIXML_USE_STL + /// std::string constructor. + TiXmlAttribute( const std::string& _name, const std::string& _value ) + { + name = _name; + value = _value; + document = 0; + prev = next = 0; + } + #endif + + /// Construct an attribute with a name and value. + TiXmlAttribute( const char * _name, const char * _value ) + { + name = _name; + value = _value; + document = 0; + prev = next = 0; + } + + const char* Name() const { return name.c_str(); } ///< Return the name of this attribute. + const char* Value() const { return value.c_str(); } ///< Return the value of this attribute. + #ifdef TIXML_USE_STL + const std::string& ValueStr() const { return value; } ///< Return the value of this attribute. + #endif + int IntValue() const; ///< Return the value of this attribute, converted to an integer. + double DoubleValue() const; ///< Return the value of this attribute, converted to a double. + + // Get the tinyxml string representation + const TIXML_STRING& NameTStr() const { return name; } + + /** QueryIntValue examines the value string. It is an alternative to the + IntValue() method with richer error checking. + If the value is an integer, it is stored in 'value' and + the call returns TIXML_SUCCESS. If it is not + an integer, it returns TIXML_WRONG_TYPE. + + A specialized but useful call. Note that for success it returns 0, + which is the opposite of almost all other TinyXml calls. + */ + int QueryIntValue( int* _value ) const; + /// QueryDoubleValue examines the value string. See QueryIntValue(). + int QueryDoubleValue( double* _value ) const; + + void SetName( const char* _name ) { name = _name; } ///< Set the name of this attribute. + void SetValue( const char* _value ) { value = _value; } ///< Set the value. + + void SetIntValue( int _value ); ///< Set the value from an integer. + void SetDoubleValue( double _value ); ///< Set the value from a double. + + #ifdef TIXML_USE_STL + /// STL std::string form. + void SetName( const std::string& _name ) { name = _name; } + /// STL std::string form. + void SetValue( const std::string& _value ) { value = _value; } + #endif + + /// Get the next sibling attribute in the DOM. Returns null at end. + const TiXmlAttribute* Next() const; + TiXmlAttribute* Next() { + return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() ); + } + + /// Get the previous sibling attribute in the DOM. Returns null at beginning. + const TiXmlAttribute* Previous() const; + TiXmlAttribute* Previous() { + return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Previous() ); + } + + bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; } + bool operator<( const TiXmlAttribute& rhs ) const { return name < rhs.name; } + bool operator>( const TiXmlAttribute& rhs ) const { return name > rhs.name; } + + /* Attribute parsing starts: first letter of the name + returns: the next char after the value end quote + */ + virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); + + // Prints this Attribute to a FILE stream. + virtual void Print( FILE* cfile, int depth ) const { + Print( cfile, depth, 0 ); + } + void Print( FILE* cfile, int depth, TIXML_STRING* str ) const; + + // [internal use] + // Set the document pointer so the attribute can report errors. + void SetDocument( TiXmlDocument* doc ) { document = doc; } + +private: + TiXmlAttribute( const TiXmlAttribute& ); // not implemented. + void operator=( const TiXmlAttribute& base ); // not allowed. + + TiXmlDocument* document; // A pointer back to a document, for error reporting. + TIXML_STRING name; + TIXML_STRING value; + TiXmlAttribute* prev; + TiXmlAttribute* next; +}; + + +/* A class used to manage a group of attributes. + It is only used internally, both by the ELEMENT and the DECLARATION. + + The set can be changed transparent to the Element and Declaration + classes that use it, but NOT transparent to the Attribute + which has to implement a next() and previous() method. Which makes + it a bit problematic and prevents the use of STL. + + This version is implemented with circular lists because: + - I like circular lists + - it demonstrates some independence from the (typical) doubly linked list. +*/ +class TiXmlAttributeSet +{ +public: + TiXmlAttributeSet(); + ~TiXmlAttributeSet(); + + void Add( TiXmlAttribute* attribute ); + void Remove( TiXmlAttribute* attribute ); + + const TiXmlAttribute* First() const { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; } + TiXmlAttribute* First() { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; } + const TiXmlAttribute* Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; } + TiXmlAttribute* Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; } + + TiXmlAttribute* Find( const char* _name ) const; + TiXmlAttribute* FindOrCreate( const char* _name ); + +# ifdef TIXML_USE_STL + TiXmlAttribute* Find( const std::string& _name ) const; + TiXmlAttribute* FindOrCreate( const std::string& _name ); +# endif + + +private: + //*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element), + //*ME: this class must be also use a hidden/disabled copy-constructor !!! + TiXmlAttributeSet( const TiXmlAttributeSet& ); // not allowed + void operator=( const TiXmlAttributeSet& ); // not allowed (as TiXmlAttribute) + + TiXmlAttribute sentinel; +}; + + +/** The element is a container class. It has a value, the element name, + and can contain other elements, text, comments, and unknowns. + Elements also contain an arbitrary number of attributes. +*/ +class TiXmlElement : public TiXmlNode +{ +public: + /// Construct an element. + TiXmlElement (const char * in_value); + + #ifdef TIXML_USE_STL + /// std::string constructor. + TiXmlElement( const std::string& _value ); + #endif + + TiXmlElement( const TiXmlElement& ); + + TiXmlElement& operator=( const TiXmlElement& base ); + + virtual ~TiXmlElement(); + + /** Given an attribute name, Attribute() returns the value + for the attribute of that name, or null if none exists. + */ + const char* Attribute( const char* name ) const; + + /** Given an attribute name, Attribute() returns the value + for the attribute of that name, or null if none exists. + If the attribute exists and can be converted to an integer, + the integer value will be put in the return 'i', if 'i' + is non-null. + */ + const char* Attribute( const char* name, int* i ) const; + + /** Given an attribute name, Attribute() returns the value + for the attribute of that name, or null if none exists. + If the attribute exists and can be converted to an double, + the double value will be put in the return 'd', if 'd' + is non-null. + */ + const char* Attribute( const char* name, double* d ) const; + + /** QueryIntAttribute examines the attribute - it is an alternative to the + Attribute() method with richer error checking. + If the attribute is an integer, it is stored in 'value' and + the call returns TIXML_SUCCESS. If it is not + an integer, it returns TIXML_WRONG_TYPE. If the attribute + does not exist, then TIXML_NO_ATTRIBUTE is returned. + */ + int QueryIntAttribute( const char* name, int* _value ) const; + /// QueryUnsignedAttribute examines the attribute - see QueryIntAttribute(). + int QueryUnsignedAttribute( const char* name, unsigned* _value ) const; + /** QueryBoolAttribute examines the attribute - see QueryIntAttribute(). + Note that '1', 'true', or 'yes' are considered true, while '0', 'false' + and 'no' are considered false. + */ + int QueryBoolAttribute( const char* name, bool* _value ) const; + /// QueryDoubleAttribute examines the attribute - see QueryIntAttribute(). + int QueryDoubleAttribute( const char* name, double* _value ) const; + /// QueryFloatAttribute examines the attribute - see QueryIntAttribute(). + int QueryFloatAttribute( const char* name, float* _value ) const { + double d; + int result = QueryDoubleAttribute( name, &d ); + if ( result == TIXML_SUCCESS ) { + *_value = (float)d; + } + return result; + } + + #ifdef TIXML_USE_STL + /// QueryStringAttribute examines the attribute - see QueryIntAttribute(). + int QueryStringAttribute( const char* name, std::string* _value ) const { + const char* cstr = Attribute( name ); + if ( cstr ) { + *_value = std::string( cstr ); + return TIXML_SUCCESS; + } + return TIXML_NO_ATTRIBUTE; + } + + /** Template form of the attribute query which will try to read the + attribute into the specified type. Very easy, very powerful, but + be careful to make sure to call this with the correct type. + + NOTE: This method doesn't work correctly for 'string' types that contain spaces. + + @return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE + */ + template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const + { + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( !node ) + return TIXML_NO_ATTRIBUTE; + + std::stringstream sstream( node->ValueStr() ); + sstream >> *outValue; + if ( !sstream.fail() ) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; + } + + int QueryValueAttribute( const std::string& name, std::string* outValue ) const + { + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( !node ) + return TIXML_NO_ATTRIBUTE; + *outValue = node->ValueStr(); + return TIXML_SUCCESS; + } + #endif + + /** Sets an attribute of name to a given value. The attribute + will be created if it does not exist, or changed if it does. + */ + void SetAttribute( const char* name, const char * _value ); + + #ifdef TIXML_USE_STL + const std::string* Attribute( const std::string& name ) const; + const std::string* Attribute( const std::string& name, int* i ) const; + const std::string* Attribute( const std::string& name, double* d ) const; + int QueryIntAttribute( const std::string& name, int* _value ) const; + int QueryDoubleAttribute( const std::string& name, double* _value ) const; + + /// STL std::string form. + void SetAttribute( const std::string& name, const std::string& _value ); + ///< STL std::string form. + void SetAttribute( const std::string& name, int _value ); + ///< STL std::string form. + void SetDoubleAttribute( const std::string& name, double value ); + #endif + + /** Sets an attribute of name to a given value. The attribute + will be created if it does not exist, or changed if it does. + */ + void SetAttribute( const char * name, int value ); + + /** Sets an attribute of name to a given value. The attribute + will be created if it does not exist, or changed if it does. + */ + void SetDoubleAttribute( const char * name, double value ); + + /** Deletes an attribute with the given name. + */ + void RemoveAttribute( const char * name ); + #ifdef TIXML_USE_STL + void RemoveAttribute( const std::string& name ) { RemoveAttribute (name.c_str ()); } ///< STL std::string form. + #endif + + const TiXmlAttribute* FirstAttribute() const { return attributeSet.First(); } ///< Access the first attribute in this element. + TiXmlAttribute* FirstAttribute() { return attributeSet.First(); } + const TiXmlAttribute* LastAttribute() const { return attributeSet.Last(); } ///< Access the last attribute in this element. + TiXmlAttribute* LastAttribute() { return attributeSet.Last(); } + + /** Convenience function for easy access to the text inside an element. Although easy + and concise, GetText() is limited compared to getting the TiXmlText child + and accessing it directly. + + If the first child of 'this' is a TiXmlText, the GetText() + returns the character string of the Text node, else null is returned. + + This is a convenient method for getting the text of simple contained text: + @verbatim + This is text + const char* str = fooElement->GetText(); + @endverbatim + + 'str' will be a pointer to "This is text". + + Note that this function can be misleading. If the element foo was created from + this XML: + @verbatim + This is text + @endverbatim + + then the value of str would be null. The first child node isn't a text node, it is + another element. From this XML: + @verbatim + This is text + @endverbatim + GetText() will return "This is ". + + WARNING: GetText() accesses a child node - don't become confused with the + similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are + safe type casts on the referenced node. + */ + const char* GetText() const; + + /// Creates a new Element and returns it - the returned element is a copy. + virtual TiXmlNode* Clone() const; + // Print the Element to a FILE stream. + virtual void Print( FILE* cfile, int depth ) const; + + /* Attribtue parsing starts: next char past '<' + returns: next char past '>' + */ + virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); + + virtual const TiXmlElement* ToElement() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlElement* ToElement() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + + /** Walk the XML tree visiting this node and all of its children. + */ + virtual bool Accept( TiXmlVisitor* visitor ) const; + +protected: + + void CopyTo( TiXmlElement* target ) const; + void ClearThis(); // like clear, but initializes 'this' object as well + + // Used to be public [internal use] + #ifdef TIXML_USE_STL + virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); + #endif + /* [internal use] + Reads the "value" of the element -- another element, or text. + This should terminate with the current end tag. + */ + const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding ); + +private: + TiXmlAttributeSet attributeSet; +}; + + +/** An XML comment. +*/ +class TiXmlComment : public TiXmlNode +{ +public: + /// Constructs an empty comment. + TiXmlComment() : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {} + /// Construct a comment from text. + TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) { + SetValue( _value ); + } + TiXmlComment( const TiXmlComment& ); + TiXmlComment& operator=( const TiXmlComment& base ); + + virtual ~TiXmlComment() {} + + /// Returns a copy of this Comment. + virtual TiXmlNode* Clone() const; + // Write this Comment to a FILE stream. + virtual void Print( FILE* cfile, int depth ) const; + + /* Attribtue parsing starts: at the ! of the !-- + returns: next char past '>' + */ + virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); + + virtual const TiXmlComment* ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlComment* ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + + /** Walk the XML tree visiting this node and all of its children. + */ + virtual bool Accept( TiXmlVisitor* visitor ) const; + +protected: + void CopyTo( TiXmlComment* target ) const; + + // used to be public + #ifdef TIXML_USE_STL + virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); + #endif +// virtual void StreamOut( TIXML_OSTREAM * out ) const; + +private: + +}; + + +/** XML text. A text node can have 2 ways to output the next. "normal" output + and CDATA. It will default to the mode it was parsed from the XML file and + you generally want to leave it alone, but you can change the output mode with + SetCDATA() and query it with CDATA(). +*/ +class TiXmlText : public TiXmlNode +{ + friend class TiXmlElement; +public: + /** Constructor for text element. By default, it is treated as + normal, encoded text. If you want it be output as a CDATA text + element, set the parameter _cdata to 'true' + */ + TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT) + { + SetValue( initValue ); + cdata = false; + } + virtual ~TiXmlText() {} + + #ifdef TIXML_USE_STL + /// Constructor. + TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT) + { + SetValue( initValue ); + cdata = false; + } + #endif + + TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TINYXML_TEXT ) { copy.CopyTo( this ); } + TiXmlText& operator=( const TiXmlText& base ) { base.CopyTo( this ); return *this; } + + // Write this text object to a FILE stream. + virtual void Print( FILE* cfile, int depth ) const; + + /// Queries whether this represents text using a CDATA section. + bool CDATA() const { return cdata; } + /// Turns on or off a CDATA representation of text. + void SetCDATA( bool _cdata ) { cdata = _cdata; } + + virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); + + virtual const TiXmlText* ToText() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlText* ToText() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + + /** Walk the XML tree visiting this node and all of its children. + */ + virtual bool Accept( TiXmlVisitor* content ) const; + +protected : + /// [internal use] Creates a new Element and returns it. + virtual TiXmlNode* Clone() const; + void CopyTo( TiXmlText* target ) const; + + bool Blank() const; // returns true if all white space and new lines + // [internal use] + #ifdef TIXML_USE_STL + virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); + #endif + +private: + bool cdata; // true if this should be input and output as a CDATA style text element +}; + + +/** In correct XML the declaration is the first entry in the file. + @verbatim + + @endverbatim + + TinyXml will happily read or write files without a declaration, + however. There are 3 possible attributes to the declaration: + version, encoding, and standalone. + + Note: In this version of the code, the attributes are + handled as special cases, not generic attributes, simply + because there can only be at most 3 and they are always the same. +*/ +class TiXmlDeclaration : public TiXmlNode +{ +public: + /// Construct an empty declaration. + TiXmlDeclaration() : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) {} + +#ifdef TIXML_USE_STL + /// Constructor. + TiXmlDeclaration( const std::string& _version, + const std::string& _encoding, + const std::string& _standalone ); +#endif + + /// Construct. + TiXmlDeclaration( const char* _version, + const char* _encoding, + const char* _standalone ); + + TiXmlDeclaration( const TiXmlDeclaration& copy ); + TiXmlDeclaration& operator=( const TiXmlDeclaration& copy ); + + virtual ~TiXmlDeclaration() {} + + /// Version. Will return an empty string if none was found. + const char *Version() const { return version.c_str (); } + /// Encoding. Will return an empty string if none was found. + const char *Encoding() const { return encoding.c_str (); } + /// Is this a standalone document? + const char *Standalone() const { return standalone.c_str (); } + + /// Creates a copy of this Declaration and returns it. + virtual TiXmlNode* Clone() const; + // Print this declaration to a FILE stream. + virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const; + virtual void Print( FILE* cfile, int depth ) const { + Print( cfile, depth, 0 ); + } + + virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); + + virtual const TiXmlDeclaration* ToDeclaration() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlDeclaration* ToDeclaration() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + + /** Walk the XML tree visiting this node and all of its children. + */ + virtual bool Accept( TiXmlVisitor* visitor ) const; + +protected: + void CopyTo( TiXmlDeclaration* target ) const; + // used to be public + #ifdef TIXML_USE_STL + virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); + #endif + +private: + + TIXML_STRING version; + TIXML_STRING encoding; + TIXML_STRING standalone; +}; + + +/** Any tag that tinyXml doesn't recognize is saved as an + unknown. It is a tag of text, but should not be modified. + It will be written back to the XML, unchanged, when the file + is saved. + + DTD tags get thrown into TiXmlUnknowns. +*/ +class TiXmlUnknown : public TiXmlNode +{ +public: + TiXmlUnknown() : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN ) {} + virtual ~TiXmlUnknown() {} + + TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN ) { copy.CopyTo( this ); } + TiXmlUnknown& operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); return *this; } + + /// Creates a copy of this Unknown and returns it. + virtual TiXmlNode* Clone() const; + // Print this Unknown to a FILE stream. + virtual void Print( FILE* cfile, int depth ) const; + + virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); + + virtual const TiXmlUnknown* ToUnknown() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlUnknown* ToUnknown() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + + /** Walk the XML tree visiting this node and all of its children. + */ + virtual bool Accept( TiXmlVisitor* content ) const; + +protected: + void CopyTo( TiXmlUnknown* target ) const; + + #ifdef TIXML_USE_STL + virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); + #endif + +private: + +}; + + +/** Always the top level node. A document binds together all the + XML pieces. It can be saved, loaded, and printed to the screen. + The 'value' of a document node is the xml file name. +*/ +class TiXmlDocument : public TiXmlNode +{ +public: + /// Create an empty document, that has no name. + TiXmlDocument(); + /// Create a document with a name. The name of the document is also the filename of the xml. + TiXmlDocument( const char * documentName ); + + #ifdef TIXML_USE_STL + /// Constructor. + TiXmlDocument( const std::string& documentName ); + #endif + + TiXmlDocument( const TiXmlDocument& copy ); + TiXmlDocument& operator=( const TiXmlDocument& copy ); + + virtual ~TiXmlDocument() {} + + /** Load a file using the current document value. + Returns true if successful. Will delete any existing + document data before loading. + */ + bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); + /// Save a file using the current document value. Returns true if successful. + bool SaveFile() const; + /// Load a file using the given filename. Returns true if successful. + bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); + /// Save a file using the given filename. Returns true if successful. + bool SaveFile( const char * filename ) const; + /** Load a file using the given FILE*. Returns true if successful. Note that this method + doesn't stream - the entire object pointed at by the FILE* + will be interpreted as an XML file. TinyXML doesn't stream in XML from the current + file location. Streaming may be added in the future. + */ + bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); + /// Save a file using the given FILE*. Returns true if successful. + bool SaveFile( FILE* ) const; + + #ifdef TIXML_USE_STL + bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ) ///< STL std::string version. + { + return LoadFile( filename.c_str(), encoding ); + } + bool SaveFile( const std::string& filename ) const ///< STL std::string version. + { + return SaveFile( filename.c_str() ); + } + #endif + + /** Parse the given null terminated block of xml data. Passing in an encoding to this + method (either TIXML_ENCODING_LEGACY or TIXML_ENCODING_UTF8 will force TinyXml + to use that encoding, regardless of what TinyXml might otherwise try to detect. + */ + virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); + + /** Get the root element -- the only top level element -- of the document. + In well formed XML, there should only be one. TinyXml is tolerant of + multiple elements at the document level. + */ + const TiXmlElement* RootElement() const { return FirstChildElement(); } + TiXmlElement* RootElement() { return FirstChildElement(); } + + /** If an error occurs, Error will be set to true. Also, + - The ErrorId() will contain the integer identifier of the error (not generally useful) + - The ErrorDesc() method will return the name of the error. (very useful) + - The ErrorRow() and ErrorCol() will return the location of the error (if known) + */ + bool Error() const { return error; } + + /// Contains a textual (english) description of the error if one occurs. + const char * ErrorDesc() const { return errorDesc.c_str (); } + + /** Generally, you probably want the error string ( ErrorDesc() ). But if you + prefer the ErrorId, this function will fetch it. + */ + int ErrorId() const { return errorId; } + + /** Returns the location (if known) of the error. The first column is column 1, + and the first row is row 1. A value of 0 means the row and column wasn't applicable + (memory errors, for example, have no row/column) or the parser lost the error. (An + error in the error reporting, in that case.) + + @sa SetTabSize, Row, Column + */ + int ErrorRow() const { return errorLocation.row+1; } + int ErrorCol() const { return errorLocation.col+1; } ///< The column where the error occured. See ErrorRow() + + /** SetTabSize() allows the error reporting functions (ErrorRow() and ErrorCol()) + to report the correct values for row and column. It does not change the output + or input in any way. + + By calling this method, with a tab size + greater than 0, the row and column of each node and attribute is stored + when the file is loaded. Very useful for tracking the DOM back in to + the source file. + + The tab size is required for calculating the location of nodes. If not + set, the default of 4 is used. The tabsize is set per document. Setting + the tabsize to 0 disables row/column tracking. + + Note that row and column tracking is not supported when using operator>>. + + The tab size needs to be enabled before the parse or load. Correct usage: + @verbatim + TiXmlDocument doc; + doc.SetTabSize( 8 ); + doc.Load( "myfile.xml" ); + @endverbatim + + @sa Row, Column + */ + void SetTabSize( int _tabsize ) { tabsize = _tabsize; } + + int TabSize() const { return tabsize; } + + /** If you have handled the error, it can be reset with this call. The error + state is automatically cleared if you Parse a new XML block. + */ + void ClearError() { error = false; + errorId = 0; + errorDesc = ""; + errorLocation.row = errorLocation.col = 0; + //errorLocation.last = 0; + } + + /** Write the document to standard out using formatted printing ("pretty print"). */ + void Print() const { Print( stdout, 0 ); } + + /* Write the document to a string using formatted printing ("pretty print"). This + will allocate a character array (new char[]) and return it as a pointer. The + calling code pust call delete[] on the return char* to avoid a memory leak. + */ + //char* PrintToMemory() const; + + /// Print this Document to a FILE stream. + virtual void Print( FILE* cfile, int depth = 0 ) const; + // [internal use] + void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding ); + + virtual const TiXmlDocument* ToDocument() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlDocument* ToDocument() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + + /** Walk the XML tree visiting this node and all of its children. + */ + virtual bool Accept( TiXmlVisitor* content ) const; + +protected : + // [internal use] + virtual TiXmlNode* Clone() const; + #ifdef TIXML_USE_STL + virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); + #endif + +private: + void CopyTo( TiXmlDocument* target ) const; + + bool error; + int errorId; + TIXML_STRING errorDesc; + int tabsize; + TiXmlCursor errorLocation; + bool useMicrosoftBOM; // the UTF-8 BOM were found when read. Note this, and try to write. +}; + + +/** + A TiXmlHandle is a class that wraps a node pointer with null checks; this is + an incredibly useful thing. Note that TiXmlHandle is not part of the TinyXml + DOM structure. It is a separate utility class. + + Take an example: + @verbatim + + + + + + + @endverbatim + + Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very + easy to write a *lot* of code that looks like: + + @verbatim + TiXmlElement* root = document.FirstChildElement( "Document" ); + if ( root ) + { + TiXmlElement* element = root->FirstChildElement( "Element" ); + if ( element ) + { + TiXmlElement* child = element->FirstChildElement( "Child" ); + if ( child ) + { + TiXmlElement* child2 = child->NextSiblingElement( "Child" ); + if ( child2 ) + { + // Finally do something useful. + @endverbatim + + And that doesn't even cover "else" cases. TiXmlHandle addresses the verbosity + of such code. A TiXmlHandle checks for null pointers so it is perfectly safe + and correct to use: + + @verbatim + TiXmlHandle docHandle( &document ); + TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).ToElement(); + if ( child2 ) + { + // do something useful + @endverbatim + + Which is MUCH more concise and useful. + + It is also safe to copy handles - internally they are nothing more than node pointers. + @verbatim + TiXmlHandle handleCopy = handle; + @endverbatim + + What they should not be used for is iteration: + + @verbatim + int i=0; + while ( true ) + { + TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", i ).ToElement(); + if ( !child ) + break; + // do something + ++i; + } + @endverbatim + + It seems reasonable, but it is in fact two embedded while loops. The Child method is + a linear walk to find the element, so this code would iterate much more than it needs + to. Instead, prefer: + + @verbatim + TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild( "Child" ).ToElement(); + + for( child; child; child=child->NextSiblingElement() ) + { + // do something + } + @endverbatim +*/ +class TiXmlHandle +{ +public: + /// Create a handle from any node (at any depth of the tree.) This can be a null pointer. + TiXmlHandle( TiXmlNode* _node ) { this->node = _node; } + /// Copy constructor + TiXmlHandle( const TiXmlHandle& ref ) { this->node = ref.node; } + TiXmlHandle operator=( const TiXmlHandle& ref ) { if ( &ref != this ) this->node = ref.node; return *this; } + + /// Return a handle to the first child node. + TiXmlHandle FirstChild() const; + /// Return a handle to the first child node with the given name. + TiXmlHandle FirstChild( const char * value ) const; + /// Return a handle to the first child element. + TiXmlHandle FirstChildElement() const; + /// Return a handle to the first child element with the given name. + TiXmlHandle FirstChildElement( const char * value ) const; + + /** Return a handle to the "index" child with the given name. + The first child is 0, the second 1, etc. + */ + TiXmlHandle Child( const char* value, int index ) const; + /** Return a handle to the "index" child. + The first child is 0, the second 1, etc. + */ + TiXmlHandle Child( int index ) const; + /** Return a handle to the "index" child element with the given name. + The first child element is 0, the second 1, etc. Note that only TiXmlElements + are indexed: other types are not counted. + */ + TiXmlHandle ChildElement( const char* value, int index ) const; + /** Return a handle to the "index" child element. + The first child element is 0, the second 1, etc. Note that only TiXmlElements + are indexed: other types are not counted. + */ + TiXmlHandle ChildElement( int index ) const; + + #ifdef TIXML_USE_STL + TiXmlHandle FirstChild( const std::string& _value ) const { return FirstChild( _value.c_str() ); } + TiXmlHandle FirstChildElement( const std::string& _value ) const { return FirstChildElement( _value.c_str() ); } + + TiXmlHandle Child( const std::string& _value, int index ) const { return Child( _value.c_str(), index ); } + TiXmlHandle ChildElement( const std::string& _value, int index ) const { return ChildElement( _value.c_str(), index ); } + #endif + + /** Return the handle as a TiXmlNode. This may return null. + */ + TiXmlNode* ToNode() const { return node; } + /** Return the handle as a TiXmlElement. This may return null. + */ + TiXmlElement* ToElement() const { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); } + /** Return the handle as a TiXmlText. This may return null. + */ + TiXmlText* ToText() const { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); } + /** Return the handle as a TiXmlUnknown. This may return null. + */ + TiXmlUnknown* ToUnknown() const { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); } + + /** @deprecated use ToNode. + Return the handle as a TiXmlNode. This may return null. + */ + TiXmlNode* Node() const { return ToNode(); } + /** @deprecated use ToElement. + Return the handle as a TiXmlElement. This may return null. + */ + TiXmlElement* Element() const { return ToElement(); } + /** @deprecated use ToText() + Return the handle as a TiXmlText. This may return null. + */ + TiXmlText* Text() const { return ToText(); } + /** @deprecated use ToUnknown() + Return the handle as a TiXmlUnknown. This may return null. + */ + TiXmlUnknown* Unknown() const { return ToUnknown(); } + +private: + TiXmlNode* node; +}; + + +/** Print to memory functionality. The TiXmlPrinter is useful when you need to: + + -# Print to memory (especially in non-STL mode) + -# Control formatting (line endings, etc.) + + When constructed, the TiXmlPrinter is in its default "pretty printing" mode. + Before calling Accept() you can call methods to control the printing + of the XML document. After TiXmlNode::Accept() is called, the printed document can + be accessed via the CStr(), Str(), and Size() methods. + + TiXmlPrinter uses the Visitor API. + @verbatim + TiXmlPrinter printer; + printer.SetIndent( "\t" ); + + doc.Accept( &printer ); + fprintf( stdout, "%s", printer.CStr() ); + @endverbatim +*/ +class TiXmlPrinter : public TiXmlVisitor +{ +public: + TiXmlPrinter() : depth( 0 ), simpleTextPrint( false ), + buffer(), indent( " " ), lineBreak( "\n" ) {} + + virtual bool VisitEnter( const TiXmlDocument& doc ); + virtual bool VisitExit( const TiXmlDocument& doc ); + + virtual bool VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute ); + virtual bool VisitExit( const TiXmlElement& element ); + + virtual bool Visit( const TiXmlDeclaration& declaration ); + virtual bool Visit( const TiXmlText& text ); + virtual bool Visit( const TiXmlComment& comment ); + virtual bool Visit( const TiXmlUnknown& unknown ); + + /** Set the indent characters for printing. By default 4 spaces + but tab (\t) is also useful, or null/empty string for no indentation. + */ + void SetIndent( const char* _indent ) { indent = _indent ? _indent : "" ; } + /// Query the indention string. + const char* Indent() { return indent.c_str(); } + /** Set the line breaking string. By default set to newline (\n). + Some operating systems prefer other characters, or can be + set to the null/empty string for no indenation. + */ + void SetLineBreak( const char* _lineBreak ) { lineBreak = _lineBreak ? _lineBreak : ""; } + /// Query the current line breaking string. + const char* LineBreak() { return lineBreak.c_str(); } + + /** Switch over to "stream printing" which is the most dense formatting without + linebreaks. Common when the XML is needed for network transmission. + */ + void SetStreamPrinting() { indent = ""; + lineBreak = ""; + } + /// Return the result. + const char* CStr() { return buffer.c_str(); } + /// Return the length of the result string. + size_t Size() { return buffer.size(); } + + #ifdef TIXML_USE_STL + /// Return the result. + const std::string& Str() { return buffer; } + #endif + +private: + void DoIndent() { + for( int i=0; i +#include + +#include "tinyxml.h" + +//#define DEBUG_PARSER +#if defined( DEBUG_PARSER ) +# if defined( DEBUG ) && defined( _MSC_VER ) +# include +# define TIXML_LOG OutputDebugString +# else +# define TIXML_LOG printf +# endif +#endif + +// Note tha "PutString" hardcodes the same list. This +// is less flexible than it appears. Changing the entries +// or order will break putstring. +TiXmlBase::Entity TiXmlBase::entity[ TiXmlBase::NUM_ENTITY ] = +{ + { "&", 5, '&' }, + { "<", 4, '<' }, + { ">", 4, '>' }, + { """, 6, '\"' }, + { "'", 6, '\'' } +}; + +// Bunch of unicode info at: +// http://www.unicode.org/faq/utf_bom.html +// Including the basic of this table, which determines the #bytes in the +// sequence from the lead byte. 1 placed for invalid sequences -- +// although the result will be junk, pass it through as much as possible. +// Beware of the non-characters in UTF-8: +// ef bb bf (Microsoft "lead bytes") +// ef bf be +// ef bf bf + +const unsigned char TIXML_UTF_LEAD_0 = 0xefU; +const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; +const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; + +const int TiXmlBase::utf8ByteTable[256] = +{ + // 0 1 2 3 4 5 6 7 8 9 a b c d e f + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x00 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x10 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x30 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x50 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x70 End of ASCII range + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x80 0x80 to 0xc1 invalid + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x90 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xa0 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xb0 + 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xc0 0xc2 to 0xdf 2 byte + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xd0 + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xe0 0xe0 to 0xef 3 byte + 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid +}; + + +void TiXmlBase::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length ) +{ + const unsigned long BYTE_MASK = 0xBF; + const unsigned long BYTE_MARK = 0x80; + const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; + + if (input < 0x80) + *length = 1; + else if ( input < 0x800 ) + *length = 2; + else if ( input < 0x10000 ) + *length = 3; + else if ( input < 0x200000 ) + *length = 4; + else + { *length = 0; return; } // This code won't covert this correctly anyway. + + output += *length; + + // Scary scary fall throughs. + switch (*length) + { + case 4: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 3: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 2: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 1: + --output; + *output = (char)(input | FIRST_BYTE_MARK[*length]); + } +} + + +/*static*/ int TiXmlBase::IsAlpha( unsigned char anyByte, TiXmlEncoding /*encoding*/ ) +{ + // This will only work for low-ascii, everything else is assumed to be a valid + // letter. I'm not sure this is the best approach, but it is quite tricky trying + // to figure out alhabetical vs. not across encoding. So take a very + // conservative approach. + +// if ( encoding == TIXML_ENCODING_UTF8 ) +// { + if ( anyByte < 127 ) + return isalpha( anyByte ); + else + return 1; // What else to do? The unicode set is huge...get the english ones right. +// } +// else +// { +// return isalpha( anyByte ); +// } +} + + +/*static*/ int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding /*encoding*/ ) +{ + // This will only work for low-ascii, everything else is assumed to be a valid + // letter. I'm not sure this is the best approach, but it is quite tricky trying + // to figure out alhabetical vs. not across encoding. So take a very + // conservative approach. + +// if ( encoding == TIXML_ENCODING_UTF8 ) +// { + if ( anyByte < 127 ) + return isalnum( anyByte ); + else + return 1; // What else to do? The unicode set is huge...get the english ones right. +// } +// else +// { +// return isalnum( anyByte ); +// } +} + + +class TiXmlParsingData +{ + friend class TiXmlDocument; + public: + void Stamp( const char* now, TiXmlEncoding encoding ); + + const TiXmlCursor& Cursor() const { return cursor; } + + private: + // Only used by the document! + TiXmlParsingData( const char* start, int _tabsize, int row, int col ) + { + assert( start ); + stamp = start; + tabsize = _tabsize; + cursor.row = row; + cursor.col = col; + } + + TiXmlCursor cursor; + const char* stamp; + int tabsize; +}; + + +void TiXmlParsingData::Stamp( const char* now, TiXmlEncoding encoding ) +{ + assert( now ); + + // Do nothing if the tabsize is 0. + if ( tabsize < 1 ) + { + return; + } + + // Get the current row, column. + int row = cursor.row; + int col = cursor.col; + const char* p = stamp; + assert( p ); + + while ( p < now ) + { + // Treat p as unsigned, so we have a happy compiler. + const unsigned char* pU = (const unsigned char*)p; + + // Code contributed by Fletcher Dunn: (modified by lee) + switch (*pU) { + case 0: + // We *should* never get here, but in case we do, don't + // advance past the terminating null character, ever + return; + + case '\r': + // bump down to the next line + ++row; + col = 0; + // Eat the character + ++p; + + // Check for \r\n sequence, and treat this as a single character + if (*p == '\n') { + ++p; + } + break; + + case '\n': + // bump down to the next line + ++row; + col = 0; + + // Eat the character + ++p; + + // Check for \n\r sequence, and treat this as a single + // character. (Yes, this bizarre thing does occur still + // on some arcane platforms...) + if (*p == '\r') { + ++p; + } + break; + + case '\t': + // Eat the character + ++p; + + // Skip to next tab stop + col = (col / tabsize + 1) * tabsize; + break; + + case TIXML_UTF_LEAD_0: + if ( encoding == TIXML_ENCODING_UTF8 ) + { + if ( *(p+1) && *(p+2) ) + { + // In these cases, don't advance the column. These are + // 0-width spaces. + if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 ) + p += 3; + else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU ) + p += 3; + else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU ) + p += 3; + else + { p +=3; ++col; } // A normal character. + } + } + else + { + ++p; + ++col; + } + break; + + default: + if ( encoding == TIXML_ENCODING_UTF8 ) + { + // Eat the 1 to 4 byte utf8 character. + int step = TiXmlBase::utf8ByteTable[*((const unsigned char*)p)]; + if ( step == 0 ) + step = 1; // Error case from bad encoding, but handle gracefully. + p += step; + + // Just advance one column, of course. + ++col; + } + else + { + ++p; + ++col; + } + break; + } + } + cursor.row = row; + cursor.col = col; + assert( cursor.row >= -1 ); + assert( cursor.col >= -1 ); + stamp = p; + assert( stamp ); +} + + +const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding ) +{ + if ( !p || !*p ) + { + return 0; + } + if ( encoding == TIXML_ENCODING_UTF8 ) + { + while ( *p ) + { + const unsigned char* pU = (const unsigned char*)p; + + // Skip the stupid Microsoft UTF-8 Byte order marks + if ( *(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==TIXML_UTF_LEAD_1 + && *(pU+2)==TIXML_UTF_LEAD_2 ) + { + p += 3; + continue; + } + else if(*(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==0xbfU + && *(pU+2)==0xbeU ) + { + p += 3; + continue; + } + else if(*(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==0xbfU + && *(pU+2)==0xbfU ) + { + p += 3; + continue; + } + + if ( IsWhiteSpace( *p ) ) // Still using old rules for white space. + ++p; + else + break; + } + } + else + { + while ( *p && IsWhiteSpace( *p ) ) + ++p; + } + + return p; +} + +#ifdef TIXML_USE_STL +/*static*/ bool TiXmlBase::StreamWhiteSpace( std::istream * in, TIXML_STRING * tag ) +{ + for( ;; ) + { + if ( !in->good() ) return false; + + int c = in->peek(); + // At this scope, we can't get to a document. So fail silently. + if ( !IsWhiteSpace( c ) || c <= 0 ) + return true; + + *tag += (char) in->get(); + } +} + +/*static*/ bool TiXmlBase::StreamTo( std::istream * in, int character, TIXML_STRING * tag ) +{ + //assert( character > 0 && character < 128 ); // else it won't work in utf-8 + while ( in->good() ) + { + int c = in->peek(); + if ( c == character ) + return true; + if ( c <= 0 ) // Silent failure: can't get document at this scope + return false; + + in->get(); + *tag += (char) c; + } + return false; +} +#endif + +// One of TinyXML's more performance demanding functions. Try to keep the memory overhead down. The +// "assign" optimization removes over 10% of the execution time. +// +const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding ) +{ + // Oddly, not supported on some comilers, + //name->clear(); + // So use this: + *name = ""; + assert( p ); + + // Names start with letters or underscores. + // Of course, in unicode, tinyxml has no idea what a letter *is*. The + // algorithm is generous. + // + // After that, they can be letters, underscores, numbers, + // hyphens, or colons. (Colons are valid ony for namespaces, + // but tinyxml can't tell namespaces from names.) + if ( p && *p + && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) ) + { + const char* start = p; + while( p && *p + && ( IsAlphaNum( (unsigned char ) *p, encoding ) + || *p == '_' + || *p == '-' + || *p == '.' + || *p == ':' ) ) + { + //(*name) += *p; // expensive + ++p; + } + if ( p-start > 0 ) { + name->assign( start, p-start ); + } + return p; + } + return 0; +} + +const char* TiXmlBase::GetEntity( const char* p, char* value, int* length, TiXmlEncoding encoding ) +{ + // Presume an entity, and pull it out. + TIXML_STRING ent; + int i; + *length = 0; + + if ( *(p+1) && *(p+1) == '#' && *(p+2) ) + { + unsigned long ucs = 0; + ptrdiff_t delta = 0; + unsigned mult = 1; + + if ( *(p+2) == 'x' ) + { + // Hexadecimal. + if ( !*(p+3) ) return 0; + + const char* q = p+3; + q = strchr( q, ';' ); + + if ( !q || !*q ) return 0; + + delta = q-p; + --q; + + while ( *q != 'x' ) + { + if ( *q >= '0' && *q <= '9' ) + ucs += mult * (*q - '0'); + else if ( *q >= 'a' && *q <= 'f' ) + ucs += mult * (*q - 'a' + 10); + else if ( *q >= 'A' && *q <= 'F' ) + ucs += mult * (*q - 'A' + 10 ); + else + return 0; + mult *= 16; + --q; + } + } + else + { + // Decimal. + if ( !*(p+2) ) return 0; + + const char* q = p+2; + q = strchr( q, ';' ); + + if ( !q || !*q ) return 0; + + delta = q-p; + --q; + + while ( *q != '#' ) + { + if ( *q >= '0' && *q <= '9' ) + ucs += mult * (*q - '0'); + else + return 0; + mult *= 10; + --q; + } + } + if ( encoding == TIXML_ENCODING_UTF8 ) + { + // convert the UCS to UTF-8 + ConvertUTF32ToUTF8( ucs, value, length ); + } + else + { + *value = (char)ucs; + *length = 1; + } + return p + delta + 1; + } + + // Now try to match it. + for( i=0; iappend( cArr, len ); + } + } + else + { + bool whitespace = false; + + // Remove leading white space: + p = SkipWhiteSpace( p, encoding ); + while ( p && *p + && !StringEqual( p, endTag, caseInsensitive, encoding ) ) + { + if ( *p == '\r' || *p == '\n' ) + { + whitespace = true; + ++p; + } + else if ( IsWhiteSpace( *p ) ) + { + whitespace = true; + ++p; + } + else + { + // If we've found whitespace, add it before the + // new character. Any whitespace just becomes a space. + if ( whitespace ) + { + (*text) += ' '; + whitespace = false; + } + int len; + char cArr[4] = { 0, 0, 0, 0 }; + p = GetChar( p, cArr, &len, encoding ); + if ( len == 1 ) + (*text) += cArr[0]; // more efficient + else + text->append( cArr, len ); + } + } + } + if ( p && *p ) + p += strlen( endTag ); + return ( p && *p ) ? p : 0; +} + +#ifdef TIXML_USE_STL + +void TiXmlDocument::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + // The basic issue with a document is that we don't know what we're + // streaming. Read something presumed to be a tag (and hope), then + // identify it, and call the appropriate stream method on the tag. + // + // This "pre-streaming" will never read the closing ">" so the + // sub-tag can orient itself. + + if ( !StreamTo( in, '<', tag ) ) + { + SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + + while ( in->good() ) + { + int tagIndex = (int) tag->length(); + while ( in->good() && in->peek() != '>' ) + { + int c = in->get(); + if ( c <= 0 ) + { + SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + break; + } + (*tag) += (char) c; + } + + if ( in->good() ) + { + // We now have something we presume to be a node of + // some sort. Identify it, and call the node to + // continue streaming. + TiXmlNode* node = Identify( tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING ); + + if ( node ) + { + node->StreamIn( in, tag ); + bool isElement = node->ToElement() != 0; + delete node; + node = 0; + + // If this is the root element, we're done. Parsing will be + // done by the >> operator. + if ( isElement ) + { + return; + } + } + else + { + SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + } + } + // We should have returned sooner. + SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN ); +} + +#endif + +const char* TiXmlDocument::Parse( const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding ) +{ + ClearError(); + + // Parse away, at the document level. Since a document + // contains nothing but other tags, most of what happens + // here is skipping white space. + if ( !p || !*p ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + // Note that, for a document, this needs to come + // before the while space skip, so that parsing + // starts from the pointer we are given. + location.Clear(); + if ( prevData ) + { + location.row = prevData->cursor.row; + location.col = prevData->cursor.col; + } + else + { + location.row = 0; + location.col = 0; + } + TiXmlParsingData data( p, TabSize(), location.row, location.col ); + location = data.Cursor(); + + if ( encoding == TIXML_ENCODING_UNKNOWN ) + { + // Check for the Microsoft UTF-8 lead bytes. + const unsigned char* pU = (const unsigned char*)p; + if ( *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0 + && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1 + && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 ) + { + encoding = TIXML_ENCODING_UTF8; + useMicrosoftBOM = true; + } + } + + p = SkipWhiteSpace( p, encoding ); + if ( !p ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + while ( p && *p ) + { + TiXmlNode* node = Identify( p, encoding ); + if ( node ) + { + p = node->Parse( p, &data, encoding ); + LinkEndChild( node ); + } + else + { + break; + } + + // Did we get encoding info? + if ( encoding == TIXML_ENCODING_UNKNOWN + && node->ToDeclaration() ) + { + TiXmlDeclaration* dec = node->ToDeclaration(); + const char* enc = dec->Encoding(); + assert( enc ); + + if ( *enc == 0 ) + encoding = TIXML_ENCODING_UTF8; + else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) ) + encoding = TIXML_ENCODING_UTF8; + else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) ) + encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice + else + encoding = TIXML_ENCODING_LEGACY; + } + + p = SkipWhiteSpace( p, encoding ); + } + + // Was this empty? + if ( !firstChild ) { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding ); + return 0; + } + + // All is well. + return p; +} + +void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + // The first error in a chain is more accurate - don't set again! + if ( error ) + return; + + assert( err > 0 && err < TIXML_ERROR_STRING_COUNT ); + error = true; + errorId = err; + errorDesc = errorString[ errorId ]; + + errorLocation.Clear(); + if ( pError && data ) + { + data->Stamp( pError, encoding ); + errorLocation = data->Cursor(); + } +} + + +TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding ) +{ + TiXmlNode* returnNode = 0; + + p = SkipWhiteSpace( p, encoding ); + if( !p || !*p || *p != '<' ) + { + return 0; + } + + p = SkipWhiteSpace( p, encoding ); + + if ( !p || !*p ) + { + return 0; + } + + // What is this thing? + // - Elements start with a letter or underscore, but xml is reserved. + // - Comments: "; + + if ( !StringEqual( p, startTag, false, encoding ) ) + { + if ( document ) + document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding ); + return 0; + } + p += strlen( startTag ); + + // [ 1475201 ] TinyXML parses entities in comments + // Oops - ReadText doesn't work, because we don't want to parse the entities. + // p = ReadText( p, &value, false, endTag, false, encoding ); + // + // from the XML spec: + /* + [Definition: Comments may appear anywhere in a document outside other markup; in addition, + they may appear within the document type declaration at places allowed by the grammar. + They are not part of the document's character data; an XML processor MAY, but need not, + make it possible for an application to retrieve the text of comments. For compatibility, + the string "--" (double-hyphen) MUST NOT occur within comments.] Parameter entity + references MUST NOT be recognized within comments. + + An example of a comment: + + + */ + + value = ""; + // Keep all the white space. + while ( p && *p && !StringEqual( p, endTag, false, encoding ) ) + { + value.append( p, 1 ); + ++p; + } + if ( p && *p ) + p += strlen( endTag ); + + return p; +} + + +const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p ) return 0; + + if ( data ) + { + data->Stamp( p, encoding ); + location = data->Cursor(); + } + // Read the name, the '=' and the value. + const char* pErr = p; + p = ReadName( p, &name, encoding ); + if ( !p || !*p ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding ); + return 0; + } + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p || *p != '=' ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + + ++p; // skip '=' + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + + const char* end; + const char SINGLE_QUOTE = '\''; + const char DOUBLE_QUOTE = '\"'; + + if ( *p == SINGLE_QUOTE ) + { + ++p; + end = "\'"; // single quote in string + p = ReadText( p, &value, false, end, false, encoding ); + } + else if ( *p == DOUBLE_QUOTE ) + { + ++p; + end = "\""; // double quote in string + p = ReadText( p, &value, false, end, false, encoding ); + } + else + { + // All attribute values should be in single or double quotes. + // But this is such a common error that the parser will try + // its best, even without them. + value = ""; + while ( p && *p // existence + && !IsWhiteSpace( *p ) // whitespace + && *p != '/' && *p != '>' ) // tag end + { + if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) { + // [ 1451649 ] Attribute values with trailing quotes not handled correctly + // We did not have an opening quote but seem to have a + // closing one. Give up and throw an error. + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + value += *p; + ++p; + } + } + return p; +} + +#ifdef TIXML_USE_STL +void TiXmlText::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + while ( in->good() ) + { + int c = in->peek(); + if ( !cdata && (c == '<' ) ) + { + return; + } + if ( c <= 0 ) + { + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + + (*tag) += (char) c; + in->get(); // "commits" the peek made above + + if ( cdata && c == '>' && tag->size() >= 3 ) { + size_t len = tag->size(); + if ( (*tag)[len-2] == ']' && (*tag)[len-3] == ']' ) { + // terminator of cdata. + return; + } + } + } +} +#endif + +const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + value = ""; + TiXmlDocument* document = GetDocument(); + + if ( data ) + { + data->Stamp( p, encoding ); + location = data->Cursor(); + } + + const char* const startTag = ""; + + if ( cdata || StringEqual( p, startTag, false, encoding ) ) + { + cdata = true; + + if ( !StringEqual( p, startTag, false, encoding ) ) + { + if ( document ) + document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding ); + return 0; + } + p += strlen( startTag ); + + // Keep all the white space, ignore the encoding, etc. + while ( p && *p + && !StringEqual( p, endTag, false, encoding ) + ) + { + value += *p; + ++p; + } + + TIXML_STRING dummy; + p = ReadText( p, &dummy, false, endTag, false, encoding ); + return p; + } + else + { + bool ignoreWhite = true; + + const char* end = "<"; + p = ReadText( p, &value, ignoreWhite, end, false, encoding ); + if ( p && *p ) + return p-1; // don't truncate the '<' + return 0; + } +} + +#ifdef TIXML_USE_STL +void TiXmlDeclaration::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + while ( in->good() ) + { + int c = in->get(); + if ( c <= 0 ) + { + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + (*tag) += (char) c; + + if ( c == '>' ) + { + // All is well. + return; + } + } +} +#endif + +const char* TiXmlDeclaration::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding _encoding ) +{ + p = SkipWhiteSpace( p, _encoding ); + // Find the beginning, find the end, and look for + // the stuff in-between. + TiXmlDocument* document = GetDocument(); + if ( !p || !*p || !StringEqual( p, "SetError( TIXML_ERROR_PARSING_DECLARATION, 0, 0, _encoding ); + return 0; + } + if ( data ) + { + data->Stamp( p, _encoding ); + location = data->Cursor(); + } + p += 5; + + version = ""; + encoding = ""; + standalone = ""; + + while ( p && *p ) + { + if ( *p == '>' ) + { + ++p; + return p; + } + + p = SkipWhiteSpace( p, _encoding ); + if ( StringEqual( p, "version", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + version = attrib.Value(); + } + else if ( StringEqual( p, "encoding", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + encoding = attrib.Value(); + } + else if ( StringEqual( p, "standalone", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + standalone = attrib.Value(); + } + else + { + // Read over whatever it is. + while( p && *p && *p != '>' && !IsWhiteSpace( *p ) ) + ++p; + } + } + return 0; +} + +bool TiXmlText::Blank() const +{ + for ( unsigned i=0; i= 1200)) || (defined(_CVI_) && (_CVI_ >= 700)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x0520)) +typedef unsigned __int64 ViUInt64; +typedef _VI_SIGNED __int64 ViInt64; +#define _VI_INT64_UINT64_DEFINED +#if defined(_WIN64) +#define _VISA_ENV_IS_64_BIT +#else +/* This is a 32-bit OS, not a 64-bit OS */ +#endif +#endif +#elif defined(__GNUC__) && (__GNUC__ >= 3) +#include +#include +typedef u_int64_t ViUInt64; +typedef int64_t ViInt64; +#define _VI_INT64_UINT64_DEFINED +#if defined(LONG_MAX) && (LONG_MAX > 0x7FFFFFFFL) +#define _VISA_ENV_IS_64_BIT +#else +/* This is a 32-bit OS, not a 64-bit OS */ +#endif +#else +/* This platform does not support 64-bit types */ +#endif +#endif + +#if defined(_VI_INT64_UINT64_DEFINED) +typedef ViUInt64 _VI_PTR ViPUInt64; +typedef ViUInt64 _VI_PTR ViAUInt64; +typedef ViInt64 _VI_PTR ViPInt64; +typedef ViInt64 _VI_PTR ViAInt64; +#endif + +#if defined(LONG_MAX) && (LONG_MAX > 0x7FFFFFFFL) +typedef unsigned int ViUInt32; +typedef _VI_SIGNED int ViInt32; +#else +typedef unsigned long ViUInt32; +typedef _VI_SIGNED long ViInt32; +#endif + +typedef ViUInt32 _VI_PTR ViPUInt32; +typedef ViUInt32 _VI_PTR ViAUInt32; +typedef ViInt32 _VI_PTR ViPInt32; +typedef ViInt32 _VI_PTR ViAInt32; + +typedef unsigned short ViUInt16; +typedef ViUInt16 _VI_PTR ViPUInt16; +typedef ViUInt16 _VI_PTR ViAUInt16; + +typedef _VI_SIGNED short ViInt16; +typedef ViInt16 _VI_PTR ViPInt16; +typedef ViInt16 _VI_PTR ViAInt16; + +typedef unsigned char ViUInt8; +typedef ViUInt8 _VI_PTR ViPUInt8; +typedef ViUInt8 _VI_PTR ViAUInt8; + +typedef _VI_SIGNED char ViInt8; +typedef ViInt8 _VI_PTR ViPInt8; +typedef ViInt8 _VI_PTR ViAInt8; + +typedef char ViChar; +typedef ViChar _VI_PTR ViPChar; +typedef ViChar _VI_PTR ViAChar; + +typedef unsigned char ViByte; +typedef ViByte _VI_PTR ViPByte; +typedef ViByte _VI_PTR ViAByte; + +typedef void _VI_PTR ViAddr; +typedef ViAddr _VI_PTR ViPAddr; +typedef ViAddr _VI_PTR ViAAddr; + +typedef float ViReal32; +typedef ViReal32 _VI_PTR ViPReal32; +typedef ViReal32 _VI_PTR ViAReal32; + +typedef double ViReal64; +typedef ViReal64 _VI_PTR ViPReal64; +typedef ViReal64 _VI_PTR ViAReal64; + +typedef ViPByte ViBuf; +typedef ViPByte ViPBuf; +typedef ViPByte _VI_PTR ViABuf; + +typedef ViPChar ViString; +typedef ViPChar ViPString; +typedef ViPChar _VI_PTR ViAString; + +typedef ViString ViRsrc; +typedef ViString ViPRsrc; +typedef ViString _VI_PTR ViARsrc; + +typedef ViUInt16 ViBoolean; +typedef ViBoolean _VI_PTR ViPBoolean; +typedef ViBoolean _VI_PTR ViABoolean; + +typedef ViInt32 ViStatus; +typedef ViStatus _VI_PTR ViPStatus; +typedef ViStatus _VI_PTR ViAStatus; + +typedef ViUInt32 ViVersion; +typedef ViVersion _VI_PTR ViPVersion; +typedef ViVersion _VI_PTR ViAVersion; + +typedef ViUInt32 ViObject; +typedef ViObject _VI_PTR ViPObject; +typedef ViObject _VI_PTR ViAObject; + +typedef ViObject ViSession; +typedef ViSession _VI_PTR ViPSession; +typedef ViSession _VI_PTR ViASession; + +typedef ViUInt32 ViAttr; + +#ifndef _VI_CONST_STRING_DEFINED +typedef const ViChar * ViConstString; +#define _VI_CONST_STRING_DEFINED +#endif + +/*- Completion and Error Codes ----------------------------------------------*/ + +#define VI_SUCCESS (0L) + +/*- Other VISA Definitions --------------------------------------------------*/ + +#define VI_NULL (0) + +#define VI_TRUE (1) +#define VI_FALSE (0) + +/*- Backward Compatibility Macros -------------------------------------------*/ + +#define VISAFN _VI_FUNC +#define ViPtr _VI_PTR + +#endif + +/*- The End -----------------------------------------------------------------*/ + diff --git a/LaipuDrawing/vpptype.h b/LaipuDrawing/vpptype.h new file mode 100644 index 0000000..e19a637 --- /dev/null +++ b/LaipuDrawing/vpptype.h @@ -0,0 +1,46 @@ +/*---------------------------------------------------------------------------*/ +/* Distributed by VXIplug&play Systems Alliance */ +/* */ +/* Do not modify the contents of this file. */ +/*---------------------------------------------------------------------------*/ +/* */ +/* Title : VPPTYPE.H */ +/* Date : 02-14-95 */ +/* Purpose : VXIplug&play instrument driver header file */ +/* */ +/*---------------------------------------------------------------------------*/ + +#ifndef __VPPTYPE_HEADER__ +#define __VPPTYPE_HEADER__ + +#include "visatype.h" + +/*- Completion and Error Codes ----------------------------------------------*/ + +#define VI_WARN_NSUP_ID_QUERY ( 0x3FFC0101L) +#define VI_WARN_NSUP_RESET ( 0x3FFC0102L) +#define VI_WARN_NSUP_SELF_TEST ( 0x3FFC0103L) +#define VI_WARN_NSUP_ERROR_QUERY ( 0x3FFC0104L) +#define VI_WARN_NSUP_REV_QUERY ( 0x3FFC0105L) + +#define VI_ERROR_PARAMETER1 (_VI_ERROR+0x3FFC0001L) +#define VI_ERROR_PARAMETER2 (_VI_ERROR+0x3FFC0002L) +#define VI_ERROR_PARAMETER3 (_VI_ERROR+0x3FFC0003L) +#define VI_ERROR_PARAMETER4 (_VI_ERROR+0x3FFC0004L) +#define VI_ERROR_PARAMETER5 (_VI_ERROR+0x3FFC0005L) +#define VI_ERROR_PARAMETER6 (_VI_ERROR+0x3FFC0006L) +#define VI_ERROR_PARAMETER7 (_VI_ERROR+0x3FFC0007L) +#define VI_ERROR_PARAMETER8 (_VI_ERROR+0x3FFC0008L) +#define VI_ERROR_FAIL_ID_QUERY (_VI_ERROR+0x3FFC0011L) +#define VI_ERROR_INV_RESPONSE (_VI_ERROR+0x3FFC0012L) + + +/*- Additional Definitions --------------------------------------------------*/ + +#define VI_ON (1) +#define VI_OFF (0) + +#endif + +/*- The End -----------------------------------------------------------------*/ + diff --git a/LaipuDrawing/对话框模板.cpp b/LaipuDrawing/对话框模板.cpp new file mode 100644 index 0000000..1793e8f --- /dev/null +++ b/LaipuDrawing/对话框模板.cpp @@ -0,0 +1,40 @@ + +#include "stdafx.h" +#include "LaiPuLaser.h" +#include "afxdialogex.h" +#include "Dlgxxxxxxxxx.h" + +IMPLEMENT_DYNAMIC(CDlgxxxxxxxxxxx, CDialogEx) +BEGIN_MESSAGE_MAP(CDlgxxxxxxxxxxx, CDialogEx) + ON_BN_CLICKED(IDOK,OnBnClickedOk) +END_MESSAGE_MAP() + + +CDlgxxxxxxxxxxx::CDlgxxxxxxxxxxx(CWnd* pParent /*=NULL*/) +: CDialogEx(CDlgxxxxxxxxxxx::IDD, pParent) +{ +} + +CDlgxxxxxxxxxxx::~CDlgxxxxxxxxxxx() +{ +} + +void CDlgxxxxxxxxxxx::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); + +} + +BOOL CDlgxxxxxxxxxxx::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + + UpdateData(FALSE); + return TRUE; +} + +void CDlgxxxxxxxxxxx::OnBnClickedOk() +{ + + OnOK(); +} \ No newline at end of file diff --git a/LaipuDrawing/对话框模板.h b/LaipuDrawing/对话框模板.h new file mode 100644 index 0000000..fc2840d --- /dev/null +++ b/LaipuDrawing/对话框模板.h @@ -0,0 +1,19 @@ +#pragma once + +class CDlgxxxxxxxxxxx : public CDialogEx +{ + DECLARE_DYNAMIC(CDlgxxxxxxxxxxx) + +public: + CDlgxxxxxxxxxxx(CWnd* pParent = NULL); // ׼캯 + virtual ~CDlgxxxxxxxxxxx(); + +// Ի + enum { IDD = IDD_XXXXXXXXX_DLG }; +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ֧ + virtual BOOL OnInitDialog(); + afx_msg void OnBnClickedOk(); + DECLARE_MESSAGE_MAP() + +}; diff --git a/LaipuDrawing/模块模板ModuleExample.cpp b/LaipuDrawing/模块模板ModuleExample.cpp new file mode 100644 index 0000000..bf8fd98 --- /dev/null +++ b/LaipuDrawing/模块模板ModuleExample.cpp @@ -0,0 +1,54 @@ +#include "StdAfx.h" +#include "ModuleExample.h" +#include "Propertie.h" +#include "PropertieMgr.h" +#include "AuthorityMgr.h" + + +CModuleExample *gModuleExample = new CModuleExample; +CModuleExample::CModuleExample(void) +{ + +} +CModuleExample::~CModuleExample(void) +{ + +} +CMFCPropertyGridProperty *CModuleExample::CreatGridProperty() +{ + CString PropertyName;// + CString Description;// + CString Path = GetParDirName();//洢· + CString Name; + CString GroupName; + CString ModuleName; +//-------------------------------------------------------------------------------// + PropertyName = _T(""); + GroupName = PropertyName; + CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName); +//-------------------------------------------------------------------------------// + if(gAuthorityMgr->CheckAuthority(_Authority_Factory)) + { + { + //Աӳ + Name = _T("m_bEnglishMode");// + CPropertie *pPropertie = new CPropertie; + pPropertie->SetpVal((void*)&m_bEnglishMode); + pPropertie->SetType(_PROP_TYPE_BOOL); + pPropertie->SetpModule(this); + pPropertie->SetPath(Path); + pPropertie->SetName(Name); + pPropertie->WriteRead(true);//ȡ + //ʾ + PropertyName = _T("Ӣģʽ"); + Description = _T("Ӣģʽ"); + pPropertie->SetGroupName(GroupName); + pPropertie->SetShowName(PropertyName); + CMFCPropertyGridProperty* p1 = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bEnglishMode, Description); + pGroup->AddSubItem(p1); + gDevicePropertieMgr.Insert(p1, pPropertie); + } + } + return pGroup; +} + diff --git a/LaipuDrawing/模块模板ModuleExample.h b/LaipuDrawing/模块模板ModuleExample.h new file mode 100644 index 0000000..15ad5fb --- /dev/null +++ b/LaipuDrawing/模块模板ModuleExample.h @@ -0,0 +1,19 @@ +#pragma once +#include "module.h" + +class CModuleExample :public CModule +{ +public: + CModuleExample(void); + ~CModuleExample(void); + virtual CMFCPropertyGridProperty *CreatGridProperty(); + virtual MODULE GetModuleType(){return _MODULE_NULL;}; + virtual CString GetParDirName(){return "ModuleExample";}; + +private: + +private: + +}; + +extern CModuleExample *gModuleExample; \ No newline at end of file