blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 5
146
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
7
| license_type
stringclasses 2
values | repo_name
stringlengths 6
79
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 4
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 5.07k
426M
⌀ | star_events_count
int64 0
27
| fork_events_count
int64 0
12
| gha_license_id
stringclasses 3
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 6
values | src_encoding
stringclasses 26
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 1
class | length_bytes
int64 20
6.28M
| extension
stringclasses 20
values | content
stringlengths 20
6.28M
| authors
listlengths 1
16
| author_lines
listlengths 1
16
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2727e4a87774d00d314b4d4b50c485ef7412c3da | 0c5fd443401312fafae18ea6a9d17bac9ee61474 | /code/engine/View/PlaneCreation.h | dd319dcbb37200d88f1f6ee4c9888ffc6a926d1e | []
| no_license | nurF/Brute-Force-Game-Engine | fcfebc997d6ab487508a5706b849e9d7bc66792d | b930472429ec6d6f691230e36076cd2c868d853d | refs/heads/master | 2021-01-18T09:29:44.038036 | 2011-12-02T17:31:59 | 2011-12-02T17:31:59 | 2,877,061 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,977 | h | /* ___ _________ ____ __
/ _ )/ __/ ___/____/ __/___ ___ _/_/___ ___
/ _ / _// (_ //___/ _/ / _ | _ `/ // _ | -_)
/____/_/ \___/ /___//_//_|_, /_//_//_|__/
/___/
This file is part of the Brute-Force Game Engine, BFG-Engine
For the latest info, see http://www.brute-force-games.com
Copyright (c) 2011 Brute-Force Games GbR
The BFG-Engine is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
The BFG-Engine is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with the BFG-Engine. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BFG_VIEW_PLANE_CREATION_H_
#define BFG_VIEW_PLANE_CREATION_H_
#include <Core/CharArray.h>
#include <Core/Types.h>
#include <Core/qv4.h>
#include <Core/v3.h>
#include <View/Defs.h>
#include <View/Enums.hh>
#include <OgrePlane.h>
namespace BFG {
namespace View {
struct VIEW_API PlaneCreation
{
PlaneCreation(GameHandle parent,
GameHandle handle,
const std::string& name,
const v3& planeNormal,
const double& normalDistance,
const double& width,
const double& height,
const qv4& orientation);
GameHandle mParent;
GameHandle mHandle;
CharArray128T mMeshName;
v3 mPlaneNormal;
double mNormalDistance;
double mWidth;
double mHeight;
qv4 mOrientation;
};
} //namespace View
} //namespace BFG
#endif // BFG_VIEW_PLANE_CREATION_H_
| [
"[email protected]"
]
| [
[
[
1,
67
]
]
]
|
c24b8bef9ff9b6692cc99ed58445bda32e1fee8c | cc946ca4fb4831693af2c6f252100b9a83cfc7d0 | /uCash.Cybos/uCash.Cybos.CpStockCode.cpp | ffde685b16876135390b97b432e421ba6d581d26 | []
| no_license | primespace/ucash-cybos | 18b8b324689516e08cf6d0124d8ad19c0f316d68 | 1ccece53844fad0ef8f3abc8bbb51dadafc75ab7 | refs/heads/master | 2021-01-10T04:42:53.966915 | 2011-10-14T07:15:33 | 2011-10-14T07:15:33 | 52,243,596 | 7 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,420 | cpp | /*
* uCash.Cybos Copyright (c) 2011 Taeyoung Park ([email protected])
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
#include "stdafx.h"
#include "uCash.Cybos.Export.h"
#include "uCash.Cybos.CpStockCodeObject.h"
#include "uCash.Cybos.CpStockCode.h"
namespace uCash { namespace Cybos {
CpStockCode::CpStockCode()
{}
CpStockCode::~CpStockCode()
{}
}} | [
"[email protected]"
]
| [
[
[
1,
35
]
]
]
|
eb6a28b53c175982d5f4044e1381501d6722298c | 6ea2685ec9aa4be984ea0febb7eefc2f3bc544c9 | /NetGen.h | 687ba0e55eac0ef5976c72bf68172e2cf05f9d43 | []
| no_license | vpatrinica/pernute | f047445a373f79209f0e32c1bf810d90c3d6289f | e2c0bf4161ccb4e768e7b64ecd2a021e51319383 | refs/heads/master | 2021-01-02T22:31:07.174479 | 2010-05-13T21:13:34 | 2010-05-13T21:13:34 | 39,997,926 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,111 | h | #pragma once
#if defined(_DEBUG) && !defined(AC_FULL_DEBUG)
#error _DEBUG should not be defined except in internal Adesk debug builds
#endif
#include "aced.h"
#include "dbsymtb.h"
#include "dbapserv.h"
#include "acgi.h"
#include "tchar.h"
#include <list>
#include <stdio.h>
#include <iostream>
#include <ADSLIB.H>
#include "ResbufPtr.h"
#include "FramePointsBuilder.h"
#include "LineFrameBuilder.h"
#include "dbobjptr.h"
#include "dbspline.h"
#include "FramePointsConstructor.h"
#include "InteriorPointsConstructor.h"
#include "InputReader.h"
class NetGen: public AcDbEntity
{
public:
ACRX_DECLARE_MEMBERS(NetGen);
NetGen();
virtual ~NetGen();
void readInput();
Acad::ErrorStatus processInput(AcDbObjectIdArray& );
Acad::ErrorStatus doNet();
Acad::ErrorStatus outputNet();
protected:
virtual Adesk::Boolean subWorldDraw(AcGiWorldDraw* );
Acad::ErrorStatus subTransformBy(const AcGeMatrix3d& );
private:
InputReader* _inputReader;
FramePointsConstructor * _fpConstructor;
InteriorPointsConstructor * _ipConstructor;
};
| [
"v.patrinica@4687759a-75b2-d36a-a905-7d4f9b7d90e1"
]
| [
[
[
1,
52
]
]
]
|
d3f542f2e225cb262881bbac19b1836bb2e8f425 | 1e976ee65d326c2d9ed11c3235a9f4e2693557cf | /XmlNodeWrapper.cpp | 4c21c9be71e2ced83f04bd756c877df2f5b6b15d | []
| no_license | outcast1000/Jaangle | 062c7d8d06e058186cb65bdade68a2ad8d5e7e65 | 18feb537068f1f3be6ecaa8a4b663b917c429e3d | refs/heads/master | 2020-04-08T20:04:56.875651 | 2010-12-25T10:44:38 | 2010-12-25T10:44:38 | 19,334,292 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,685 | cpp | // XmlNodeWrapper.cpp: implementation of the CXmlNodeWrapper class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "XmlNodeWrapper.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CXmlNodeWrapper::CXmlNodeWrapper()
{
}
CXmlNodeWrapper::CXmlNodeWrapper(MSXML2::IXMLDOMNodePtr pNode,BOOL bAutoRelease)
{
m_xmlnode = pNode;
m_bAutoRelease = bAutoRelease;
}
void CXmlNodeWrapper::operator=(MSXML2::IXMLDOMNodePtr pNode)
{
if (IsValid())
m_xmlnode.Release();
m_xmlnode = pNode;
}
CXmlNodeWrapper::~CXmlNodeWrapper()
{
if (!m_bAutoRelease)
m_xmlnode.Detach();
}
CString CXmlNodeWrapper::GetValue(LPCTSTR valueName)
{
if (!IsValid())
return _T("");
MSXML2::IXMLDOMNodePtr attribute = m_xmlnode->Getattributes()->getNamedItem(valueName);
if (attribute)
{
return (LPCTSTR)attribute->Gettext();
}
return _T("");
}
BOOL CXmlNodeWrapper::IsValid()
{
if (m_xmlnode == NULL)
return FALSE;
if (m_xmlnode.GetInterfacePtr() == NULL)
return FALSE;
return TRUE;
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::GetPrevSibling()
{
if (!IsValid())
return NULL;
return m_xmlnode->GetpreviousSibling().Detach();
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::GetNextSibling()
{
if (!IsValid())
return NULL;
return m_xmlnode->GetnextSibling().Detach();
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::GetNode(LPCTSTR nodeName)
{
if (!IsValid())
return NULL;
try{
return m_xmlnode->selectSingleNode(nodeName).Detach();
}
catch (_com_error e)
{
CString err = e.ErrorMessage();
}
return NULL;
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::GetNode(int nodeIndex)
{
if (!IsValid())
return NULL;
return m_xmlnode->GetchildNodes()->Getitem(nodeIndex).Detach();
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::FindNode(LPCTSTR searchString)
{
if (!IsValid())
return NULL;
try{
return m_xmlnode->selectSingleNode(searchString).Detach();
}
catch (_com_error e)
{
CString err = e.ErrorMessage();
}
return NULL;
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::Detach()
{
if (IsValid())
{
return m_xmlnode.Detach();
}
else
return NULL;
}
long CXmlNodeWrapper::NumNodes()
{
if (IsValid())
{
return m_xmlnode->GetchildNodes()->Getlength();
}
else
return 0;
}
void CXmlNodeWrapper::SetValue(LPCTSTR valueName,LPCTSTR value)
{
MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
if (xmlDocument)
{
MSXML2::IXMLDOMNamedNodeMapPtr attributes = m_xmlnode->Getattributes();
if (attributes)
{
MSXML2::IXMLDOMAttributePtr attribute = xmlDocument->createAttribute(valueName);
if (attribute)
{
attribute->Puttext(value);
attributes->setNamedItem(attribute);
}
}
}
}
void CXmlNodeWrapper::SetValue(LPCTSTR valueName,int value)
{
CString str;
str.Format(_T("%ld"),value);
SetValue(valueName,str);
}
void CXmlNodeWrapper::SetValue(LPCTSTR valueName,short value)
{
CString str;
str.Format(_T("%hd"),value);
SetValue(valueName,str);
}
void CXmlNodeWrapper::SetValue(LPCTSTR valueName,double value)
{
CString str;
str.Format(_T("%f"),value);
SetValue(valueName,str);
}
void CXmlNodeWrapper::SetValue(LPCTSTR valueName,float value)
{
CString str;
str.Format(_T("%f"),value);
SetValue(valueName,str);
}
void CXmlNodeWrapper::SetValue(LPCTSTR valueName,bool value)
{
CString str;
if (value)
str = _T("True");
else
str = _T("False");
SetValue(valueName,str);
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertNode(int index,LPCTSTR nodeName)
{
MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
if (xmlDocument)
{
MSXML2::IXMLDOMNodePtr newNode = xmlDocument->createNode(_variant_t((short)MSXML2::NODE_ELEMENT),nodeName,"");
MSXML2::IXMLDOMNode* refNode = GetNode(index);
if (refNode)
newNode = m_xmlnode->insertBefore(newNode.Detach(),refNode);
else
newNode = m_xmlnode->appendChild(newNode.Detach());
return newNode.Detach();
}
return NULL;
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertNode(int index,MSXML2::IXMLDOMNodePtr pNode)
{
MSXML2::IXMLDOMNodePtr newNode = pNode->cloneNode(VARIANT_TRUE);
if (newNode)
{
MSXML2::IXMLDOMNode* refNode = GetNode(index);
if (refNode)
newNode = m_xmlnode->insertBefore(newNode.Detach(),refNode);
else
newNode = m_xmlnode->appendChild(newNode.Detach());
return newNode.Detach();
}
else
return NULL;
}
CString CXmlNodeWrapper::GetXML()
{
if (IsValid())
return (LPCTSTR)m_xmlnode->Getxml();
else
return _T("");
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::RemoveNode(MSXML2::IXMLDOMNodePtr pNode)
{
if (!IsValid())
return NULL;
return m_xmlnode->removeChild(pNode).Detach();
}
/* ********************************************************************************************************* */
CXmlDocumentWrapper::CXmlDocumentWrapper()
{
m_xmldoc.CreateInstance(MSXML2::CLSID_DOMDocument);
}
CXmlDocumentWrapper::CXmlDocumentWrapper(MSXML2::IXMLDOMDocumentPtr pDoc)
{
m_xmldoc = pDoc;
}
CXmlDocumentWrapper::~CXmlDocumentWrapper()
{
}
BOOL CXmlDocumentWrapper::IsValid()
{
if (m_xmldoc == NULL)
return FALSE;
if (m_xmldoc.GetInterfacePtr() == NULL)
return FALSE;
return TRUE;
}
MSXML2::IXMLDOMDocument* CXmlDocumentWrapper::Detach()
{
if (!IsValid())
return NULL;
return m_xmldoc.Detach();
}
MSXML2::IXMLDOMDocument* CXmlDocumentWrapper::Clone()
{
if (!IsValid())
return NULL;
MSXML2::IXMLDOMDocumentPtr xmldoc;
xmldoc.CreateInstance(MSXML2::CLSID_DOMDocument);
_variant_t v(xmldoc.GetInterfacePtr());
m_xmldoc->save(v);
return xmldoc.Detach();
}
BOOL CXmlDocumentWrapper::Load(LPCTSTR path)
{
if (!IsValid())
return FALSE;
_variant_t v(path);
m_xmldoc->put_async(VARIANT_FALSE);
VARIANT_BOOL success = m_xmldoc->load(v);
if (success == VARIANT_TRUE)
return TRUE;
else
return FALSE;
}
BOOL CXmlDocumentWrapper::LoadXML(LPCTSTR xml)
{
if (!IsValid())
return FALSE;
VARIANT_BOOL success = m_xmldoc->loadXML(xml);
if (success == VARIANT_TRUE)
return TRUE;
else
return FALSE;
}
BOOL CXmlDocumentWrapper::Save(LPCTSTR path)
{
try
{
if (!IsValid())
return FALSE;
CString szPath(path);
if (szPath == "")
{
_bstr_t curPath = m_xmldoc->Geturl();
szPath = (LPSTR)curPath;
}
_variant_t v(szPath);
if (FAILED(m_xmldoc->save(v)))
return FALSE;
else
return TRUE;
}
catch(...)
{
return FALSE;
}
}
MSXML2::IXMLDOMNode* CXmlDocumentWrapper::AsNode()
{
if (!IsValid())
return NULL;
return m_xmldoc->GetdocumentElement().Detach();
}
CString CXmlDocumentWrapper::GetXML()
{
if (IsValid())
return (LPCTSTR)m_xmldoc->Getxml();
else
return _T("");
}
CString CXmlDocumentWrapper::GetUrl()
{
return (LPTSTR)m_xmldoc->Geturl();
}
MSXML2::IXMLDOMDocument* CXmlNodeWrapper::ParentDocument()
{
return m_xmlnode->GetownerDocument().Detach();
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::Interface()
{
if (IsValid())
return m_xmlnode;
return NULL;
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertBefore(MSXML2::IXMLDOMNode *refNode, LPCTSTR nodeName)
{
MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
if (xmlDocument)
{
MSXML2::IXMLDOMNodePtr newNode = xmlDocument->createNode(_variant_t((short)MSXML2::NODE_ELEMENT),nodeName,"");
newNode = m_xmlnode->insertBefore(newNode.Detach(),(IUnknown*)refNode);
return newNode.Detach();
}
return NULL;
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertAfter(MSXML2::IXMLDOMNode *refNode, LPCTSTR nodeName)
{
MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
if (xmlDocument)
{
MSXML2::IXMLDOMNodePtr newNode = xmlDocument->createNode(_variant_t((short)MSXML2::NODE_ELEMENT),nodeName,"");
MSXML2::IXMLDOMNodePtr nextNode = refNode->GetnextSibling();
if (nextNode.GetInterfacePtr() != NULL)
newNode = m_xmlnode->insertBefore(newNode.Detach(),(IUnknown*)nextNode);
else
newNode = m_xmlnode->appendChild(newNode.Detach());
return newNode.Detach();
}
return NULL;
}
void CXmlNodeWrapper::RemoveNodes(LPCTSTR searchStr)
{
if (!IsValid())
return;
MSXML2::IXMLDOMNodeListPtr nodeList = m_xmlnode->selectNodes(searchStr);
for (int i = 0; i < nodeList->Getlength(); i++)
{
try
{
MSXML2::IXMLDOMNode* pNode = nodeList->Getitem(i).Detach();
pNode->GetparentNode()->removeChild(pNode);
}
catch (_com_error er)
{
AfxMessageBox(er.ErrorMessage());
}
}
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::Parent()
{
if (IsValid())
return m_xmlnode->GetparentNode().Detach();
return NULL;
}
CXmlNodeListWrapper::CXmlNodeListWrapper()
{
}
CXmlNodeListWrapper::CXmlNodeListWrapper(MSXML2::IXMLDOMNodeListPtr pList)
{
m_xmlnodelist = pList;
}
void CXmlNodeListWrapper::operator=(MSXML2::IXMLDOMNodeListPtr pList)
{
if (IsValid())
m_xmlnodelist.Release();
m_xmlnodelist = pList;
}
CXmlNodeListWrapper::~CXmlNodeListWrapper()
{
}
int CXmlNodeListWrapper::Count()
{
if (IsValid())
return m_xmlnodelist->Getlength();
else
return 0;
}
BOOL CXmlNodeListWrapper::IsValid()
{
if (m_xmlnodelist == NULL)
return FALSE;
if (m_xmlnodelist.GetInterfacePtr() == NULL)
return FALSE;
return TRUE;
}
MSXML2::IXMLDOMNode* CXmlNodeListWrapper::Next()
{
if (IsValid())
return m_xmlnodelist->nextNode().Detach();
else
return NULL;
}
void CXmlNodeListWrapper::Start()
{
if (IsValid())
m_xmlnodelist->reset();
}
MSXML2::IXMLDOMNode* CXmlNodeListWrapper::Node(int index)
{
if (IsValid())
return m_xmlnodelist->Getitem(index).Detach();
else
return NULL;
}
MSXML2::IXMLDOMDocument* CXmlNodeListWrapper::AsDocument()
{
if (IsValid())
{
CXmlDocumentWrapper doc;
doc.LoadXML(_T("<NodeList></NodeList>"));
CXmlNodeWrapper root(doc.AsNode());
for (int i = 0; i < m_xmlnodelist->Getlength(); i++)
{
root.InsertNode(root.NumNodes(),m_xmlnodelist->Getitem(i)->cloneNode(VARIANT_TRUE));
}
return doc.Detach();
}
else
return NULL;
}
MSXML2::IXMLDOMNodeList* CXmlNodeWrapper::FindNodes(LPCTSTR searchStr)
{
if(IsValid())
{
try{
return m_xmlnode->selectNodes(searchStr).Detach();
}
catch (_com_error e)
{
CString err = e.ErrorMessage();
return NULL;
}
}
else
return NULL;
}
CString CXmlNodeWrapper::Name()
{
if (IsValid())
return (LPCTSTR)m_xmlnode->GetbaseName();
return _T("");
}
MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertAfter(MSXML2::IXMLDOMNode *refNode, MSXML2::IXMLDOMNode *pNode)
{
MSXML2::IXMLDOMNodePtr nextNode = refNode->GetnextSibling();
MSXML2::IXMLDOMNodePtr newNode;
if (nextNode.GetInterfacePtr() != NULL)
newNode = m_xmlnode->insertBefore(pNode,(IUnknown*)nextNode);
else
newNode = m_xmlnode->appendChild(pNode);
return newNode.Detach();
}
void CXmlNodeWrapper::SetText(LPCTSTR text)
{
if (IsValid())
m_xmlnode->Puttext(text);
}
CString CXmlNodeWrapper::GetText()
{
if (IsValid())
return (LPCTSTR)m_xmlnode->Gettext();
else
return _T("");
}
void CXmlNodeWrapper::ReplaceNode(MSXML2::IXMLDOMNode *pOldNode, MSXML2::IXMLDOMNode *pNewNode)
{
if (IsValid())
{
m_xmlnode->replaceChild(pNewNode,pOldNode);
}
}
int CXmlNodeWrapper::NumAttributes()
{
if (IsValid())
{
MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();
if (attribs)
return attribs->Getlength();
}
return 0;
}
CString CXmlNodeWrapper::GetAttribName(int index)
{
if (IsValid())
{
MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();
if (attribs)
{
MSXML2::IXMLDOMAttributePtr attrib = attribs->Getitem(index);
if (attrib)
return (LPCTSTR)attrib->Getname();
}
}
return _T("");
}
CString CXmlNodeWrapper::GetAttribVal(int index)
{
if (IsValid())
{
MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();
if (attribs)
{
MSXML2::IXMLDOMAttributePtr attrib = attribs->Getitem(index);
if (attrib)
return (LPCTSTR)attrib->Gettext();
}
}
return _T("");
}
CString CXmlNodeWrapper::NodeType()
{
if (IsValid())
return (LPCTSTR)m_xmlnode->GetnodeTypeString();
return _T("");
}
| [
"outcast1000@dc1b949e-fa36-4f9e-8e5c-de004ec35678"
]
| [
[
[
1,
597
]
]
]
|
a5ef53e4abe0a77b8785aa406892fd5c53f5cf32 | 1e976ee65d326c2d9ed11c3235a9f4e2693557cf | /CrashReport/DetailsDlg.cpp | d17fef0acc9af743ce8db1985cb13f102694537c | []
| no_license | outcast1000/Jaangle | 062c7d8d06e058186cb65bdade68a2ad8d5e7e65 | 18feb537068f1f3be6ecaa8a4b663b917c429e3d | refs/heads/master | 2020-04-08T20:04:56.875651 | 2010-12-25T10:44:38 | 2010-12-25T10:44:38 | 19,334,292 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,544 | cpp | // Details.cpp Version 1.0
//
// Author: Hans Dietrich
// [email protected]
//
// This software is released into the public domain.
// You are free to use it in any way you like, except
// that you may not sell this source code.
//
// This software is provided "as is" with no expressed
// or implied warranty. I accept no liability for any
// damage or loss of business that this software may cause.
//
///////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "CrashReport.h"
#include "DetailsDlg.h"
//#include "strcvt.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
BEGIN_MESSAGE_MAP(CDetailsDlg, CDialog)
END_MESSAGE_MAP()
CDetailsDlg::CDetailsDlg(CWnd* pParent /*=NULL*/)
: CDialog(CDetailsDlg::IDD, pParent)
{
}
CDetailsDlg::~CDetailsDlg()
{
if (m_FileContentsFont.GetSafeHandle())
m_FileContentsFont.DeleteObject();
}
void CDetailsDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
}
BOOL CDetailsDlg::OnInitDialog()
{
CDialog::OnInitDialog();
LOGFONT lf;
GetFont()->GetLogFont(&lf);
_tcscpy_s(lf.lfFaceName, _T("Courier New"));
m_FileContentsFont.CreateFontIndirect(&lf);
GetDlgItem(IDC_CONTENTS)->SetFont(&m_FileContentsFont);
SetDlgItemText(IDC_CONTENTS, m_FileContents);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
| [
"outcast1000@dc1b949e-fa36-4f9e-8e5c-de004ec35678"
]
| [
[
[
1,
60
]
]
]
|
eee40c5c10c40f08157e7dd16841ee3b4a549fa9 | 7d4527b094cfe62d9cd99efeed2aff7a8e8eae88 | /TalkTom/TalkTom/Matrix.h | f8aba21b3d03f45fcf3dc995da1de55c3be081d1 | []
| no_license | Evans22/talktotom | a828894df42f520730e6c47830946c8341b230dc | 4e72ba6021fdb3a918af1df30bfe8642f03b1f07 | refs/heads/master | 2021-01-10T17:11:10.132971 | 2011-02-15T12:53:00 | 2011-02-15T12:53:00 | 52,947,431 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,217 | h | #include "stdafx.h"
#ifndef __CMATRIX__
#define __CMATRIX__
class CMatrix //矩阵类
{
public:
//构造函数、析构函数、拷贝构造函数、赋值运算符
CMatrix(int row, int col);
~CMatrix();
CMatrix(const CMatrix &rhs);
CMatrix& operator=(const CMatrix &rhs);
public:
//填充矩阵
bool setMatrix(const double *array, int size);
//获取矩阵中的所有元素
bool getMatrix(double *array, int size);
//获取矩阵的行数
void getRow(int &row);
//获取矩阵的列数
void getCol(int &col);
//显示矩阵
bool display(void);
public:
//矩阵相加
bool Add(const CMatrix &rhs);
//矩阵相减
bool Minus(const CMatrix &rhs);
//矩阵相乘
bool Multiply(const CMatrix &rhs);
//常数与矩阵相乘
bool Multiply(const double constant);
public:
//矩阵转置，结果保存在rhs中
bool TransposeMatrix();
//求逆矩阵，结果保存在rhs中
bool InverseMatrix();
private:
bool ContraryMatrix(double *const pMatrix, double *const _pMatrix, const int &dim);
CMatrix(){}
private:
double *m_matrix; //指向矩阵的指针
int m_row; //矩阵的行数
int m_col; //矩阵的列数
};
#endif | [
"aicrosoft1104@61e0f6aa-79d2-64b1-0467-50e2521aa597"
]
| [
[
[
1,
56
]
]
]
|
67dd0b43d46ec93741005743b1bbcaab2738d9d9 | 7118fecdd59504e990582bc5e1c5ccad0f565488 | /NeuralBasic/Neuron.cpp | f471acf19bf7ce153ecc8a0f5a5c985aa9c9c7b4 | []
| no_license | YungGod999/YungGod999 | 7ae91aa0b81fcb1d67e2a022d856ee8ca9699283 | fc96dd67604cfb3cb739762401880d96dc2bee38 | refs/heads/master | 2021-08-22T07:07:46.998249 | 2010-10-19T21:45:13 | 2010-10-19T21:45:13 | 112,490,922 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,838 | cpp | #include "StdAfx.h"
#include "Neuron.h"
#include "HyperbolicTangent.h"
#include "BackPropagation.h"
#include "Tools.h"
#include "WeightInitializer.h"
namespace NeuralBasic
{
Neuron::Neuron(void)
{
}
Neuron::Neuron(const size_t inputsCount)
: m_weights(inputsCount)
{
std::generate(m_weights.begin(), m_weights.end(),
[]()
{
return WeightInitializer::Generate();
}
);
backPropagation.init(m_weights.size());
}
Neuron::~Neuron(void)
{
}
double Neuron::Work(const Doubles& m_inputs) const
{
const double innerProduct = std::inner_product(m_weights.begin(), m_weights.end(),
m_inputs.begin(), 0.0);
const double result = HyperbolicTangent::Output(innerProduct);
return result;
}
void Neuron::Train(const Doubles& inputs, const double output, const double backPropError, Doubles& layerError)
{
const double learningError = backPropError * HyperbolicTangent::Derivative(output);
CalculateError(learningError, layerError);
backPropagation.Train(learningError, inputs, m_weights);
}
void Neuron::TrainFirstLayer(const Doubles& inputs, const double output, const double backPropError)
{
const double learningError = backPropError * HyperbolicTangent::Derivative(output);
backPropagation.Train(learningError, inputs, m_weights);
}
void Neuron::CalculateError(const double learningError, Doubles& error) const
{
assert(m_weights.size() == error.size()+BIAS_INPUT);
//accumulate error from previous layer
//error(n)=error(n)+m_learningError*m_weights(n)
ForEach2It(error.begin(), error.end()
, m_weights.begin()
,[learningError](double& error, const double weight)
{
error = error + weight*learningError;
}
);
}
size_t Neuron::GetInputsCount() const
{
return m_weights.size();
}
} | [
"Mariusz@localhost"
]
| [
[
[
1,
71
]
]
]
|
a130ab91002689e6459160c47635789626d60825 | 21da454a8f032d6ad63ca9460656c1e04440310e | /src/wcpp/net/impl/wscDatagramSocketImpl_win32.h | 8742e66722aab9a27afb4b0eadc723447452fe35 | []
| no_license | merezhang/wcpp | d9879ffb103513a6b58560102ec565b9dc5855dd | e22eb48ea2dd9eda5cd437960dd95074774b70b0 | refs/heads/master | 2021-01-10T06:29:42.908096 | 2009-08-31T09:20:31 | 2009-08-31T09:20:31 | 46,339,619 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,919 | h | #pragma once
#include <wcpp/net/wscDatagramSocketImpl.h>
#if (WS_PLATFORM == WS_PLATFORM_WIN32)
#include <windows.h>
class wscDatagramSocketImpl_win32 : public wscDatagramSocketImpl
{
public:
static const ws_char * const s_class_name;
public:
wscDatagramSocketImpl_win32(void);
~wscDatagramSocketImpl_win32(void);
private:
SOCKET m_socket;
protected: // impl wsiSocketOpetions
WS_METHOD( ws_result , GetOption )(wsiObject ** ret , ws_int optID);
WS_METHOD( ws_result , SetOption )(ws_int optID , wsiObject * value);
protected: // impl wsiDatagramSocketImpl
WS_METHOD( ws_result , Bind )(ws_int lport , wsiInetAddress * laddr);
WS_METHOD( ws_result , Close )(void);
WS_METHOD( ws_result , Connect )(wsiInetAddress * address , ws_int port);
WS_METHOD( ws_result , Create )(void);
WS_METHOD( ws_result , Disconnect )(void);
WS_METHOD( ws_result , GetFileDescriptor )(wsiFileDescriptor ** ret);
WS_METHOD( ws_int , GetLocalPort )(void);
WS_METHOD( ws_int , GetTimeToLive )(void);
WS_METHOD( ws_result , Join )(wsiInetAddress * inetaddr);
WS_METHOD( ws_result , JoinGroup )(wsiSocketAddress * mcastaddr , wsiNetworkInterface * netIf);
WS_METHOD( ws_result , Leave )(wsiInetAddress * inetaddr);
WS_METHOD( ws_result , LeaveGroup )(wsiSocketAddress * mcastaddr , wsiNetworkInterface * netIf);
WS_METHOD( ws_int , Peek )(wsiInetAddress * i);
WS_METHOD( ws_int , PeekData )(wsiDatagramPacket * p);
WS_METHOD( ws_result , Receive )(wsiDatagramPacket * p);
WS_METHOD( ws_result , Send )(wsiDatagramPacket * p);
WS_METHOD( ws_result , SetTimeToLive )(ws_int ttl);
};
#endif // (WS_PLATFORM == WS_PLATFORM_WIN32)
| [
"xukun0217@98f29a9a-77f1-11de-91f8-ab615253d9e8"
]
| [
[
[
1,
45
]
]
]
|
39f58707e61b589565d1863314dcaadd4051aac0 | 21da454a8f032d6ad63ca9460656c1e04440310e | /src/wcpp/lang/ref/wsiSupportsWeakReference.h | 922180afafa12e7d89a066c966c779d855c2da42 | []
| no_license | merezhang/wcpp | d9879ffb103513a6b58560102ec565b9dc5855dd | e22eb48ea2dd9eda5cd437960dd95074774b70b0 | refs/heads/master | 2021-01-10T06:29:42.908096 | 2009-08-31T09:20:31 | 2009-08-31T09:20:31 | 46,339,619 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 448 | h | #pragma once
#include <wcpp/lang/wsiObject.h>
#include "wsiWeakReference.h"
#define WS_IID_OF_wsiSupportsWeakReference \
{ 0x87833ca2, 0xbebf, 0x4b27, { 0xb2, 0xe, 0x15, 0xaf, 0x7b, 0x77, 0x2a, 0x7b } }
// {87833CA2-BEBF-4b27-B20E-15AF7B772A7B}
class wsiSupportsWeakReference : public wsiObject
{
public:
static const ws_iid sIID;
public:
WS_METHOD( ws_result , GetWeakReference )(wsiWeakReference ** ret) = 0;
};
| [
"xukun0217@98f29a9a-77f1-11de-91f8-ab615253d9e8"
]
| [
[
[
1,
18
]
]
]
|
2ce4c26db6425014e364c9af21e3734539ef213b | b7c505dcef43c0675fd89d428e45f3c2850b124f | /Src/SimulatorQt/Util/qt/Win32/include/Qt/qwindowdefs.h | 56bef96bea8c0c2194c2b4ebeddbfe0d62fca7f1 | [
"BSD-2-Clause"
]
| permissive | pranet/bhuman2009fork | 14e473bd6e5d30af9f1745311d689723bfc5cfdb | 82c1bd4485ae24043aa720a3aa7cb3e605b1a329 | refs/heads/master | 2021-01-15T17:55:37.058289 | 2010-02-28T13:52:56 | 2010-02-28T13:52:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,892 | h | /****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information ([email protected])
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain
** additional rights. These rights are described in the Nokia Qt LGPL
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QWINDOWDEFS_H
#define QWINDOWDEFS_H
#include <QtCore/qobjectdefs.h>
#include <QtCore/qnamespace.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Gui)
// Class forward definitions
class QPaintDevice;
class QWidget;
class QDialog;
class QColor;
class QPalette;
#ifdef QT3_SUPPORT
class QColorGroup;
#endif
class QCursor;
class QPoint;
class QSize;
class QRect;
class QPolygon;
class QPainter;
class QRegion;
class QFont;
class QFontMetrics;
class QFontInfo;
class QPen;
class QBrush;
class QMatrix;
class QPixmap;
class QBitmap;
class QMovie;
class QImage;
class QPicture;
class QPrinter;
class QTimer;
class QTime;
class QClipboard;
class QString;
class QByteArray;
class QApplication;
template<typename T> class QList;
typedef QList<QWidget *> QWidgetList;
QT_END_NAMESPACE
QT_END_HEADER
// Window system dependent definitions
#if defined(Q_WS_MAC) && !defined(Q_WS_QWS)
#include <QtGui/qmacdefines_mac.h>
#ifdef Q_WS_MAC32
typedef int WId;
#else
typedef long WId;
#endif
#endif // Q_WS_MAC
#if defined(Q_WS_WIN)
#include <QtGui/qwindowdefs_win.h>
#endif // Q_WS_WIN
#if defined(Q_WS_X11)
typedef struct _XDisplay Display;
typedef union _XEvent XEvent;
typedef struct _XGC *GC;
typedef struct _XRegion *Region;
typedef unsigned long WId;
#endif // Q_WS_X11
#if defined(Q_WS_QWS)
typedef unsigned long WId;
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
struct QWSEvent;
QT_END_NAMESPACE
QT_END_HEADER
#endif // Q_WS_QWS
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
template<class K, class V> class QHash;
typedef QHash<WId, QWidget *> QWidgetMapper;
template<class V> class QSet;
typedef QSet<QWidget *> QWidgetSet;
QT_END_NAMESPACE
QT_END_HEADER
#if defined(QT_NEEDS_QMAIN)
#define main qMain
#endif
// Global platform-independent types and functions
#endif // QWINDOWDEFS_H
| [
"alon@rogue.(none)"
]
| [
[
[
1,
152
]
]
]
|
135607dc59c9775dcad76f274639afc2339fac66 | c70941413b8f7bf90173533115c148411c868bad | /plugins/AS3Plugin/src/vtxas3EventDispatcher.cpp | 41e64f9425343a040294f450b4fd207afc984120 | []
| no_license | cnsuhao/vektrix | ac6e028dca066aad4f942b8d9eb73665853fbbbe | 9b8c5fa7119ff7f3dc80fb05b7cdba335cf02c1a | refs/heads/master | 2021-06-23T11:28:34.907098 | 2011-03-27T17:39:37 | 2011-03-27T17:39:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,120 | cpp | /*
-----------------------------------------------------------------------------
This source file is part of "vektrix"
(the rich media and vector graphics rendering library)
For the latest info, see http://www.fuse-software.com/
Copyright (c) 2009-2010 Fuse-Software (tm)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#include "vtxas3EventDispatcher.h"
#include "vtxas3Event.h"
#include "vtxas3Object.h"
#include "vtxFileEvent.h"
#include "vtxFocusEvent.h"
#include "vtxInstance.h"
#include "vtxLogManager.h"
#include "vtxMouseEvent.h"
#include "vtxStringHelper.h"
#include "cspVmCore.h"
#include "vtxas3ScriptInterface.h"
using namespace avmplus;
namespace vtx { namespace as3 {
//-----------------------------------------------------------------------
EventDispatcher::EventDispatcher(avmplus::VTable* vtable, avmplus::ScriptObject* prototype)
: AS3Object(vtable, prototype)
{
MMGC_GCENTER(core()->GetGC());
dispatchEvent = CSP_CORE->getMethodEnv(this, "dispatchEvent");
}
//-----------------------------------------------------------------------
void EventDispatcher::ctor(avmplus::ScriptObject* target)
{
AS3Object::ctor();
}
//-----------------------------------------------------------------------
const String& EventDispatcher::getMappedVektrixType() const
{
static String type = "NONE";
VTX_DEBUG_ASSERT(true, "error");
return type;
}
//-----------------------------------------------------------------------
void EventDispatcher::eventFired(const vtx::Event& evt)
{
MMGC_GCENTER(core()->GetGC());
if(evt.getType().length() == 0 || evt.getCategory() == FileEvent::CATEGORY) return;
TRY(core(), kCatchAction_ReportAsError)
{
VTX_DEBUG_ASSERT(evt.getType().length(), "evt.type.length == 0");
uint num_args = 3;
Atom* evt_args = new Atom[16];
evt_args[1] = CSP_CORE->toScript(evt.getType());
evt_args[2] = CSP_CORE->toScript(false);
evt_args[3] = CSP_CORE->toScript(true);
if(evt.getCategory() == vtx::MouseEvent::CATEGORY)
{
const vtx::MouseEvent& mouse_evt = static_cast<const vtx::MouseEvent&>(evt);
evt_args[4] = CSP_CORE->toScript(mouse_evt.stageX);
evt_args[5] = CSP_CORE->toScript(mouse_evt.stageY);
num_args = 5;
}
if(evt.getType() == vtx::Event::ENTER_FRAME)
VTX_LOG("ENTER_FRAME dispatched from %u", (uint)this);
Event* as3_evt = static_cast<Event*>(CSP_CORE->createObject(evt.getCategory(), "flash.events", num_args, evt_args));
delete[] evt_args;
//as3_evt->setCurrentTarget(this);
//as3_evt->setTarget(this);
// call the AS3 "dispatch" method
Atom dispatch_args[] = { atom(), as3_evt->atom() };
csp::VmCore::callFunction(this, dispatchEvent, dispatch_args);
if(as3_evt->RefCount() > 0)
as3_evt->DecrementRef();
}
CATCH(Exception* exception)
{
CSP_CORE->printException(exception);
}
END_CATCH
END_TRY
}
//-----------------------------------------------------------------------
}}
| [
"stonecold_@9773a11d-1121-4470-82d2-da89bd4a628a"
]
| [
[
[
1,
115
]
]
]
|
f26e957e803def153b5c953fbf2d10111ebc1641 | f55665c5faa3d79d0d6fe91fcfeb8daa5adf84d0 | /Depend/MyGUI/Tools/SkinEditor/RegionTextureControl.cpp | 4572a09a972afac2209e37bbff12fdf80d921b03 | []
| no_license | lxinhcn/starworld | 79ed06ca49d4064307ae73156574932d6185dbab | 86eb0fb8bd268994454b0cfe6419ffef3fc0fc80 | refs/heads/master | 2021-01-10T07:43:51.858394 | 2010-09-15T02:38:48 | 2010-09-15T02:38:48 | 47,859,019 | 2 | 1 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 7,203 | cpp | /*!
@file
@author Albert Semenov
@date 08/2010
*/
#include "precompiled.h"
#include "RegionTextureControl.h"
namespace tools
{
RegionTextureControl::RegionTextureControl(MyGUI::Widget* _parent) :
TextureToolControl(_parent),
mTextureVisible(false),
mAreaSelectorControl(nullptr),
mPositionSelectorControl(nullptr)
{
mTypeName = MyGUI::utility::toString((int)this);
// сразу рисуем рамки для стейтов
std::vector<MyGUI::IntCoord> coords(10);
drawUnselectedStates(coords);
addSelectorControl(mAreaSelectorControl);
addSelectorControl(mPositionSelectorControl);
mPositionSelectorControl->setEnabled(false);
mAreaSelectorControl->eventChangePosition += MyGUI::newDelegate(this, &RegionTextureControl::notifyChangePosition);
initialiseAdvisor();
}
RegionTextureControl::~RegionTextureControl()
{
shutdownAdvisor();
mAreaSelectorControl->eventChangePosition -= MyGUI::newDelegate(this, &RegionTextureControl::notifyChangePosition);
}
void RegionTextureControl::updateRegionProperty(Property* _sender, const MyGUI::UString& _owner)
{
if (_owner != mTypeName)
{
if (_sender->getName() == "Position")
updatePosition();
else if (_sender->getName() == "Visible")
updateVisible();
else if (_sender->getName() == "Enabled")
updateVisible();
}
}
void RegionTextureControl::updateRegionProperties()
{
updateVisible();
updatePosition();
updateUnselectedStates();
}
void RegionTextureControl::updateTextureControl()
{
if (mTextureVisible && !mTextureName.empty() && getCurrentSkin() != nullptr && getCurrentState() != nullptr)
{
setTextureName(mTextureName);
setTextureRegion(mTextureRegion);
}
else
{
setTextureRegion(MyGUI::IntCoord());
}
}
void RegionTextureControl::updateSkinProperties()
{
updateTextureName();
updateRegionSize();
}
void RegionTextureControl::updateSkinProperty(Property* _sender, const MyGUI::UString& _owner)
{
if (_sender->getName() == "Texture")
updateTextureName();
else if (_sender->getName() == "Coord")
updateRegionSize();
}
void RegionTextureControl::updateStateProperties()
{
updateRegionPosition();
updateTextureVisible();
}
void RegionTextureControl::updateStateProperty(Property* _sender, const MyGUI::UString& _owner)
{
if (_sender->getName() == "Position")
updateRegionPosition();
else if (_sender->getName() == "Visible")
updateTextureVisible();
}
void RegionTextureControl::updateTextureName()
{
mTextureName = "";
if (getCurrentSkin() != nullptr)
mTextureName = getCurrentSkin()->getPropertySet()->getPropertyValue("Texture");
updateTextureControl();
}
void RegionTextureControl::updateRegionSize()
{
mTextureRegion.width = 0;
mTextureRegion.height = 0;
if (getCurrentSkin() != nullptr)
{
MyGUI::IntCoord coord = MyGUI::IntCoord::parse(getCurrentSkin()->getPropertySet()->getPropertyValue("Coord"));
mTextureRegion.width = coord.width;
mTextureRegion.height = coord.height;
}
updateTextureControl();
updateUnselectedStates();
}
void RegionTextureControl::updateRegionPosition()
{
mTextureRegion.left = 0;
mTextureRegion.top = 0;
if (getCurrentState() != nullptr)
{
MyGUI::IntPoint position = MyGUI::IntPoint::parse(getCurrentState()->getPropertySet()->getPropertyValue("Position"));
mTextureRegion.left = position.left;
mTextureRegion.top = position.top;
}
updateTextureControl();
}
void RegionTextureControl::updateTextureVisible()
{
mTextureVisible = false;
if (getCurrentState() != nullptr)
mTextureVisible = getCurrentState()->getPropertySet()->getPropertyValue("Visible") == "True";
updateTextureControl();
}
void RegionTextureControl::updatePosition()
{
MyGUI::UString value;
if (getCurrentRegion() != nullptr)
value = getCurrentRegion()->getPropertySet()->getPropertyValue("Position");
MyGUI::IntCoord coord;
if (MyGUI::utility::parseComplex(value, coord.left, coord.top, coord.width, coord.height))
{
mAreaSelectorControl->setCoord(coord);
mPositionSelectorControl->setCoord(coord);
}
}
void RegionTextureControl::updateVisible()
{
mAreaSelectorControl->setVisible(false);
mPositionSelectorControl->setVisible(false);
if (getCurrentRegion() != nullptr)
{
if (getCurrentRegion()->getPropertySet()->getPropertyValue("Visible") == "True")
{
if (getCurrentRegion()->getPropertySet()->getPropertyValue("Enabled") == "True")
{
if (!getCurrentRegion()->getPropertySet()->getPropertyReadOnly("Position"))
mAreaSelectorControl->setVisible(true);
else
mPositionSelectorControl->setVisible(true);
}
}
}
}
void RegionTextureControl::notifyChangePosition()
{
MyGUI::IntCoord coord = mAreaSelectorControl->getCoord();
if (getCurrentRegion() != nullptr)
getCurrentRegion()->getPropertySet()->setPropertyValue("Position", coord.print(), mTypeName);
}
void RegionTextureControl::updateUnselectedStates()
{
std::vector<MyGUI::IntCoord> coords;
if (getCurrentSkin() != nullptr)
{
ItemHolder<RegionItem>::EnumeratorItem regions = getCurrentSkin()->getRegions().getChildsEnumerator();
while (regions.next())
{
RegionItem* item = regions.current();
if (item != getCurrentSkin()->getRegions().getItemSelected())
{
if (item->getPropertySet()->getPropertyValue("Visible") == "True")
{
if (item->getPropertySet()->getPropertyValue("Enabled") == "True")
{
addCoord(coords, item->getPropertySet()->getPropertyValue("Position"));
}
}
}
}
}
drawUnselectedStates(coords);
}
void RegionTextureControl::addCoord(std::vector<MyGUI::IntCoord>& _coords, const MyGUI::UString& _coord)
{
MyGUI::IntCoord coord;
if (MyGUI::utility::parseComplex(_coord, coord.left, coord.top, coord.width, coord.height))
{
for (std::vector<MyGUI::IntCoord>::iterator item = _coords.begin(); item != _coords.end(); ++item)
{
if ((*item) == coord)
return;
}
_coords.push_back(coord);
}
}
void RegionTextureControl::drawUnselectedStates(std::vector<MyGUI::IntCoord>& _coords)
{
while (_coords.size() > mBlackSelectors.size())
{
PositionSelectorBlackControl* selector = nullptr;
addSelectorControl(selector);
mBlackSelectors.push_back(selector);
}
for (size_t index = 0; index < mBlackSelectors.size(); ++index)
{
if (index < _coords.size())
{
mBlackSelectors[index]->setVisible(true);
mBlackSelectors[index]->setCoord(_coords[index]);
}
else
{
mBlackSelectors[index]->setVisible(false);
}
}
}
void RegionTextureControl::updateSeparatorProperties()
{
updateUnselectedStates();
}
void RegionTextureControl::updateSeparatorProperty(Property* _sender, const MyGUI::UString& _owner)
{
if (_sender->getName() == "Visible" || _sender->getName() == "Offset")
updateUnselectedStates();
}
} // namespace tools
| [
"albertclass@a94d7126-06ea-11de-b17c-0f1ef23b492c"
]
| [
[
[
1,
272
]
]
]
|
db41f920f83818eba3cb87bc72ad90b1a11f1873 | 95a8d2b18434b00ff35ffddd6b4c2fb744ffab48 | /src/pm_pbg6.cpp | b22d3545749776d8bfa6a9564b60c7b20151f8d8 | []
| no_license | DTM9025/musicroom | 912ee0829a26e67be2d3c070fcb1cf2680ec2883 | cf1e97209c279fbbeb210601e7466af35f9848fd | refs/heads/master | 2020-03-20T13:07:44.448378 | 2011-09-01T22:50:42 | 2011-09-01T22:50:42 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 5,573 | cpp | // Music Room Interface
// --------------------
// pm_pbg6.cpp - Parsing for PBG6 archives (Banshiryuu)
// --------------------
// "©" Nmlgc, 2011
#include "musicroom.h"
#include <FXFile.h>
#include <bgmlib/packmethod.h>
#include <bgmlib/config.h>
#include <bgmlib/utils.h>
#include "pm.h"
bool PM_PBG6::ParseGameInfo(ConfigFile &NewGame, GameInfo *GI)
{
GI->CryptKind = CR_YUITIA;
return PF_PGI_BGMFile(NewGame, GI);
}
bool PM_PBG6::ParseTrackInfo(ConfigFile &NewGame, GameInfo *GI, ConfigParser* TS, TrackInfo *NewTrack)
{
TS->GetValue("filename", TYPE_STRING, &NewTrack->NativeFN);
NewTrack->PosFmt = FMT_SAMPLE;
GI->Vorbis = true;
return true; // Read (additional) position info from BGM file. Because they didn't even got _that_ right.
}
// Decryption
// ----------
// Constants
const ulong CP1_SIZE = 0x102;
const ulong CP2_SIZE = 0x400;
void PM_PBG6::CryptStep(ulong* pool1, ulong* pool2, ulong& ecx)
{
static const ulong cmp = (CP1_SIZE - 1);
pool2[ecx]++;
ecx++;
while(ecx <= cmp)
{
pool1[ecx]++;
ecx++;
}
if(pool1[cmp] < 0x10000) return;
pool1[0] = 0;
for(ushort c = 0; c < cmp; c++)
{
pool2[c] = (pool2[c] | 2) >> 1;
pool1[c + 1] = pool1[c] + pool2[c];
}
return;
}
ulong PM_PBG6::Decrypt(volatile FXulong& d, char* dest, const char* source, const ulong& size)
{
// Source byte checks are disabled here because they aren't necessary and I don't want to add yet another member to TrackInfo.
// Those few extra bytes we load this way are worth my sanity.
ulong ebx = 0, ecx, edi, esi, edx;
ulong cryptval[2];
ulong s = 4;
d = 0; // source and destination bytes
FXulong LastD = d;
ulong pool1[CP1_SIZE];
ulong pool2[CP2_SIZE];
for(ulong c = 0; c < CP1_SIZE; c++) pool1[c] = c;
for(ulong c = 0; c < CP2_SIZE; c++) pool2[c] = 1;
edi = EndianSwap(*(ulong*)source);
esi = 0xFFFFFFFF;
while(d == LastD)
{
edx = 0x100;
cryptval[0] = esi / pool1[0x101];
cryptval[1] = (edi - ebx) / cryptval[0];
ecx = 0x80;
esi = 0;
while(1)
{
while( (ecx != 0x100) && (pool1[ecx] > cryptval[1]))
{
ecx--;
edx = ecx;
ecx = (esi+ecx) >> 1;
}
if(cryptval[1] < pool1[ecx+1]) break;
esi = ecx+1;
ecx = (esi+edx) >> 1;
}
*(dest + d) = (char)ecx; // Write!
if(++d >= size) return s;
LastD++;
esi = (long)pool2[ecx] * (long)cryptval[0]; // IMUL
ebx += pool1[ecx] * cryptval[0];
CryptStep(pool1, pool2, ecx);
ecx = (ebx + esi) ^ ebx;
while(!(ecx & 0xFF000000))
{
ebx <<= 8;
esi <<= 8;
edi <<= 8;
ecx = (ebx+esi) ^ ebx;
edi += *(source + s) & 0x000000FF;
s++;
// if(++s >= sourcesize) return s;
}
while(esi < 0x10000)
{
esi = 0x10000 - (ebx & 0x0000FFFF);
ebx <<= 8;
esi <<= 8;
edi <<= 8;
edi += *(source + s) & 0x000000FF;
s++;
// if(++s >= sourcesize) return s;
}
}
return s;
}
// ----------
#define THRESHOLD_BYTES 32768
ulong PM_PBG6::DecryptFile(GameInfo* GI, FXFile& In, char* Out, const ulong& Pos, const ulong& Size, volatile FXulong* p)
{
char* Crypt;
ulong r;
FXulong t;
volatile FXulong& d = p ? *p : t;
if(!Out) return false;
if(!(Crypt = new char[Size])) return false;
if(!In.position(Pos)) return false;
if(!In.readBlock(Crypt, Size)) return false;
if(Size > THRESHOLD_BYTES) MW->ProgConnect(&d, Size);
r = Decrypt(d, Out, Crypt, Size);
SAFE_DELETE_ARRAY(Crypt);
if(Size > THRESHOLD_BYTES) MW->ProgConnect();
return r;
}
// Data
// ----
void PM_PBG6::AudioData(GameInfo* GI, FXFile& In, const ulong& Pos, const ulong& Size, TrackInfo* TI)
{
PackMethod::AudioData(GI, In, Pos, Size, TI);
// Get bitrate by reading 0x28 - 0x2A
char HeaderPart[0x2A];
ushort Temp;
DecryptFile(GI, In, HeaderPart, Pos, 0x2A);
memcpy(&Temp, HeaderPart + 0x28, 2);
TI->Freq = Temp;
}
void PM_PBG6::MetaData(GameInfo* GI, FXFile& In, const ulong& Pos, const ulong& Size, TrackInfo* TI)
{
if( (TI->Loop != 0) && (TI->End != 0)) return;
char* SLI_Decrypt = new char[Size];
FXString SLI;
DecryptFile(GI, In, SLI_Decrypt, Pos, Size);
SLI = SLI_Decrypt;
if(!TI->Loop) TI->Loop = NamedValue(SLI, "LoopStart", "=", "\r\n").toULong();
if(!TI->End) TI->End = NamedValue(SLI, "LoopLength", "=", "\r\n").toULong() + TI->Loop;
SAFE_DELETE_ARRAY(SLI_Decrypt);
}
void PM_PBG6::GetPosData(GameInfo* GI, FXFile& In, ulong& Files, char* toc, ulong& tocSize)
{
char* p = toc;
FXString FN, FNExt;
ulong CFPos = 0, CFSize[2] = {0, 0}; // 0: insize, 1: outsize
for(ulong c = 0; c < Files; c++)
{
FN = p;
p += FN.length() + 1;
memcpy_advance(CFSize, &p, 8);
memcpy_advance(&CFPos, &p, 4);
p += 4;
PF_TD_ParseArchiveFile(GI, In, FN, "ogg", "ogg.sli", CFPos, CFSize[1]);
}
GI->Scanned = true;
}
// ----
bool PM_PBG6::TrackData(GameInfo* GI)
{
FXFile In;
ulong Files;
ulong Pos, Size[2]; // 0: insize, 1: outsize
char* Toc;
In.open(GI->BGMFile, FXIO::Reading);
Size[0] = In.size();
In.position(4);
In.readBlock(&Pos, 4);
In.readBlock(&Size[1], 4);
Size[0] -= Pos;
Toc = new char[Size[1]];
DecryptFile(GI, In, Toc, Pos, Size[1]);
Files = *((ulong*)Toc);
GetPosData(GI, In, Files, Toc + 4, Size[1]);
SAFE_DELETE_ARRAY(Toc);
// ... done!
In.close();
return true;
}
// Scanning
// --------
GameInfo* PM_PBG6::Scan(const FXString& Path)
{
return PF_Scan_BGMFile(Path);
}
// --------
| [
"[email protected]",
"[email protected]"
]
| [
[
[
1,
4
],
[
7,
149
],
[
156,
268
]
],
[
[
5,
6
],
[
150,
155
]
]
]
|
41c94f5713475438e1702d2bab7bb399f8119121 | f177993b13e97f9fecfc0e751602153824dfef7e | /ImPro/ImProBaseClass/MyLib/LEADTOOL/Include/Filters/ILMAConverter.h | a20c4982c5088da459369d681537010cadb1540f | []
| no_license | svn2github/imtophooksln | 7bd7412947d6368ce394810f479ebab1557ef356 | bacd7f29002135806d0f5047ae47cbad4c03f90e | refs/heads/master | 2020-05-20T04:00:56.564124 | 2010-09-24T09:10:51 | 2010-09-24T09:10:51 | 11,787,598 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,170 | h |
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 7.00.0500 */
/* at Thu Nov 05 12:42:24 2009
*/
/* Compiler settings for .\ILMAudConv.idl:
Oicf, W1, Zp8, env=Win32 (32b run)
protocol : dce , ms_ext, c_ext, robust
error checks: allocation ref bounds_check enum stub_data
VC __declspec() decoration level:
__declspec(uuid()), __declspec(selectany), __declspec(novtable)
DECLSPEC_UUID(), MIDL_INTERFACE()
*/
//@@MIDL_FILE_HEADING( )
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif // __RPCNDR_H_VERSION__
#ifndef __ILMAConverter_h__
#define __ILMAConverter_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __ILMAConverter_FWD_DEFINED__
#define __ILMAConverter_FWD_DEFINED__
typedef interface ILMAConverter ILMAConverter;
#endif /* __ILMAConverter_FWD_DEFINED__ */
#ifndef __LMAConverter_FWD_DEFINED__
#define __LMAConverter_FWD_DEFINED__
#ifdef __cplusplus
typedef class LMAConverter LMAConverter;
#else
typedef struct LMAConverter LMAConverter;
#endif /* __cplusplus */
#endif /* __LMAConverter_FWD_DEFINED__ */
/* header files for imported files */
#include "oaidl.h"
#include "ocidl.h"
#ifdef __cplusplus
extern "C"{
#endif
#ifndef __LMAConverterLib_LIBRARY_DEFINED__
#define __LMAConverterLib_LIBRARY_DEFINED__
/* library LMAConverterLib */
/* [helpstring][version][uuid] */
#ifndef __ILMACONVERTER_H__
#define __ILMACONVERTER_H__
static const GUID CLSID_LMAConverter = {0xE2B7DF3B, 0x38c5, 0x11d5, {0x91, 0xf6, 0x00, 0x10, 0x4b, 0xdb, 0x8f, 0xf9}};
static const GUID CLSID_LMAAboutConverter = {0xE2B7DF3C, 0x38c5, 0x11d5, {0x91, 0xf6, 0x00, 0x10, 0x4b, 0xdb, 0x8f, 0xf9}};
static const GUID IID_ILMAConverter = {0xE2B7DF3D, 0x38c5, 0x11d5, {0x91, 0xf6, 0x00, 0x10, 0x4b, 0xdb, 0x8f, 0xf9}};
static const GUID LIBID_LMAConverterLib = {0xE2B7DF3A, 0x38c5, 0x11d5, {0x91, 0xf6, 0x00, 0x10, 0x4b, 0xdb, 0x8f, 0xf9}};
static const GUID CLSID_LMAConverterPropPage = {0xE2B7DF3E, 0x38c5, 0x11d5, {0x91, 0xf6, 0x00, 0x10, 0x4b, 0xdb, 0x8f, 0xf9}};
#endif
EXTERN_C const IID LIBID_LMAConverterLib;
#ifndef __ILMAConverter_INTERFACE_DEFINED__
#define __ILMAConverter_INTERFACE_DEFINED__
/* interface ILMAConverter */
/* [unique][helpstring][uuid][dual][local][object] */
EXTERN_C const IID IID_ILMAConverter;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("E2B7DF3D-38C5-11D5-91F6-00104BDB8FF9")
ILMAConverter : public IDispatch
{
public:
virtual /* [helpstring][id][propput] */ HRESULT STDMETHODCALLTYPE put_OutputSampleRate(
/* [in] */ long rate) = 0;
virtual /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE get_OutputSampleRate(
/* [retval][out] */ long *pRate) = 0;
};
#else /* C style interface */
typedef struct ILMAConverterVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ILMAConverter * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ILMAConverter * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ILMAConverter * This);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
ILMAConverter * This,
/* [out] */ UINT *pctinfo);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
ILMAConverter * This,
/* [in] */ UINT iTInfo,
/* [in] */ LCID lcid,
/* [out] */ ITypeInfo **ppTInfo);
HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
ILMAConverter * This,
/* [in] */ REFIID riid,
/* [size_is][in] */ LPOLESTR *rgszNames,
/* [range][in] */ UINT cNames,
/* [in] */ LCID lcid,
/* [size_is][out] */ DISPID *rgDispId);
/* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
ILMAConverter * This,
/* [in] */ DISPID dispIdMember,
/* [in] */ REFIID riid,
/* [in] */ LCID lcid,
/* [in] */ WORD wFlags,
/* [out][in] */ DISPPARAMS *pDispParams,
/* [out] */ VARIANT *pVarResult,
/* [out] */ EXCEPINFO *pExcepInfo,
/* [out] */ UINT *puArgErr);
/* [helpstring][id][propput] */ HRESULT ( STDMETHODCALLTYPE *put_OutputSampleRate )(
ILMAConverter * This,
/* [in] */ long rate);
/* [helpstring][id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_OutputSampleRate )(
ILMAConverter * This,
/* [retval][out] */ long *pRate);
END_INTERFACE
} ILMAConverterVtbl;
interface ILMAConverter
{
CONST_VTBL struct ILMAConverterVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ILMAConverter_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ILMAConverter_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ILMAConverter_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ILMAConverter_GetTypeInfoCount(This,pctinfo) \
( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) )
#define ILMAConverter_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) )
#define ILMAConverter_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) )
#define ILMAConverter_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) )
#define ILMAConverter_put_OutputSampleRate(This,rate) \
( (This)->lpVtbl -> put_OutputSampleRate(This,rate) )
#define ILMAConverter_get_OutputSampleRate(This,pRate) \
( (This)->lpVtbl -> get_OutputSampleRate(This,pRate) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ILMAConverter_INTERFACE_DEFINED__ */
EXTERN_C const CLSID CLSID_LMAConverter;
#ifdef __cplusplus
class DECLSPEC_UUID("E2B7DF3B-38C5-11D5-91F6-00104BDB8FF9")
LMAConverter;
#endif
#endif /* __LMAConverterLib_LIBRARY_DEFINED__ */
/* Additional Prototypes for ALL interfaces */
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
| [
"ndhumuscle@fa729b96-8d43-11de-b54f-137c5e29c83a"
]
| [
[
[
1,
239
]
]
]
|
60f68615f103a9f1ba3ed98bd0e9e1d2fb2bfc1c | 9b1a6a3bcaaf7f1a398e96c5c63d0643d366b1cc | /SpinningMixer/src/main.cpp | 61091c2209b730103703612c67f9fc7d8adcdf08 | []
| no_license | liquuid/experimentos | 7d5589b2297a7d9fafacb447abf3dce560326f10 | 803bc96b968ab2bee56a5334c45d73a2b4c767ea | refs/heads/master | 2020-05-19T13:41:36.142670 | 2010-11-13T01:31:36 | 2010-11-13T01:31:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 314 | cpp | #include "ofMain.h"
#include "testApp.h"
#include "ofAppGlutWindow.h"
//========================================================================
int main( ){
ofAppGlutWindow window;
ofSetupOpenGL(&window, 1024,768, OF_WINDOW); // <-------- setup the GL context
ofRunApp( new testApp());
}
| [
"[email protected]"
]
| [
[
[
1,
13
]
]
]
|
1426f82d6779f70da6471aa57965faebb6561d31 | ef23e388061a637f82b815d32f7af8cb60c5bb1f | /src/mame/includes/lkage.h | 416251f902e87188982bd866903018f5e3c28ec9 | []
| no_license | marcellodash/psmame | 76fd877a210d50d34f23e50d338e65a17deff066 | 09f52313bd3b06311b910ed67a0e7c70c2dd2535 | refs/heads/master | 2021-05-29T23:57:23.333706 | 2011-06-23T20:11:22 | 2011-06-23T20:11:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,750 | h |
class lkage_state : public driver_device
{
public:
lkage_state(running_machine &machine, const driver_device_config_base &config)
: driver_device(machine, config) { }
UINT8 * m_scroll;
UINT8 * m_vreg;
UINT8 * m_videoram;
UINT8 * m_spriteram;
// UINT8 * m_paletteram; // currently this uses generic palette handling
/* video-related */
tilemap_t *m_bg_tilemap;
tilemap_t *m_fg_tilemap;
tilemap_t *m_tx_tilemap;
UINT8 m_bg_tile_bank;
UINT8 m_fg_tile_bank;
UINT8 m_tx_tile_bank;
int m_sprite_dx;
/* misc */
int m_sound_nmi_enable;
int m_pending_nmi;
/* mcu */
UINT8 m_from_main;
UINT8 m_from_mcu;
int m_mcu_sent;
int m_main_sent;
UINT8 m_port_a_in;
UINT8 m_port_a_out;
UINT8 m_ddr_a;
UINT8 m_port_b_in;
UINT8 m_port_b_out;
UINT8 m_ddr_b;
UINT8 m_port_c_in;
UINT8 m_port_c_out;
UINT8 m_ddr_c;
/* lkageb fake mcu */
UINT8 m_mcu_val;
int m_mcu_ready; /* cpu data/mcu ready status */
/* devices */
device_t *m_maincpu;
device_t *m_audiocpu;
device_t *m_mcu;
};
/*----------- defined in machine/lkage.c -----------*/
READ8_HANDLER( lkage_68705_port_a_r );
WRITE8_HANDLER( lkage_68705_port_a_w );
READ8_HANDLER( lkage_68705_port_b_r );
WRITE8_HANDLER( lkage_68705_port_b_w );
READ8_HANDLER( lkage_68705_port_c_r );
WRITE8_HANDLER( lkage_68705_port_c_w );
WRITE8_HANDLER( lkage_68705_ddr_a_w );
WRITE8_HANDLER( lkage_68705_ddr_b_w );
WRITE8_HANDLER( lkage_68705_ddr_c_w );
WRITE8_HANDLER( lkage_mcu_w );
READ8_HANDLER( lkage_mcu_r );
READ8_HANDLER( lkage_mcu_status_r );
/*----------- defined in video/lkage.c -----------*/
WRITE8_HANDLER( lkage_videoram_w );
VIDEO_START( lkage );
SCREEN_UPDATE( lkage );
| [
"Mike@localhost"
]
| [
[
[
1,
74
]
]
]
|
10705658841fbc13ce2255f4a0396488c7e08811 | b03c23324d8f048840ecf50875b05835dedc8566 | /engin3d/src/Graphics/Camera.h | 9c0be5143ef11d1ff26ecdb5b2f1347df8070cb4 | []
| no_license | carlixyz/engin3d | 901dc61adda54e6098a3ac6637029efd28dd768e | f0b671b1e75a02eb58a2c200268e539154cd2349 | refs/heads/master | 2018-01-08T16:49:50.439617 | 2011-06-16T00:13:26 | 2011-06-16T00:13:26 | 36,534,616 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,204 | h | #ifndef CAMERA_H
#define CAMERA_H
#include "../Libraries/MathLib/MathLib.h"
class cCamera
{
private:
cMatrix mView;
cMatrix mProj;
cMatrix mViewProj; // same as View Matrix * Proj Matrix
inline void RefreshViewProj() { mViewProj = mView * mProj; }
public:
void Init();
void SetLookAt( const cVec3 &lvPosition, const cVec3 &lvTarget,// LvUpWorld by default is +Y Vector
const cVec3 &lvUpWorld = cVec3(0.0f, 1.0f, 0.0f) );
void SetOrtho( float lfLeft, float lfRight,
float lfBottom, float lfTop,
float lfZNear, float lfZNFar ); // Set 2D Proyection
void SetPerspective( float lfFOVY_Rad, float lfAspect,
float lfZNear, float lfZFar );// 3D Proyection
cVec3 GetFront() const { mView.GetFront(); }
cVec3 GetLeft() const { mView.GetLeft(); }
cVec3 GetRight() const { mView.GetRight(); }
cVec3 GetUp() const { mView.GetUp(); }
cVec3 GetPosition() const { mView.GetPosition(); }
const cMatrix &GetView() const { return mView; }
const cMatrix &GetProj() const { return mProj; }
const cMatrix &GetViewProj() const { return mViewProj; }
};
// GL_MODELVIEW = WorldMatrix * ViewMatrix
// GL_PROJECTION = ProyectionMatrix
#endif | [
"[email protected]"
]
| [
[
[
1,
39
]
]
]
|
95e1322eb3015a3299e531c28795de4cfebe99dd | 89d2197ed4531892f005d7ee3804774202b1cb8d | /GWEN/include/Gwen/Controls/TabTitleBar.h | 3bff1b95874ba6f4f79bb145952cd57dd0b7dd96 | [
"MIT",
"Zlib"
]
| permissive | hpidcock/gbsfml | ef8172b6c62b1c17d71d59aec9a7ff2da0131d23 | e3aa990dff8c6b95aef92bab3e94affb978409f2 | refs/heads/master | 2020-05-30T15:01:19.182234 | 2010-09-29T06:53:53 | 2010-09-29T06:53:53 | 35,650,825 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,114 | h | /*
GWEN
Copyright (c) 2010 Facepunch Studios
See license in Gwen.h
*/
#pragma once
#pragma once
#include "Gwen/Controls/Base.h"
#include "Gwen/Controls/Label.h"
#include "Gwen/Controls/TabButton.h"
#include "Gwen/DragAndDrop.h"
#include "Gwen/Skin.h"
namespace Gwen
{
namespace Controls
{
class GWEN_EXPORT TabTitleBar : public Label
{
public:
GWEN_CONTROL_INLINE( TabTitleBar, Label )
{
SetMouseInputEnabled( true );
SetTextPadding( Gwen::Padding( 5, 2, 5, 2 ) );
SetPadding( Gwen::Padding( 1, 2, 1, 2 ) );
DragAndDrop_SetPackage( true, "TabWindowMove" );
}
void Render( Skin::Base* skin )
{
skin->DrawTabTitleBar( this );
}
void DragAndDrop_StartDragging( Gwen::DragAndDrop::Package* pPackage, int x, int y )
{
DragAndDrop::SourceControl = GetParent();
DragAndDrop::SourceControl->DragAndDrop_StartDragging( pPackage, x, y );
}
void UpdateFromTab( TabButton* pButton )
{
SetText( pButton->GetText() );
SizeToContents();
}
private:
};
}
}
| [
"haza55@5bf3a77f-ad06-ad18-b9fb-7d0f6dabd793"
]
| [
[
[
1,
53
]
]
]
|
1befc56258c53e425f76bd7b7ae3014074ef12cd | bd89d3607e32d7ebb8898f5e2d3445d524010850 | /adaptationlayer/tsy/simatktsy_dll/inc/satmesshandler.h | aa1b869ab09ab202d5a3ce53ad66d4b881ee8cc5 | []
| no_license | wannaphong/symbian-incubation-projects.fcl-modemadaptation | 9b9c61ba714ca8a786db01afda8f5a066420c0db | 0e6894da14b3b096cffe0182cedecc9b6dac7b8d | refs/heads/master | 2021-05-30T05:09:10.980036 | 2010-10-19T10:16:20 | 2010-10-19T10:16:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 45,331 | h | /*
* Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#ifndef SATMESSHANDLER_H
#define SATMESSHANDLER_H
// INCLUDES
#include "cmmphonetreceiver.h" // mmmmessagereceiver interface
#include <etelsat.h> // etel sat api
#include <product_profile_definitions.h> // product profile definitions
// CONSTANTS
// UICC file path max length
const TUint8 KUiccFilePathLength( 8 );
// UICC file path length when reading service table
const TUint8 KUiccFilePathLengthServiceTable( 6 );
// Call Server's maximum address length. Use only with Call Server messages.
const TUint8 KCallServerMaxAddressLenght( 123 );
const TInt KAtkPdpCcRespMaxSize( 690 );
// Bitmask for status bit of call control in USIM
const TUint8 KCallControlBitMaskUsim( 0x20 );
// Bitmask for status bit of call control in SIM
const TUint8 KCallControlBitMaskSim( 0xC0 );
// Bitmask for status bit of SMS PP DD in USIM
const TUint8 KSmsPpDdBitMaskUsim( 0x08 );
// Bitmask for status bit of SMS PP DD in SIM
const TUint8 KSmsPpDdBitMaskSim( 0x0C );
// Bitmask for status bit of MO SMS control in USIM
const TUint8 KMoSmsControlBitMaskUsim( 0x40 );
// Bitmask for status bit of MO SMS control in SIM
const TUint8 KMoSmsControlBitMaskSim( 0x03 );
// Bitmask for status bit of USSD CC in SIM
const TUint8 KMoUssdCallControlBitMaskSim( 0x03 );
// Unique transaction IDs for UICC messages
const TUint8 KUiccTrIdCommon( 0xFA );
const TUint8 KUiccTrIdReadSatIcon( 0xFB );
const TUint8 KUiccTrIdReadIconClut( 0xF8 );
const TUint8 KUiccTrIdReadIconInstancePhase1( 0xF7 );
const TUint8 KUiccTrIdReadIconInstancePhase2( 0xF6 );
const TUint8 KUiccTrIdServiceTableByte4( 0xFC );
const TUint8 KUiccTrIdServiceTableByte10( 0xF9 );
const TUint8 KUiccTrIdServiceTableByte7( 0xFD );
const TUint8 KUiccTrIdServiceTableByte11( 0xFF );
// PollInterval, PollingOff
const TUint8 KDefaultPollInterval( 0x00 );
const TUint8 KMinPollInterval( 0x05 );
const TUint8 KMaxPollInterval( 0xFF );
const TUint8 KBlackAndWhite( 0x11 ); // Image Coding Scheme
// FORWARD DECLARATIONS
class CMmPhoNetSender;
class CTsySatMessaging;
class CBerTlv;
// CLASS DECLARATION
/**
* SAT message handler class.
* Handles message sending and receiving to and from phonet.
*
* @lib simatktsy.lib
* @since Series60_ver 2.6
*/
class CSatMessHandler : public CBase, public MMmMessageReceiver
{
public: // Data types
//Type of SIM card
enum TIccType
{
EIccTypeSim2GGsm,
EIccTypeSim3G,
EIccTypeSimUnknown
};
//Ss and Ussd status
enum TSsStatus
{
ENotBusy,
ESsBusy,
EUssdBusy
};
// Location information
struct TLocationInfo
{
TInt iRegStatus; // Registration status
TBuf8<2> iLac; // Location Area Code
TBuf8<4> iCellId;
TBuf8<3> iOperatorCode;
};
public: // Constructors and destructor
/**
* Two-phased constructor.
* @param aTsySatMessaging pointer to TsySatMessaging class
* @param aPnSend Phonetsender for passing messages to phonet
*/
static CSatMessHandler* NewL( CTsySatMessaging* aTsySatMessaging,
CMmPhoNetSender* aPnSend );
/**
* Destructor.
*/
virtual ~CSatMessHandler();
private: // Constructors
/**
* C++ default constructor.
* @param aTsySatMessaging pointer to TsySatMessaging class
* @param aPnSend Phonetsender for passing messages to phonet
*/
CSatMessHandler( CTsySatMessaging* aTsySatMessaging,
CMmPhoNetSender* aPnSend );
public: // New methods
/**
* Display text response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails command details tlv
* @param aGeneralResult result of the proactive command display text
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt DisplayTextTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* Get Inkey response method.
* @since NCP 3.1
* @param aTransId Unique transaction ID
* @param aCommandDetails command details tlv
* @param aRsp Response packet from Etel
* @return phonet sender status
*/
TInt GetInkeyTerminalResp( const TUint8 aTransId,
const TDes8& aCommandDetails, const RSat::TGetInkeyRspV2& aRsp );
/**
* Get Input response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details tlv
* @param aGeneralResult result of the proactive command Get Input
* @param aAdditionalInfo Additional info response might give
* @param aTextString text string provided by the user
* @param aDataCodingScheme data coding scheme for text string
* @return phonet sender status
*/
TInt GetInputTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo,
TDesC16& aTextString, TUint8 aDataCodingScheme );
/**
* Play Tone response method.
* @since Series60_ver 2.6
* @param Unique transaction ID
* @param aCommandDetails
* @param aGeneralResult result of the proactive command
* @param aAdditionalInfo Additional info given in some cases
* @return phonet sender status
*/
TInt PlayToneTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* Setup Menu response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails command details tlv
* @param aGeneralResult result of the proactice command Setup Menu
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt SetUpMenuTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* Select Item response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails command details tlv
* @param aGeneralResult result of the proactice command Select Item
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt SelectItemTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* Send SM response method.
* @since Series60_ver 2.6
* @param aPCmdNumber Unique transaction ID
* @param aCommandDetails command details tlv
* @param aGeneralResult result of the proactice command Send SM
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt SendSmTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* Send SS response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactive command Send SS
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt SendSsTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TDesC8& aAdditionalInfo );
/**
* Send DTMF response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aPCmdNumber Command number
* @param aGeneralResult result of the proactice command Send SS
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt SendDtmfTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* Send USSD response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails command details of the PCmd
* @param aGeneralResult result of the proactive command Send USSD
* @param aAdditionalInfo Additional info the response might give
* @param aUssdData Ussd text string, without the DCS byte
* @param aUssdCbsDataCodingScheme, DCS byte of the USSD data
* @return phonet sender status
*/
TInt SendUssdTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo,
TDes& aUssdData, TUint8 aUssdCbsDataCodingScheme );
/**
* Polling Interval response method
* @since Series60_ver 2.8
* @param aPCmdNumber Unique transaction ID
* @param aCommandDetails command details tlv
* @param aGeneralResult result of the proactive command
* @param aAdditionalInfo Additional info response might give
* @param aNumOfUnits time interval
* @return phonet sender status
*/
TInt PollIntervalTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo,
TUint8 aNumOfUnits );
/**
* Setup Call response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactive command Setup Call
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt SetUpCallTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* Refresh response method.
* @since Series60_ver 2.6
* @param aPCmdNumber Unique transaction ID
* @param aGeneralResult result of the proactice command Refresh
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt RefreshTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* Menu Selection method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aItemIdentifier identifier of the selected menu item
* @param aHelp help requested by the user indicator
* @return phonet sender status
*/
void MenuSelectionInd( TUint8 aTransId, TUint8 aItemIdentifier,
TUint8 aHelp );
/**
* Launch Browser terminal response method
* @since Series60_ver 2.6
* @param aTransId transaction id
* @param aPCmdNumber command number
* @param aGeneralResult
* @param aAdditionalInfo
* @param aCmdQualifier
* @return phonet sender status
*/
TInt LaunchBrowserTerminalResp( TUint8 aTransId,
TDes8& aCommandDetails, TUint8 aGeneralResult,
TUint8 aAdditionalInfo );
/**
* Test if a command was performed successfully
* @since Series60_ver 2.6
* @param aGeneralResult
* @return ETrue if command performed successfully, else EFalse
*/
TBool CommandPerformedSuccessfully( TUint8 aGeneralResult );
/**
* SetupIdleModeText Terminal Response
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails command details tlv
* @param aGeneralResult result of the proactive command display text
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt SetUpIdleModeTextTerminalResp( TUint8 aTransId,
TDes8& aCommandDetails, TUint8 aGeneralResult,
TUint8 aAdditionalInfo );
/**
* SetUpEventList response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails command details tlv
* @param aGeneralResult result of the proactive command display text
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt SetUpEventListTerminalResp( TUint8 aTransId,
TDes8& aCommandDetails, TUint8 aGeneralResult,
TUint8 aAdditionalInfo );
/**
* PollingOff response method.
* @since Series60_ver 2.6
* @param aPCmdNumber Unique transaction ID
* @param aCommandDetails command details tlv
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt PollingOffTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aAdditionalInfo );
/**
* LocalInfo response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactice command
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt LocalInfoTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TDes& aAdditionalInfo );
/**
* Timer management response method.
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactive command
* @param aTimerValue[3]: timer value in hours, minutes and seconds
* @param aTimerId: timer identifier
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt TimerMgmtTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TUint8 aTimerValue[3], TUint8 aTimerId,
TUint8 aAdditionalInfo );
/**
* Timer expiration indication
* @since Series60_ver 2.6
* @param TUint8 aTransId: Unique transaction ID
* @param TUint8 aTimerId: timer identification
* @param TUint8 aTimerValue: timer value
* @return TInt:
*/
TInt TimerExpirationInd ( TUint8 aTransId, TUint8 aTimerId,
TUint8 aTimerValue[3] );
/**
* More time response
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactive command
* @return phonet sender status
*/
TInt MoreTimeTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult );
/**
* Open Channel response method
* @since Series60_ver 3.0
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactive command
* @param aAdditionalInfo Additional info response might give
* @param aBearerType
* @param aBearer
* @param aBufferSize
* @return phonet sender status
*/
TInt OpenChannelTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, TDes8& aAdditionalInfo, TUint8 aBearerType,
TDesC8& aBearer, TUint16 aBufferSize );
/**
* Get Channel Status response method.
* @since Series60_ver 3.0
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactice command
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt GetChannelStatusTerminalResp( TUint8 aTransId,
TDes8& aCommandDetails, TUint8 aGeneralResult,
const TDes8& aAdditionalInfo );
/**
* Close Channel response method.
* @since Series60_ver 3.0
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactice command
* @param aAdditionalInfo Additional info response might give
* @return phonet sender status
*/
TInt CloseChannelTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, const TDes8& aAdditionalInfo );
/**
* Receive Data response method.
* @since Series60_ver 3.0
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactice command
* @param aAdditionalInfo Additional info response might give
* @param aChannelDataLength
* @return phonet sender status
*/
TInt ReceiveDataTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, const TDes8& aAdditionalInfo,
TUint8 aChannelDataLength );
/**
* Send Data response method.
* @since Series60_ver 3.0
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactice command
* @param aAdditionalInfo Additional info response might give
* @param aChannelDataLength
* @return phonet sender status
*/
TInt SendDataTerminalResp( TUint8 aTransId, TDes8& aCommandDetails,
TUint8 aGeneralResult, const TDes8& aAdditionalInfo,
TUint8 aChannelDataLength );
/**
* SendTerminalResponse
* @since Series60_ver 2.6
* @param aCommandDetails Command details TLV
* @param aBerTlvSpecificData data to be sent
* @return phonet sender status
*/
TInt SendTerminalResponse( const TDes8& aCommandDetails,
const TDesC8& aBerTlvSpecificData,
const TUint8 aTransId = 0 );
/**
* Sends an empty terminal response to the SIMSON
* @param aTransId transaction id / should be same as in REQ
* @return phonet sender status
*/
TInt SendEmptyTerminalRsp( const TInt aTransId );
/**
* send UICC_CAT_REQ
* @since Series60_ver 3.0
* @param aTransId Transaction id of envelope
* @param aBerTlv TLV data of the envelope command
* @param aStore Decides wether the provided envelope
* is stored for resending or not.
* @return phonet sender status
*/
TInt UiccCatReqEnvelope( TUint8 aTransId, const TDesC8& aBerTlv,
TBool aStore = ETrue );
/**
* Send a Sms-Pp report to SMS server, with subblocks
* @since Series60_ver 2.6
* @param aTransId Unique transaction Id
* @param aData data to be appended to the request
* @return None
*/
void SendSmsReportReq( TUint8 aTransId, TDesC8& aData );
/**
* Send a request to SMS server
* @since Series60_ver 2.6
* @param aTransId Unique transaction Id
* @param aMsgId Message identifier of the request
* @param aData data to be appended to the request
* @return None
*/
void SmsResoureConfReq( TUint8 aTransId, TUint8 aMsgId, TDesC8& aData );
/**
* Breaks a INFO_SERIAL_NUMBER_READ_RESP ISI-message
* @since Series60_ver 3.0
* @param TIsiReceiveC& aIsiMessage response to envelope
* @return none
*/
//void InfoSerialNumberReadResp( const TIsiReceiveC& aIsiMessage );
/**
* Send NET_NEIGHBOUR_CELLS_REQ message to Phonet.
* @since Series60_ver 2.6
* @param aTransId a unique transaction id
* @param aCellInfoType NET_NEIGHBOUR_CELL_INFO_TYPE
* @return TInt: Phonet sender status
*/
TInt NetNeighbourCellsReq( TUint8 aTransId, TUint8 aCellInfoType );
/**
* Breaks a NET_NEIGHBOUR_CELLS_RESP ISI-message
* @since Series60_ver 3.0
* @param aIsiMessage response to envelope
* @return none
*/
void NetNeighbourCellResp( const TIsiReceiveC& aIsiMessage );
/**
* Sends a CALL_MODEM_RESOURCE_REQ ISI-message to modem Call server.
* @param sTransId Unique transaction id
* @param aMsg ISI message data to be sent
* @return TInt: Phonet sender status
*/
TInt CallModemResourceReq( TUint8 aTransId, const TDesC8& aMsg );
/**
* Sends a CALL_MODEM_RESOURCE_CONF_REQ ISI-message to modem Call server
* @param aResourceId resource to be controlled
* @param aResourceIdMask mask for resource to be controlled
* @return TInt: Phonet sender status
*/
TInt CallModemResourceConfReq( TUint16 aResourceId, TUint16 aResourceIdMask );
/**
* Sends a SS_RESOURCE_CONF_REQ ISI-message to modem SS server.
* @return TInt: Phonet sender status
*/
TInt SsResourceConfReq();
/**
* Sends a SS_RESOURCE_CONTROL_REQ ISI-message to modem SS server.
* @param aTransId Unique transaction id
* @param aMsg ISI message data to be sent
* @return TInt: Phonet sender status
*/
TInt SsResourceControlReq(
TUint8 aTransId,
const TDesC8& aMsg
);
/**
* Sends a GPDS_RESOURCE_CONF_REQ ISI-message to modem SS server.
* @return TInt: Phonet sender status
*/
TInt GpdsResourceConfReq();
/**
* Sends a GPDS_RESOURCE_CONTROL_REQ ISI-message to modem SS server.
* @param aTransId Unique transaction id
* @param aMsg ISI message data to be sent
* @return TInt: Phonet sender status
*/
TInt GpdsResourceControlReq(
TUint8 aTransId,
const TDesC8& aMsg
);
/**
* Set Polling Interval, sending a request to sim server
* @since Series60_ver 2.6
* @param aTraId Transaction Id
* @param aValue in seconds
* @return none
*/
void SetPollingInterval( TUint8 aTraId, TUint8 aValue );
/**
* Method to check SIM server response to a refresh request
* @since Series60_ver 2.6
* @param aStatus SIM server status
* @return none
*/
void RefreshResultL( TUint8 aStatus );
/**
* Method to check SIM server response to a set polling request
* Called by SimAtkRespL
* @since Series60_ver 2.6
* @param aStatus SIM server status
* @param aTransId Transaction Id
* @param aInterval obtained from the ISI message of the response
* @param None
*/
void SetPollingResult( TUint8 aStatus, TUint8 aTransId,
TUint8 aInterval );
/**
* Method to check that proactive command is in correct format.
* @since NCP 5.0
* @param aIsiMessage
* @return KErrNone or KErrCorrupt
*/
TInt CheckProactiveCommand( const TIsiReceiveC& aIsiMessage );
/**
* Send a SMS_CB_ROUTING_REQ ISI-message
* @since Series60_ver 2.6
* @param aTransId
* @param aRoutingCommand
* Return value: phonet sender return value
*/
TInt SmsCbRoutingReq( TUint8 aTransId, TUint8 aRoutingCommand );
/**
* Breaks a SMS_CB_ROUTING_RESP ISI-message
* @since NCP 3.1
* @param aIsiMessage Message from SMS server
* Return value: none
*/
void SmsCbRoutingResp( const TIsiReceiveC& aIsiMessage );
/**
* Breaks a SMS_RESOURCE_CONF_IND ISI-message
* @since NCP 3.1
* @param aIsiMessage Message from SMS server
* Return value: none
*/
void SmsResourceConfInd( const TIsiReceiveC& aIsiMessage );
/**
* Creates InfoSerialNumberReadReq ISI message and sends it to Phonet
* @since Series60_ver 3.0
* @param aTransId: unique transaction id
* @param aTarget: requested data
* return value TInt : success/failure value
*/
//TInt InfoSerialNumberReadReq( TUint8 aTransId, TUint8 aTarget );
/**
* Creates NET_CELL_INFO_GET_REQ ISI message and sends it to Phonet
* @param aTransId: unique transaction id
* return value TInt: success/failure value
*/
TInt NetCellInfoGetReq( TUint8 aTransId );
/**
* Breaks a NET_CELL_INFO_GET_RESP ISI-message
* @param aIsiMessage Net cell info get resp ISI message
* Return value: none
*/
void NetCellInfoGetResp( const TIsiReceiveC& aIsiMessage );
/**
* Sends a GSS_CS_SERVICE_REQ isi-message to phonet
* @since Series60_ver 2.6
* @param aTransId Transaction ID
* @param TUint8 aOperation: Gss operation
* @retrun TInt: Phonet sender status
*/
TInt GssCsServiceReq( TUint8 aTransId, TUint8 aOperation );
/**
* Breaks a GSS_CS_SERVICE_RESP ISI-message
* @since Series60_ver 3.0
* @param aIsiMessage ISI message from GSS server
* Return value: none
*/
void GssCsServiceResp( const TIsiReceiveC& aIsiMessage );
/**
* Breaks a GSS_CS_SERVICE_FAIL_RESP ISI-message
* @since Series60_ver 3.0
* @param aIsiMessage ISI message from GSS server
* Return value: none
*/
void GssCsServiceFailResp( const TIsiReceiveC& aIsiMessage );
/**
* Language Notification response
* @since Series60_ver 2.6
* @param aTransId Unique transaction ID
* @param aCommandDetails Command details TLV
* @param aGeneralResult result of the proactive command
* @param aLanguage
* @return phonet sender status
*/
TInt LanguageNotificationTerminalResp( TUint8 aTransId,
TDes8& aCommandDetails, TUint8 aGeneralResult,
TUint8 aAdditionalInfo );
/**
* Breaks a NET_TIME_IND isi-message
* @since Series60_ver 3.0
* @param aIsiMessage received indication
* @return none
*/
void NetTimeInd( const TIsiReceiveC& aIsiMessage );
/**
* Send a response to SMS server after a SMS resource Indication received from
* SMS sever.
* This response tells whether the SMS can be sent or not.
* @since Series60_ver 2.6
* @param aTransId Transaction id, same as in the request
* @param aData Data to be sent
* @return none
*/
TInt SendSmsResourceReq( TUint8 aTransId, TDesC8& aData,
TUint8 aReceiverObject );
/**
* Breaks a SS_STATUS_IND isi-message
* @since Series60_ver 3.0
* @param TIsiReceiveC& aIsiMessage received indication
* @return none
*/
void SsStatusInd( const TIsiReceiveC& aIsiMessage );
/**
* Helper method to find out does the given result require an additional
* info byte(s) in terminal response
* @param aGeneralResult
* @return ETrue if result needs an additional info byte(s), else EFalse
*/
TBool AdditionalInfoNeeded( const TUint8 aGeneralResult );
/**
* Breaks a NET_RAT_IND isi-message
* @since Series60_ver 3.0
* @param aIsiMessage received indication
* @return none
*/
void NetRatInd( const TIsiReceiveC& aIsiMessage );
/**
* Stores Network service status to an internal structure
* @param aIsiMessage NetCellInfoInd or NetCellInfoGetResp
* @return TInt: Success value
*/
TInt StoreNetServiceStatus( const TIsiReceiveC& aIsiMessage );
/**
* Getter for location information
* @since NCP 5.0
* @return Location Information structure
*/
const TLocationInfo& LocationInfo();
/**
* Sends a INFO_PP_READ_REQ isi-message to phonet
* @since NCP 5.0
* @param aReqType Product profile feature being requested
* @retrun TInt: Phonet sender status
*/
TInt InfoPpReadReq( const TUint8 aReqType );
/**
* Breaks a INFO_PP_READ_RESP isi-message
* @since Series60_ver 5.0
* @param aIsiMessage received indication
* @return none
*/
void InfoPpReadRespL( const TIsiReceiveC& aIsiMessage );
/**
* Validates lengths of simple tlv objects inside BER TLV
* object
* @param berTlv BER TLV object
* @retrun TInt: Validation status
*/
TInt CheckTlvObjects( CBerTlv& berTlv );
/**
* Activate or DeActivate MO SMS Control on SMS Server according to SIM
* Server Response
* @param MO SM control status in SIM card
* @return none
*/
void SimMoSmsControlAvail( TUint8 aStatus );
/**
* Send UICC_CAT_REQ(UICC_SB_TERMINAL_PROFILE) ISI message
* @return none
*/
void UiccTerminalProfileReq();
/**
* Send UICC_APPL_CMD_REQ ISI message for reading data
* from service table of UICC
* @param aTrId Transaction ID
* @param aFileOffset Offset of service table to be read
* @return Error code
*/
TInt UiccReadServiceTableReq( TUint8 aTrId, TUint16 aFileOffset );
/**
* Send UICC_APPL_CMD_REQ ISI message for reading data
* from EF img
* @param aRecordNumber Record number
* @param aFileOffset File Offset
* @param aDataAmount Data amount
* @param aTrId Transaction ID
* @return Error code
*/
TInt UiccReadSatIconReq(
TUint8 aRecordNumber,
TUint8 aFileOffset,
TUint8 aDataAmount,
TUint8 aTrId );
/**
* Send UICC_APPL_CMD_REQ ISI message for reading image instance
* @param aFileId File ID
* @return Error code
*/
TInt UiccReadSatIconInstanceReq( TUint16 aFileId );
/**
* Send UICC_CAT_REQ ISI message
* @param aCommand Command
* @return Error code
*/
TInt UiccCatReq( TUint8 aCommand );
/**
* Send UICC_CAT_REQ ISI message for refresh command
* @param aTransId Transaction ID
* @param aServiceType Service type
* @param aFileList File list
* @param aAid Application ID
* @return Error code
*/
TInt UiccCatReqRefresh(
const TUint8 aTransId,
const TUint8 aServiceType,
TDes8& aFileList,
const TDesC8& aAid );
/**
* Send UICC_CAT_REQ ISI message for terminal response
* @param aCommandDetails Command details
* @param aBerTlvSpecificData BER-TLV data
* @param aTransId Transaction ID
* @return Error code
*/
TInt UiccCatReqTerminalResponse(
const TDes8& aCommandDetails,
const TDesC8& aBerTlvSpecificData,
const TUint8 aTransId = 0 );
/**
* Handle UICC_CAT_RESP ISI message for envelope response
* @param aIsiMessage Received ISI message
* @return Information about handling of the message
*/
TBool UiccCatRespEnvelope( const TIsiReceiveC& aIsiMessage );
/**
* Handle UICC_CAT_RESP ISI message for terminal response
* @param aIsiMessage Received ISI message
* @return Information about handling of the message
*/
TBool UiccCatRespTerminalResponse( const TIsiReceiveC& aIsiMessage );
/**
* Get application file ID
* @return Application file ID
*/
const TDesC8& GetApplicationFileId();
/**
* Set status of iSatReady flag
* @param aSatReadyStatus SAT status
* @return None
*/
void SetSatReadyStatus( TBool aSatReadyStatus );
/**
* Get status of iSatReady flag
* @return SAT status
*/
TBool GetSatReadyStatus();
/**
* Get status of iTerminalProfileSent flag
* @return Terminal profile status
*/
TBool GetTerminalProfileStatus();
/**
* Get clut data
* @return Clut data
*/
const TDesC8& GetClut();
public: // Inline functions
/**
* Returns time zone information received from network.
* @since NCP 5.0
* @param none
* @return TUint8 Time zone
*/
inline TUint8 TimeZone() const;
/**
* Method to check if IMEI is successfully received
* @since NCP 5.0
* @return ETrue if IMEI is known, otherwise EFalse
* @param None
*/
inline TBool ImeiAvailable() const;
/**
* Method to check if IMEISV is successfully received
* @return ETrue if IMEISV is known, otherwise EFalse
* @param None
*/
inline TBool ImeiSvAvailable() const;
/**
* Method to check Location information status
* @since NCP 5.0
* @return ETrue or EFalse
* @param None
*/
inline TBool ServiceAvailable() const;
/**
* Get Polling off status
* @since NCP 5.0
* @return Return ETrue if Polling is set off,
* and false after a polling interval pcmd
*/
inline TBool PollingOff() const;
/**
* Set Polling off status
* @since NCP 5.0
* @param aPollingOff true after a Polling Off,
* and false after a polling interval pcmd
* @return none
*/
inline void SetPollingOff( const TBool aPollingOff );
/**
* Get Ss status
* @since NCP 5.0
* @return status indicating if Ss or Ussd transaction ongoing
*/
inline TSsStatus SsStatus() const;
/**
* Get current access technology
* @since NCP 5.1
* @return current access technology
*/
inline TUint8 CurrentAccessTechnology() const;
#ifdef INFO_PP_ENHANCED_NETWORK_SELECTION
/**
* Get current status of INFO_PP_ENHANCED_NETWORK_SELECTION PP flag
* @return current status of INFO_PP_ENHANCED_NETWORK_SELECTION PP flag
*/
inline TBool EnsSupported() const;
#endif
/**
* Get Old Polling interval status
* @return Return ETrue if Old Polling is set on,
* and EFalse otherwise
*/
inline TBool OldPollInterval() const;
public: // Functions from MMmMessageReceiver-interface
/**
* Called by phonet receiver when an ISI message has
* been received
* @since Series60_ver 3.0
* @param aIsiMessage The received ISI message
* @return none
*/
virtual void ReceiveMessageL( const TIsiReceiveC& aIsiMessage );
/**
* Handles errors which comes come from PhoNetReceiver RunError
* @param aIsiMessage The received ISI message
* @param aError Error code
* @return none
*/
virtual void HandleError( const TIsiReceiveC& /*aIsiMessage*/,
TInt /*aErrorCode*/ );
private: // Constructors
/**
* Copy constructor, usage not allowed
* @param Satmesshandler reference
*/
CSatMessHandler( const CSatMessHandler& aRhs );
/**
* Assignment operator, usage not allowed
* @param Satmesshandler reference
* @return aRhs SatMessHandler reference
*/
CSatMessHandler& operator = ( const CSatMessHandler& aRhs );
/**
* Constructor method for sat message handler.
*/
void ConstructL();
private: // New methods
/**
* Handles the Net server related messages
* @since Series60_ver 3.0
* @param aIsiMessage Isi message from net server
* @return none
*/
void NetServerMessageReceived( const TIsiReceiveC& aIsiMessage );
/**
* Handles the Phone Info server related messages
* @since Series60_ver 3.0
* @param aIsiMsg proactive command
* @return none
*/
//void PhoneInfoMessageReceivedL( const TIsiReceiveC& aIsiMessage );
/**
* Handles the UICC server related messages
* @param aIsiMessage received ISI message
* @return Information about handling of response
*/
TBool UiccServerMessageReceivedL( const TIsiReceiveC& aIsiMessage );
/**
* Handles the Sms server related messages
* @since NCP 3.1
* @param aIsiMessage Message from SMS server
* @return none
*/
void SmsServerMessageReceived( const TIsiReceiveC& aIsiMessage );
/**
* Handles the Ss server related messages
* @since Series60_ver 3.0
* @param aIsiMsg proactive command
* @return none
*/
void SsServerMessageReceived( const TIsiReceiveC& aIsiMessage );
/**
* Handles the GSM Stack server related messages
* @since Series60_ver 3.0
* @param aIsiMessage ISI message from GSS server
* @return none
*/
void GsmStackServerMessageReceived( const TIsiReceiveC& aIsiMessage );
/**
* Handles proactive procedures, i.e Call Control, Data Download,
* Event Download and MO-SMS Control related messages
* @since NCP 3.1
* @param aIsiMessage received ISI message
* @return none
*/
void ProactiveProcedureMessageReceivedL(
const TIsiReceiveC& aIsiMessage );
/**
* Breaks UICC_APPL_CMD_RESP ISI message
* @param aReceiverObject: Receiver object ID
* @return None
*/
void UiccApplCmdResp( const TIsiReceiveC& aIsiMessage );
/**
* Breaks a UICC_CAT_IND ISI-message
* @param aIsiMessage Received ISI message
* @return None
*/
void UiccCatIndL( const TIsiReceiveC& aIsiMessage );
private: // Data
// Pointer to SAT messaging object
CTsySatMessaging* iTsySatMessaging;
// Pointer to Phonet Sender
CMmPhoNetSender* iPnSend;
// Storage for terminal resp transaction id.
TInt iTerminalRespTraId;
// Save the SimReadField transaction id used by GetIcon.
TInt iGetIconSimReadFieldTraId;
// Save the SimReadField transaction id used by DataDownload.
TInt iDataDownloadSimReadFieldTraId;
// Save the SMS_CB_ROUTING_REQ transaction id used by DataDownload.
TInt iCbRoutingReqTraId;
// Variable for storing card id
TUint8 iCardId;
// For storing IMEI code.
TBuf8<16> iIMEI;
// For storing IMEI-SV BCD string
TBuf8<9> iIMEIsv;
// For storing NMR
TBuf8<16> iNMR;
// For storing BCCH channel list
TBuf<32> iBCCHChannelList;
// For checking if IMEI code has been received
TBool iImeiAvailable;
// For checking if IMEISV code has been received
TBool iImeiSvAvailable;
// Stores the state of SMS CB routing request
TBool iSmsCbRoutingComplete;
// Refresh proactive command is currently active flag.
TBool iRefreshRequestIsOn;
// Variable for storing Timing Advance
TUint8 iTimingAdvance;
// Variable for storing Timing advance Status
TUint8 iTaStatus;
// Time zone information from Network. 0xFF if not received.
TUint8 iTimeZone;
// SIM Server's object Id
TUint8 iSimServerObjectId;
// Variable for storing Current Access Technology
TUint8 iCurrentAccTech;
// Flag is true after a Polling Off, and false after a polling
// interval pcmd
TBool iPollingOff;
// status indicating if Ss or Ussd transaction ongoing
TSsStatus iSsStatus;
// Flag is set true if requested Poll Interval
// is longer than KMaxLegacyPollInterval
TBool iLongPollIntervalReq;
// Location Information
TLocationInfo iLocInfo;
// UTRAN Measurement results
TPtrC8 iUtranNMR;
#ifdef INFO_PP_ATK_MO_SM_CONTROL
// Boolean to check if MO SMS control is supported in product profile
TBool iMoSmsSupportedInPp;
#endif // INFO_PP_ATK_MO_SM_CONTROL
// For storing transaction id in product profile queries. Used only
// with INFO_PP_ATK_MO_SM_CONTROL, but there can be several
// simultaneous PP queries ongoing
TUint8 iInfoPpMoSmsTraId;
#ifdef INFO_PP_ENHANCED_NETWORK_SELECTION
// Boolean to hold status of INFO_PP_ENHANCED_NETWORK_SELECTION in
// product profile
TBool iEnsSupportedInPp;
// Boolean to check if TR for SET UP EVENT LIST has been sent
TBool iSetUpEventListTrSent;
#endif // INFO_PP_ENHANCED_NETWORK_SELECTION
// Previous registration status
TUint8 iPreviousRegistrationStatus;
// Boolean to check if OLD_POLL_INTERVAL control is supported in product profile
TBool iOldPollIntervalSupportedInPp;
// To store Subscription no
TUint8 iSmsCbSubscriptionNo;
// To store SAT server status
TBool iSatReady;
// To store status of terminal profile
TBool iTerminalProfileSent;
// To store card type
TUint8 iCardType;
// To store application ID
TUint8 iApplicationId;
// Application file ID
TBuf8<2> iApplFileId;
// To store UICC client ID
TUint8 iUiccClientId;
// Polling interval
TUint8 iPollingInterval;
// Image coding scheme
TUint8 iImageCodingScheme;
// Number of clut in image instance data
TInt iNumberOfClut;
// Clut data
TPtrC8 iClutData;
};
#include "satmesshandler.inl"
#endif // SATMESSHANDLER_H
// End of File
| [
"dalarub@localhost",
"mikaruus@localhost",
"[email protected]"
]
| [
[
[
1,
1
],
[
3,
13
],
[
15,
42
],
[
44,
46
],
[
48,
50
],
[
52,
52
],
[
54,
60
],
[
62,
62
],
[
64,
552
],
[
554,
636
],
[
638,
690
],
[
692,
792
],
[
794,
794
],
[
796,
817
],
[
819,
968
],
[
976,
1087
],
[
1089,
1094
],
[
1096,
1142
],
[
1144,
1161
],
[
1165,
1170
],
[
1174,
1180
],
[
1185,
1287
]
],
[
[
2,
2
],
[
43,
43
],
[
47,
47
],
[
51,
51
],
[
53,
53
],
[
61,
61
],
[
63,
63
],
[
553,
553
],
[
637,
637
],
[
691,
691
],
[
818,
818
],
[
1088,
1088
],
[
1095,
1095
],
[
1143,
1143
],
[
1162,
1164
]
],
[
[
14,
14
],
[
793,
793
],
[
795,
795
],
[
969,
975
],
[
1171,
1173
],
[
1181,
1184
]
]
]
|
a137080fbb73204f47a7fd99d488106d33d952fb | b7d5640a8078e579f61d54f81858cc1dff3fa7ae | /GameClient/include/network/network.h | 361e645db1dbbbe05983821459a828b14c3ddde2 | []
| no_license | gemini14/Typhon | 7497d225aa46abae881e77450466592dc0615060 | fa799896e13cdfaf40f65ff0981e7d98ad80a5f0 | refs/heads/master | 2016-09-06T14:34:11.048290 | 2011-10-22T07:12:33 | 2011-10-22T07:12:33 | 1,990,457 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 937 | h | #ifndef NETWORK_H
#define NETWORK_H
#include <boost/noncopyable.hpp>
#include <string>
#ifdef WIN32
#include <WinSock2.h>
#include <Ws2tcpip.h>
#else
#include <netinet/in.h>
#endif
#include "logger/logger.h"
#include "network/message.h"
namespace Typhon
{
class Network : boost::noncopyable
{
private:
protected:
// broadcast IP
static sockaddr_in broadcastAddr;
// our IP
static sockaddr_in machineAddr;
static const int recvBufferLength = 1024;
virtual void DisplayError(const std::string &message) = 0;
public:
// designated port
static int portNumber;
Network(const int port);
virtual ~Network();
virtual void BroadcastMessage(const std::string &msg, const char prefix) = 0;
const unsigned long GetIP() const;
std::string GetIPInStringForm() const;
virtual const Message ReceiveMessage() = 0;
virtual bool StartUp() = 0;
};
}
#endif | [
"[email protected]"
]
| [
[
[
1,
49
]
]
]
|
925f738c9c982aa61968e6e818df7ce6b0aae7cb | 91b964984762870246a2a71cb32187eb9e85d74e | /SRC/OFFI SRC!/boost_1_34_1/boost_1_34_1/boost/ptr_container/ptr_set_adapter.hpp | 4aac43942e2ad6154f654bea4869a067c1b1c3d5 | [
"BSL-1.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | willrebuild/flyffsf | e5911fb412221e00a20a6867fd00c55afca593c7 | d38cc11790480d617b38bb5fc50729d676aef80d | refs/heads/master | 2021-01-19T20:27:35.200154 | 2011-02-10T12:34:43 | 2011-02-10T12:34:43 | 32,710,780 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,716 | hpp | //
// Boost.Pointer Container
//
// Copyright Thorsten Ottosen 2003-2005. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see http://www.boost.org/libs/ptr_container/
//
#ifndef BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
#define BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/ptr_container/detail/associative_ptr_container.hpp>
#include <boost/ptr_container/detail/void_ptr_iterator.hpp>
#include <boost/range/iterator_range.hpp>
namespace boost
{
namespace ptr_container_detail
{
template
<
class Key,
class VoidPtrSet
>
struct set_config
{
typedef VoidPtrSet
void_container_type;
typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type
allocator_type;
typedef Key value_type;
typedef value_type
key_type;
typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::value_compare
value_compare;
typedef value_compare
key_compare;
typedef void_ptr_iterator<
BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key >
iterator;
typedef void_ptr_iterator<
BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key >
const_iterator;
template< class Iter >
static Key* get_pointer( Iter i )
{
return static_cast<Key*>( *i.base() );
}
template< class Iter >
static const Key* get_const_pointer( Iter i )
{
return static_cast<const Key*>( *i.base() );
}
BOOST_STATIC_CONSTANT(bool, allow_null = false );
};
template
<
class Key,
class VoidPtrSet,
class CloneAllocator = heap_clone_allocator
>
class ptr_set_adapter_base
: public ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet>,
CloneAllocator >
{
typedef ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet>,
CloneAllocator >
base_type;
public:
typedef BOOST_DEDUCED_TYPENAME base_type::iterator
iterator;
typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
const_iterator;
typedef Key key_type;
typedef BOOST_DEDUCED_TYPENAME base_type::size_type
size_type;
private:
ptr_set_adapter_base()
: base_type( BOOST_DEDUCED_TYPENAME VoidPtrSet::key_compare(),
BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type() )
{ }
public:
template< class Compare, class Allocator >
ptr_set_adapter_base( const Compare& comp,
const Allocator& a )
: base_type( comp, a )
{ }
template< class InputIterator, class Compare, class Allocator >
ptr_set_adapter_base( InputIterator first, InputIterator last,
const Compare& comp,
const Allocator& a )
: base_type( first, last, comp, a )
{ }
template< class PtrContainer >
ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone )
: base_type( clone )
{ }
template< typename PtrContainer >
void operator=( std::auto_ptr<PtrContainer> clone )
{
base_type::operator=( clone );
}
iterator find( const key_type& x )
{
return iterator( this->c_private().
find( const_cast<key_type*>(&x) ) );
}
const_iterator find( const key_type& x ) const
{
return const_iterator( this->c_private().
find( const_cast<key_type*>(&x) ) );
}
size_type count( const key_type& x ) const
{
return this->c_private().count( const_cast<key_type*>(&x) );
}
iterator lower_bound( const key_type& x )
{
return iterator( this->c_private().
lower_bound( const_cast<key_type*>(&x) ) );
}
const_iterator lower_bound( const key_type& x ) const
{
return const_iterator( this->c_private().
lower_bound( const_cast<key_type*>(&x) ) );
}
iterator upper_bound( const key_type& x )
{
return iterator( this->c_private().
upper_bound( const_cast<key_type*>(&x) ) );
}
const_iterator upper_bound( const key_type& x ) const
{
return const_iterator( this->c_private().
upper_bound( const_cast<key_type*>(&x) ) );
}
iterator_range<iterator> equal_range( const key_type& x )
{
std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,
BOOST_DEDUCED_TYPENAME base_type::ptr_iterator>
p = this->c_private().
equal_range( const_cast<key_type*>(&x) );
return make_iterator_range( iterator( p.first ),
iterator( p.second ) );
}
iterator_range<const_iterator> equal_range( const key_type& x ) const
{
std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator,
BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator>
p = this->c_private().
equal_range( const_cast<key_type*>(&x) );
return make_iterator_range( const_iterator( p.first ),
const_iterator( p.second ) );
}
};
} // ptr_container_detail
/////////////////////////////////////////////////////////////////////////
// ptr_set_adapter
/////////////////////////////////////////////////////////////////////////
template
<
class Key,
class VoidPtrSet,
class CloneAllocator = heap_clone_allocator
>
class ptr_set_adapter :
public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator>
{
typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator>
base_type;
public: // typedefs
typedef BOOST_DEDUCED_TYPENAME base_type::iterator
iterator;
typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
const_iterator;
typedef BOOST_DEDUCED_TYPENAME base_type::size_type
size_type;
typedef Key key_type;
typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
auto_type;
typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::key_compare
key_compare;
typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type
allocator_type;
private:
template< typename II >
void set_basic_clone_and_insert( II first, II last ) // basic
{
while( first != last )
{
if( this->find( *first ) == this->end() )
insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit
++first;
}
}
public:
explicit ptr_set_adapter( const key_compare& comp = key_compare(),
const allocator_type& a = allocator_type() )
: base_type( comp, a )
{
BOOST_ASSERT( this->empty() );
}
template< class InputIterator, class Compare, class Allocator >
ptr_set_adapter( InputIterator first, InputIterator last,
const Compare& comp = Compare(),
const Allocator a = Allocator() )
: base_type( comp, a )
{
BOOST_ASSERT( this->empty() );
set_basic_clone_and_insert( first, last );
}
template< class T >
ptr_set_adapter( std::auto_ptr<T> r ) : base_type( r )
{ }
template< class T >
void operator=( std::auto_ptr<T> r )
{
base_type::operator=( r );
}
std::pair<iterator,bool> insert( key_type* x ) // strong
{
this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
auto_type ptr( x );
std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
res = this->c_private().insert( x );
if( res.second )
ptr.release();
return std::make_pair( iterator( res.first ), res.second );
}
template< class U >
std::pair<iterator,bool> insert( std::auto_ptr<U> x )
{
return insert( x.release() );
}
iterator insert( iterator where, key_type* x ) // strong
{
this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
auto_type ptr( x );
BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
res = this->c_private().insert( where.base(), x );
if( *res == x )
ptr.release();
return iterator( res);
}
template< class U >
iterator insert( iterator where, std::auto_ptr<U> x )
{
return insert( where, x.release() );
}
template< typename InputIterator >
void insert( InputIterator first, InputIterator last ) // basic
{
set_basic_clone_and_insert( first, last );
}
#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
#else
template< class Range >
BOOST_DEDUCED_TYPENAME
boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
insert( const Range& r )
{
insert( boost::begin(r), boost::end(r) );
}
#endif
template< class PtrSetAdapter >
bool transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object,
PtrSetAdapter& from ) // strong
{
return this->single_transfer( object, from );
}
template< class PtrSetAdapter >
size_type
transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first,
BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last,
PtrSetAdapter& from ) // basic
{
return this->single_transfer( first, last, from );
}
#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
#else
template< class PtrSetAdapter, class Range >
BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >,
size_type >::type
transfer( const Range& r, PtrSetAdapter& from ) // basic
{
return transfer( boost::begin(r), boost::end(r), from );
}
#endif
template< class PtrSetAdapter >
size_type transfer( PtrSetAdapter& from ) // basic
{
return transfer( from.begin(), from.end(), from );
}
};
/////////////////////////////////////////////////////////////////////////
// ptr_multiset_adapter
/////////////////////////////////////////////////////////////////////////
template
<
class Key,
class VoidPtrMultiSet,
class CloneAllocator = heap_clone_allocator
>
class ptr_multiset_adapter :
public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator>
{
typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator> base_type;
public: // typedefs
typedef BOOST_DEDUCED_TYPENAME base_type::iterator
iterator;
typedef BOOST_DEDUCED_TYPENAME base_type::size_type
size_type;
typedef Key key_type;
typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
auto_type;
typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::key_compare
key_compare;
typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::allocator_type
allocator_type;
private:
template< typename II >
void set_basic_clone_and_insert( II first, II last ) // basic
{
while( first != last )
{
insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit
++first;
}
}
public:
explicit ptr_multiset_adapter( const key_compare& comp = key_compare(),
const allocator_type& a = allocator_type() )
: base_type( comp, a )
{ }
template< class InputIterator >
ptr_multiset_adapter( InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& a = allocator_type() )
: base_type( comp, a )
{
set_basic_clone_and_insert( first, last );
}
template< class T >
ptr_multiset_adapter( std::auto_ptr<T> r ) : base_type( r )
{ }
template< class T >
void operator=( std::auto_ptr<T> r )
{
base_type::operator=( r );
}
iterator insert( iterator before, key_type* x ) // strong
{
return base_type::insert( before, x );
}
template< class U >
iterator insert( iterator before, std::auto_ptr<U> x )
{
return insert( before, x.release() );
}
iterator insert( key_type* x ) // strong
{
this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" );
auto_type ptr( x );
BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
res = this->c_private().insert( x );
ptr.release();
return iterator( res );
}
template< class U >
iterator insert( std::auto_ptr<U> x )
{
return insert( x.release() );
}
template< typename InputIterator >
void insert( InputIterator first, InputIterator last ) // basic
{
set_basic_clone_and_insert( first, last );
}
#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
#else
template< class Range >
BOOST_DEDUCED_TYPENAME
boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
insert( const Range& r )
{
insert( boost::begin(r), boost::end(r) );
}
#endif
template< class PtrSetAdapter >
void transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object,
PtrSetAdapter& from ) // strong
{
this->multi_transfer( object, from );
}
template< class PtrSetAdapter >
size_type transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first,
BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last,
PtrSetAdapter& from ) // basic
{
return this->multi_transfer( first, last, from );
}
#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
#else
template< class PtrSetAdapter, class Range >
BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, size_type >::type
transfer( const Range& r, PtrSetAdapter& from ) // basic
{
return transfer( boost::begin(r), boost::end(r), from );
}
#endif
template< class PtrSetAdapter >
void transfer( PtrSetAdapter& from ) // basic
{
transfer( from.begin(), from.end(), from );
BOOST_ASSERT( from.empty() );
}
};
} // namespace 'boost'
#endif
| [
"[email protected]@e2c90bd7-ee55-cca0-76d2-bbf4e3699278"
]
| [
[
[
1,
513
]
]
]
|
dced7184cc89cbfa5359b8aa1af04fefc033bb23 | 82d364f8be686abe0201314cdb58012af49e66a5 | /texturecontainer.h | a92c83f140cf32ed5bdf719d3a9825cc56c8d857 | []
| no_license | youkaicountry/ProceduralTextureMaker | b55d7dbcc70da62e3473bbb093394e748ec9aef7 | 499923221edeab1832cfe4e264c713feec93c658 | refs/heads/master | 2021-05-26T18:45:39.204113 | 2011-12-10T04:02:55 | 2011-12-10T04:02:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,950 | h | #ifndef __TEXTURECONTAINER_
#define __TEXTURECONTAINER_
#include <vector.h>
#include "ptexture.h"
#include "lua.hpp"
class TextureContainer
{
public:
TextureContainer();
~TextureContainer();
//reading operations
int getWorkingA8R8G8B8(int num, int x, int y);
int getFinalA8R8G8B8(int num, int x, int y);
int getFinalNumber(); //returns number of elements in Final
int getWorkingNumber();
int getWorkingXSize(int num);
int getFinalXSize(int num);
int getWorkingYSize(int num);
int getFinalYSize(int num);
int getWorkingTextureMemSize(int num);
int getFinalTextureMemSize(int num);
int getTextureContainerMemSize();
//utility operations
int addNewWorkingTexture(int xsize, int ysize);
int makeFinal(int num);
void copyTexture(int num1, int num2);
void clearTextureContainer();
//loading operations
void loadLua(char* filename);
void loadLuaLib(const char *dir, lua_State *L);
//edit operations
void setPixel(int num, int x, int y, int red, int green, int blue);
void clearTexture(int num, int red, int green, int blue);
void setHStrip(int num, int xstart, int length, int y, int red, int green, int blue);
void setVStrip(int num, int ystart, int length, int x, int red, int green, int blue);
void applyTransform(int num, float m00, float m01, float m02, float m10, float m11, float m12, int red, int green, int blue);
void applyScale(int num, float xscale, float yscale, int red, int green, int blue);
void applyRotationAbout(int num, float theta, float ox, float oy, int red, int green, int blue);
void makeHeightMap(int num);
void tint(int num, int red, int green, int blue);
void quantize(int num, int redvalues, int greenvalues, int bluevalues);
void fill(int num, int x, int y, int red, int green, int blue);
void fill2(int num, int x, int y, int red, int green, int blue);
void filledCircle(int num, int x, int y, int radius, int red, int green, int blue);
void filledRect(int num, int x1, int y1, int x2, int y2, int red, int green, int blue);
void apply3Convolution(int num, float* matrix, float divide, float bias, int passes, bool red, bool green, bool blue);
void noise(int num, int seed, int lored, int logreen, int loblue, int hired, int higreen, int hiblue);
void fractionalNoise(int num, int seed, int lored, int logreen, int loblue, int hired, int higreen, int hiblue);
void setWithProbability(int num, int seed, float p, int red, int green, int blue);
void closestColour(int num, float var, int red, int green, int blue);
void perlinNoise(int num, float px, float py, float length, float persist, int octaves, int seed);
void light(int num, int bump, float bumpheight, float lightx, float lighty, float lightz, float ambientbright, float lightbright, float falloffkmult, float falloff, bool shadows);
void add(int num1, int num2, int type);
void line(int num, int x0, int y0, int x1, int y1, int red, int green, int blue);
void rect(int num, int x1, int y1, int x2, int y2, int red, int green, int blue);
void circle(int num, int x0, int y0, int radius, int red, int green, int blue);
void colourReplace(int num, float var, int redrep, int greenrep, int bluerep, int red, int green, int blue);
void overlay(int num1, int num2, float var, int tred, int tgreen, int tblue);
//void pixelFit(int num, float probmult, int seedstart, int seedend, int red, int green, int blue);
void directionLight(int num, int bump, float bumpheight, float lightx, float lighty, float lightz, float ambientbright, float lightbright, bool shadows);
void clampBelow(int num, float belowvalue, float tored, float togreen, float toblue);
void clampAbove(int num, float abovevalue, float tored, float togreen, float toblue);
void brightnessMult(int num, float scale);
float getRed(int num, int x, int y);
float getGreen(int num, int x, int y);
float getBlue(int num, int x, int y);
void makeNormalMap(int num, float bumpheight);
void lightNormal(int num, int normal, float lightx, float lighty, float lightz, float ambientbright, float lightbright, float falloffkmult, float falloff, bool shadows);
void directionLightNormal(int num, int normal, float lx, float ly, float lz, float ambientbright, float lightbright, bool shadows);
//exposed lua functions
static int l_setPixel( lua_State* luaVM );
static int l_clearTexture( lua_State* luaVM );
static int l_newTexture( lua_State* luaVM );
static int l_makeFinal( lua_State* luaVM );
static int l_setHStrip( lua_State* luaVM );
static int l_setVStrip( lua_State* luaVM );
static int l_applyTransform( lua_State* luaVM );
static int l_applyScale( lua_State* luaVM );
static int l_applyRotationAbout( lua_State* luaVM );
static int l_makeHeightMap( lua_State* luaVM );
static int l_tint( lua_State* luaVM );
static int l_quantize( lua_State* luaVM );
static int l_copyTexture( lua_State* luaVM );
static int l_fill( lua_State* luaVM );
static int l_filledCircle( lua_State* luaVM );
static int l_filledRect( lua_State* luaVM );
static int l_applyBlur( lua_State* luaVM );
static int l_applyDefocus( lua_State* luaVM );
static int l_applyEdgeDetect( lua_State* luaVM );
static int l_applyGaussianBlur( lua_State* luaVM );
static int l_noise( lua_State* luaVM );
static int l_fractionalNoise( lua_State* luaVM );
static int l_setWithProbability(lua_State *luaVM);
static int l_closestColour(lua_State *luaVM);
static int l_perlinNoise(lua_State *luaVM);
static int l_light(lua_State *luaVM);
static int l_add(lua_State *luaVM);
static int l_line(lua_State* luaVM);
static int l_rect(lua_State* luaVM);
static int l_circle(lua_State* luaVM);
static int l_colourReplace(lua_State* luaVM);
static int l_overlay(lua_State* luaVM);
static int l_directionLight(lua_State *luaVM);
static int l_applyEmboss(lua_State* luaVM);
static int l_applyEdgeDetectLaplace(lua_State* luaVM);
static int l_clampBelow(lua_State* luaVM);
static int l_clampAbove(lua_State* luaVM);
static int l_brightnessMult(lua_State* luaVM);
static int l_getRed(lua_State* luaVM);
static int l_getGreen(lua_State* luaVM);
static int l_getBlue(lua_State* luaVM);
//to document:
//static int l_pixelFit(lua_State* luaVM);
static int l_makeNormalMap(lua_State* luaVM);
static int l_directionLightNormal(lua_State *luaVM);
static int l_lightNormal(lua_State *luaVM);
vector<PTexture*> workingtextures;
vector<PTexture*> finaltextures;
private:
void recurseFill(int num, int x, int y, int fred, int fgreen, int fblue, int tred, int tgreen, int tblue);
// Matrices in order: m00 m01 m02 m10 m11 m12
};
#endif
| [
"[email protected]"
]
| [
[
[
1,
143
]
]
]
|
1f7e72b7c699c17855ab9d605faef5ddd90820cd | 138a353006eb1376668037fcdfbafc05450aa413 | /source/ogre/OgreNewt/boost/type_traits/detail/bool_trait_undef.hpp | 9c90729f553a40d956db3d5aca46e5dcf4f4ac16 | []
| no_license | sonicma7/choreopower | 107ed0a5f2eb5fa9e47378702469b77554e44746 | 1480a8f9512531665695b46dcfdde3f689888053 | refs/heads/master | 2020-05-16T20:53:11.590126 | 2009-11-18T03:10:12 | 2009-11-18T03:10:12 | 32,246,184 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,050 | hpp |
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
// Copyright Aleksey Gurtovoy 2002-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// $Source: /cvsroot/ogre/ogreaddons/ogrenewt/OgreNewt_Main/inc/boost/type_traits/detail/bool_trait_undef.hpp,v $
// $Date: 2006/04/17 23:50:27 $
// $Revision: 1.1 $
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
| [
"Sonicma7@0822fb10-d3c0-11de-a505-35228575a32e"
]
| [
[
[
1,
27
]
]
]
|
3428a6c215b6eb6a67c118691aa6668ffed68d5a | 8a3fce9fb893696b8e408703b62fa452feec65c5 | /内存池/MemPool/MemDef.h | 7de4eeea6ac31eaf4b1d9c3a8431fcc5612fc1b2 | []
| no_license | win18216001/tpgame | bb4e8b1a2f19b92ecce14a7477ce30a470faecda | d877dd51a924f1d628959c5ab638c34a671b39b2 | refs/heads/master | 2021-04-12T04:51:47.882699 | 2011-03-08T10:04:55 | 2011-03-08T10:04:55 | 42,728,291 | 0 | 2 | null | null | null | null | GB18030 | C++ | false | false | 3,403 | h | /**
* @brief 关于内存池的一些定义
* @date 2010.05.01
* @modify 2010.10.10
*/
#pragma once
#define CHUNKSIZE 20*(1<<20) // 20M
#define MAXALLOCSIZE 3*CHUNKSIZE // 60M
#define MaxSize ((1<<30)-1) // 最大范围
#define LvlRange 512
#define SizeRange 5120 // 预分配为小于等于5120，超过则通过预分配策略
#define LONGSIZE sizeof(long)
const long Range[ ] = { 16,32,64,128,256,512,1024,2048,3072,4096,5120 };
#define DEF_IMPL_FACTORY_FUN( classname, baseclassname) \
static baseclassname* create();\
static void destory(baseclassname*p)
#define DEL_IMPL_FACTORY_FUN( classname, baseclassname) \
baseclassname* classname::create(){ return new classname(); } \
void classname::destory(baseclassname*p) { if(p){ delete p ; p=next;} }
#define FAC_IMPL_FACTORY_FUN( classname, baseclassname) \
static baseclassname* create(){ return new classname(); } \
static void destory(baseclassname*p) { if(p){ delete p ; p=next;} }
#define LP_SNMP_0(pname)
#define LP_SNMP_1(pname) pname##1
#define LP_SNMP_2(pname) LP_SNMP_1(pname), pname##2
#define LP_SNMP_3(pname) LP_SNMP_2(pname), pname##3
#define LP_SNMP_4(pname) LP_SNMP_3(pname), pname##4
#define LP_SNMP_5(pname) LP_SNMP_4(pname), pname##5
#define LP_SNMP_6(pname) LP_SNMP_5(pname), pname##6
#define LP_SNMP_7(pname) LP_SNMP_6(pname), pname##7
#define LP_SNMP_8(pname) LP_SNMP_7(pname), pname##8
#define LP_SNMP_9(pname) LP_SNMP_8(pname), pname##9
#define LP_SNMP_10(pname) LP_SNMP_9(pname), pname##10
#define DP_MTMP_0(type,name)
#define DP_MTMP_1(type,name) type##1 name##1
#define DP_MTMP_2(type,name) DP_MTMP_1(type,name), type##2 name##2
#define DP_MTMP_3(type,name) DP_MTMP_2(type,name), type##3 name##3
#define DP_MTMP_4(type,name) DP_MTMP_3(type,name), type##4 name##4
#define DP_MTMP_5(type,name) DP_MTMP_4(type,name), type##5 name##5
#define DP_MTMP_6(type,name) DP_MTMP_5(type,name), type##6 name##6
#define DP_MTMP_7(type,name) DP_MTMP_6(type,name), type##7 name##7
#define DP_MTMP_8(type,name) DP_MTMP_7(type,name), type##8 name##8
#define DP_MTMP_9(type,name) DP_MTMP_8(type,name), type##9 name##9
#define DP_MTMP_10(type,name) DP_MTMP_9(type,name), type##10 name##10
#define DP_STMP_0(type,pname)
#define DP_STMP_1(type,pname) type pname##1
#define DP_STMP_2(type,pname) DP_STMP_1(type,pname), type pname##2
#define DP_STMP_3(type,pname) DP_STMP_2(type,pname), type pname##3
#define DP_STMP_4(type,pname) DP_STMP_3(type,pname), type pname##4
#define DP_STMP_5(type,pname) DP_STMP_4(type,pname), type pname##5
#define DP_STMP_6(type,pname) DP_STMP_5(type,pname), type pname##6
#define DP_STMP_7(type,pname) DP_STMP_6(type,pname), type pname##7
#define DP_STMP_8(type,pname) DP_STMP_7(type,pname), type pname##8
#define DP_STMP_9(type,pname) DP_STMP_8(type,pname), type pname##9
#define DP_STMP_10(type,pname) DP_STMP_9(type,pname), type pname##10
template <class T>
inline T * CALL_CON( T * ptMem )
{
T * pt = new(ptMem)T;
return pt;
}
#define DEFINE_CALL_CON( paramcount ) template <class T, DP_STMP_##paramcount( typename, tp ) >\
inline T * Alloc(DP_MTMP_##paramcount( tp, p ) ){\
unsigned long lSize = sizeof(T);\
void* ptMem = Alloc(lSize);\
if( !ptMem) return NULL; \
T * pt = new(ptMem)T( LP_SNMP_##paramcount( p ) );\
return pt;\
} | [
"[email protected]"
]
| [
[
[
1,
82
]
]
]
|
61e1eca04db92343331c95cb85cdf30f66769b0b | f54dca64cbc02f9c0ebdfe57333fe4f63bed7fa1 | /libneural/UnipolarFunction.cpp | 1c59dea9da1e1300517caaf2e9f8c17c62857cde | []
| no_license | tom3q/cowiek-maupa | f67b590e500d417e16277a979d063d0969808e3e | 6ce9330ce3252f0ed6961ec09dd9a0dcb83e4c18 | refs/heads/master | 2019-01-02T08:48:26.605680 | 2011-12-11T18:08:47 | 2011-12-11T18:08:47 | 32,119,555 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 447 | cpp | #include <cmath>
#include "UnipolarFunction.h"
UnipolarFunction::UnipolarFunction(float beta)
: beta_(beta) {
}
float UnipolarFunction::calcValue(float arg) {
float val = (float) 1.0/(1.0+exp(-beta_*arg));
return val;
}
/* TODO:
Calculate derivative by hand and update the formula.
*/
float UnipolarFunction::calcDerivative(float arg) {
float tmp = value(arg);
float val = (float) beta_*tmp*(1.0-tmp);
return val;
}
| [
"[email protected]"
]
| [
[
[
1,
20
]
]
]
|
b2ea626a896d89655847423735853ae2f105403d | 971b000b9e6c4bf91d28f3723923a678520f5bcf | /BookMarkWidget/TranslateModel.h | 2acc2e9624da892d3c7764fa91c2dd8bf50a44a2 | []
| no_license | google-code-export/fop-miniscribus | 14ce53d21893ce1821386a94d42485ee0465121f | 966a9ca7097268c18e690aa0ea4b24b308475af9 | refs/heads/master | 2020-12-24T17:08:51.551987 | 2011-09-02T07:55:05 | 2011-09-02T07:55:05 | 32,133,292 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,957 | h | #ifndef TRANSLATEMODEL_H
#define TRANSLATEMODEL_H
#include <stdio.h>
#include <iostream>
#include <QtCore>
#include <QtGui>
#include <QDebug>
#include <QtCore>
#include <QtGui>
#include <QDebug>
#include <QDomElement>
#include <QDomDocument>
#include <QDomNode>
QIcon createBookColorIcon( QColor color );
QList<QStandardItem*> childList( QStandardItem *qi );
QMap<QStandardItem*,QModelIndexList> childListmap( QStandardItem *qi );
namespace ApacheFop
{
typedef enum
{
Mfull,
Mommit,
Mclean
} ModusReadModel;
class ModelDomRead : public QObject
{
Q_OBJECT
public:
ModelDomRead( QStandardItemModel *mod , ModusReadModel e = Mfull, const QString xlinktxt = QString() );
inline QDomDocument *Domdocument() { return dom; }
protected:
void parserChild( QModelIndex index , QDomElement e );
void read();
void appendOnTreeDom();
QDomElement linkPdf( QModelIndex first , QModelIndex second );
QStandardItemModel *model;
ModusReadModel modus;
QString linktxt;
QDomDocument *dom;
QDomElement root;
QDomElement appender;
};
}
class BooksDelegate : public QItemDelegate
{
Q_OBJECT
public:
BooksDelegate( QObject *parent , QStringList link );
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;
QWidget *createEditor(QWidget *parent0, const QStyleOptionViewItem &option, const QModelIndex &index) const;
void setEditorData(QWidget *editor, const QModelIndex &index);
void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const ;
QSize sizeHint( const QStyleOptionViewItem &option, const QModelIndex &index ) const;
signals:
public slots:
private:
QStringList xi;
};
#endif // TRANSLATEMODEL_H
| [
"ppkciz@9af58faf-7e3e-0410-b956-55d145112073"
]
| [
[
[
1,
91
]
]
]
|
0d3837f813f4765ecc6a3f35ffb2402fd27a4fe7 | 7f72fc855742261daf566d90e5280e10ca8033cf | /branches/full-calibration/ground/src/plugins/rawhid/rawhidplugin.cpp | c93794826e9d8ab35b3607704c660168ab9fae86 | []
| no_license | caichunyang2007/my_OpenPilot_mods | 8e91f061dc209a38c9049bf6a1c80dfccb26cce4 | 0ca472f4da7da7d5f53aa688f632b1f5c6102671 | refs/heads/master | 2023-06-06T03:17:37.587838 | 2011-02-28T10:25:56 | 2011-02-28T10:25:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,442 | cpp | /**
******************************************************************************
*
* @file rawhidplugin.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup RawHIDPlugin Raw HID Plugin
* @{
* @brief Impliments a HID USB connection to the flight hardware as a QIODevice
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "rawhidplugin.h"
#include "rawhid.h"
#include <extensionsystem/pluginmanager.h>
#include <QtCore/QtPlugin>
#include <QtCore/QMutexLocker>
#include "pjrc_rawhid.h"
#include "rawhid_const.h"
RawHIDEnumerationThread::RawHIDEnumerationThread(RawHIDConnection *rawhid)
: m_rawhid(rawhid),
m_running(true)
{
}
RawHIDEnumerationThread::~RawHIDEnumerationThread()
{
m_running = false;
//wait for the thread to terminate
if(wait(1000) == false)
qDebug() << "Cannot terminate RawHIDEnumerationThread";
}
void RawHIDEnumerationThread::run()
{
QStringList devices = m_rawhid->availableDevices();
while(m_running)
{
if(!m_rawhid->deviceOpened())
{
QStringList newDev = m_rawhid->availableDevices();
if(devices != newDev)
{
devices = newDev;
emit enumerationChanged();
}
}
msleep(500); //update available devices twice per second (doesn't need more)
}
}
RawHIDConnection::RawHIDConnection()
: m_enumerateThread(this)
{
//added by andrew
RawHidHandle = NULL;
QObject::connect(&m_enumerateThread, SIGNAL(enumerationChanged()),
this, SLOT(onEnumerationChanged()));
m_enumerateThread.start();
}
RawHIDConnection::~RawHIDConnection()
{}
void RawHIDConnection::onEnumerationChanged()
{
emit availableDevChanged(this);
}
QStringList RawHIDConnection::availableDevices()
{
QMutexLocker locker(&m_enumMutex);
QStringList devices;
pjrc_rawhid dev;
//open all device we can
int opened = dev.open(MAX_DEVICES, VID, PID, USAGE_PAGE, USAGE);
//for each devices found, get serial number and close it back
for(int i=0; i<opened; i++)
{
devices.append(dev.getserial(i));
dev.close(i);
}
return devices;
}
QIODevice *RawHIDConnection::openDevice(const QString &deviceName)
{
//added by andrew
if (RawHidHandle){
closeDevice(deviceName);
}
//end added by andrew
m_deviceOpened = true;
//return new RawHID(deviceName);
RawHidHandle = new RawHID(deviceName);
return RawHidHandle;
}
void RawHIDConnection::closeDevice(const QString &deviceName)
{
//added by andrew...
if (RawHidHandle){
RawHidHandle->close();
delete(RawHidHandle);
RawHidHandle=NULL;
}
//end added by andrew
m_deviceOpened = false;
}
QString RawHIDConnection::connectionName()
{
return QString("Raw HID USB");
}
QString RawHIDConnection::shortName()
{
return QString("USB");
}
//usb hid test thread
//temporary...
RawHIDTestThread::RawHIDTestThread()
{
Core::ConnectionManager *cm = Core::ICore::instance()->connectionManager();
QObject::connect(cm, SIGNAL(deviceConnected(QIODevice *)),
this, SLOT(onDeviceConnect(QIODevice *)));
QObject::connect(cm, SIGNAL(deviceDisconnected()),
this, SLOT(onDeviceDisconnect()));
}
void RawHIDTestThread::onDeviceConnect(QIODevice *dev)
{
this->dev = dev;
dev->open(QIODevice::ReadWrite);
QObject::connect(dev, SIGNAL(readyRead()),
this, SLOT(onReadyRead()));
QObject::connect(dev, SIGNAL(bytesWritten(qint64)),
this, SLOT(onBytesWritten(qint64)));
dev->write("Hello raw hid device\n");
}
void RawHIDTestThread::onDeviceDisconnect()
{
dev->close();
}
void RawHIDTestThread::onReadyRead()
{
qDebug() << "Rx:" << dev->readLine(32);
}
void RawHIDTestThread::onBytesWritten(qint64 sz)
{
qDebug() << "Sent " << sz << " bytes";
}
RawHIDPlugin::RawHIDPlugin()
{
}
RawHIDPlugin::~RawHIDPlugin()
{
}
void RawHIDPlugin::extensionsInitialized()
{
addAutoReleasedObject(new RawHIDConnection);
//temp for test
//addAutoReleasedObject(new RawHIDTestThread);
}
bool RawHIDPlugin::initialize(const QStringList & arguments, QString * errorString)
{
Q_UNUSED(arguments);
Q_UNUSED(errorString);
return true;
}
Q_EXPORT_PLUGIN(RawHIDPlugin)
| [
"jonathan@ebee16cc-31ac-478f-84a7-5cbb03baadba"
]
| [
[
[
1,
219
]
]
]
|
95d3c8be8879c7a1f5b41141fa7738006ad3a281 | fad6f9883d4ad2686c196dc532a9ecb9199500ee | /NXP-LPC/CommTest/CommTest/Packet.cpp | 98125d017053121746aa7bc548a827012755ee08 | []
| no_license | aquarius20th/nxp-lpc | fe83d6a140d361a1737d950ff728c6ea9a16a1dd | 4abfb804daf0ac9c59bd90d879256e7a3c1b2f30 | refs/heads/master | 2021-01-10T13:54:40.237682 | 2009-12-22T14:54:59 | 2009-12-22T14:54:59 | 48,420,260 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 8,212 | cpp | /****************************************Copyright (c)**************************************************
**
**
**
**
**
**
**--------------文件信息--------------------------------------------------------------------------------
**文 件 名:
**创 建 人:
**最后修改日期:
**描 述: 报文
**
**--------------历史版本信息----------------------------------------------------------------------------
** 创建人:
** 版 本:
** 日 期:
** 描 述:
**
**--------------当前版本修订------------------------------------------------------------------------------
** 修改人:
** 日 期:
** 描 述:
**
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
#include "stdafx.h"
#include "Packet.h"
#include <algorithm>
#include "boost/memory.hpp"
boost::auto_alloc g_packet_alloc;
CPacket::CPacket()
{
m_pPacketData = NULL;
m_nLen = 0;;
m_nId = 0;
}
CPacket::~CPacket()
{
}
CPacket::CPacket( unsigned char *pData,unsigned int nLen )
{
m_pPacketData = NULL;
m_nLen = 0;;
m_nId = 0;
ASSERT( pData );
ASSERT(nLen >0 && nLen <= MAX_PACKET_LEN);
if (pData == NULL || nLen == 0 || nLen > MAX_PACKET_LEN)
return;
GetLocalTime(&m_stBuild);
m_pPacketData = BOOST_MEMORY_ALLOC_ARRAY(g_packet_alloc, unsigned char, nLen);
m_nLen = nLen;
memcpy_s(m_pPacketData,m_nLen,pData,nLen);
}
void CPacket::SetPacket( unsigned char *pData,unsigned int nLen)
{
ASSERT( pData );
ASSERT(nLen >0 && nLen <= MAX_PACKET_LEN);
if (pData == NULL || nLen == 0 || nLen > MAX_PACKET_LEN)
return;
GetLocalTime(&m_stBuild);
m_pPacketData = BOOST_MEMORY_ALLOC_ARRAY(g_packet_alloc, unsigned char, nLen);
m_nLen = nLen;
memcpy_s(m_pPacketData,m_nLen,pData,nLen);
}
void CPacket::GetPacket ( CPacket &Dest)
{
Dest.m_pPacketData = BOOST_MEMORY_ALLOC_ARRAY(g_packet_alloc, unsigned char, m_nLen);
Dest.m_nLen = m_nLen;
memcpy_s(Dest.m_pPacketData,m_nLen,m_pPacketData,m_nLen);
}
CPacket CPacket::operator= (const CPacket &Src)
{
// m_nMsgType = Src.m_nMsgType; // 消息类型
m_pPacketData = BOOST_MEMORY_ALLOC_ARRAY(g_packet_alloc, unsigned char,Src.m_nLen);
m_nLen = Src.m_nLen;
memcpy_s(m_pPacketData,m_nLen,Src.m_pPacketData,m_nLen);
return *this;
}
unsigned int CPacket::GetPacket(CString &szPacket)
{
if (m_nLen >0 && m_nLen <MAX_PACKET_LEN)
{
// char szMsgB[512] = {0};
// sprintf(szMsgB,"%02X ",pMsg->pData[0]);
unsigned int nLen = m_nLen;
unsigned int i = 1;
TCHAR temp[10] = {0};
// _stprintf_s(temp,"%02X ",m_pPacketData[0]);
szPacket.Format(_T("%02X "),m_pPacketData[0]);
if (nLen >= 32)
{
nLen = 32;
for (i = 1; i<nLen; i++)
{
_stprintf_s(temp,6,_T("%02X "), m_pPacketData[i] );
szPacket += temp;
}
szPacket.Delete(szPacket.GetLength()-1);
szPacket += _T("...");
}
else
{
if (nLen>1)
{
for (i = 1; i<nLen; i++)
{
_stprintf_s(temp,6,_T("%02X "), m_pPacketData[i] );
szPacket += temp;
}
}
szPacket.Delete(szPacket.GetLength()-1);
}
}
return m_nLen;
}
unsigned char *CPacket::GetPacket(unsigned int &nLen)
{
nLen = m_nLen;
return m_pPacketData;
}
CPacketContainer::CPacketContainer()
{
m_nCurId = 0;
}
CPacketContainer::~CPacketContainer()
{
FreeMem( );
}
/*********************************************************************************************************
** 函数名称: PutData
** 函数名称: CPacketContainer::PutData
**
** 功能描述：
**
** 输 入: unsigned char * pData
** 输 入: unsigned int nLen
**
** 输 出: void
**
** 全局变量:
** 调用模块: 无
**
** 作 者: LiJin
** 日 期: 2009年10月15日
** 备 注:
**-------------------------------------------------------------------------------------------------------
** 修改人:
** 日 期:
** 备 注:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
void CPacketContainer::PutData( unsigned char *pData,unsigned int nLen )
{
ASSERT( pData );
ASSERT(nLen >0 && nLen <= MAX_PACKET_LEN);
if (pData == NULL || nLen == 0 || nLen > MAX_PACKET_LEN)
return;
CSingleLock lock( & m_Mutex);
if (m_arrPingBuf.size() >= MAX_PACKET_CNT )
{
lock.Unlock();
return;
}
CPacket *pPacket = BOOST_NEW(g_packet_alloc,CPacket);
ASSERT(pPacket);
if (pPacket)
{
pPacket->SetPacket(pData,nLen);
pPacket->m_nId = ++m_nCurId;
m_arrPingBuf.push_back(pPacket);
}
lock.Unlock();
return;
}
/*********************************************************************************************************
** 函数名称: GetData
** 函数名称: CPacketContainer::GetData
**
** 功能描述： 从PING队列中获取数据，并送到pong队列中
**
** 输 入: CPacket * * ppPacket
**
** 输 出: bool
**
** 全局变量:
** 调用模块: 无
**
** 作 者: LiJin
** 日 期: 2009年10月15日
** 备 注:
**-------------------------------------------------------------------------------------------------------
** 修改人:
** 日 期:
** 备 注:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
bool CPacketContainer::GetData( CPacket **ppPacket )
{
if (ppPacket == NULL)
return false;
CSingleLock lock( & m_Mutex);
if (m_arrPingBuf.empty() )
{
lock.Unlock();
return false;
}
*ppPacket = m_arrPingBuf.front();
m_arrPingBuf.pop_front();
m_arrPongBuf.push_back(*ppPacket);
return true;
}
bool CPacketContainer::FindData(unsigned int nId,CPacket &packet)
{
if (nId == 0 || nId > m_nCurId)
return false;
CSingleLock lock( & m_Mutex);
std::deque<CPacket *>::iterator iter = m_arrPongBuf.begin();
for (; iter != m_arrPongBuf.end() ;++iter)
{
if ((*iter)->m_nId == nId)
{
packet = *(*iter);
lock.Unlock();
return true;
}
}
lock.Unlock();
// iter = std::find(m_arrPongBuf.begin(), m_arrPongBuf.end(),pPacket );
// if (iter != m_arrPongBuf.end())
// {
// ASSERT( (*iter)->m_nId == pPacket->m_nId );
// m_arrPongBuf.erase( iter);
// return true;
// }
// CSingleLock lock( & m_Mutex);
return false;
}
/*********************************************************************************************************
** 函数名称: RemoveData
** 函数名称: CPacketContainer::RemoveData
**
** 功能描述：
**
** 输 入: CPacket * pPacket
**
** 输 出: bool
**
** 全局变量:
** 调用模块: 由视图来调用
**
** 作 者: LiJin
** 日 期: 2009年10月15日
** 备 注:
**-------------------------------------------------------------------------------------------------------
** 修改人:
** 日 期:
** 备 注:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
bool CPacketContainer::RemoveData( CPacket *pPacket )
{
ASSERT(pPacket);
if (pPacket == NULL)
return false;
std::deque<CPacket *>::iterator iter;
iter = std::find(m_arrPongBuf.begin(), m_arrPongBuf.end(),pPacket );
if (iter != m_arrPongBuf.end())
{
ASSERT( (*iter)->m_nId == pPacket->m_nId );
m_arrPongBuf.erase( iter);
return true;
}
// CSingleLock lock( & m_Mutex);
return false;
}
void CPacketContainer::FreeMem( )
{
m_arrPongBuf.clear();
m_arrPingBuf.clear();
}
| [
"lijin.unix@13de9a6c-71d3-11de-b374-81e7cb8b6ca2"
]
| [
[
[
1,
316
]
]
]
|
d7064b773dc02c65ca57414a063545298bd3a203 | 22438bd0a316b62e88380796f0a8620c4d129f50 | /applications/rythmbuilder/track_builder.cpp | 8f835d24bca790667f684046d0fd6cd69db0088e | [
"BSL-1.0"
]
| permissive | DannyHavenith/NAPL | 1578f5e09f1b825f776bea9575f76518a84588f4 | 5db7bf823bdc10587746d691cb8d94031115b037 | refs/heads/master | 2021-01-20T02:17:01.186461 | 2010-11-26T22:26:25 | 2010-11-26T22:26:25 | 1,856,141 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 7,682 | cpp | #include "stdafx.h"
#include <string>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include "track_builder.h"
#include "instrument.h"
using namespace std;
namespace
{
block_producer *Concatenate( block_producer *left, block_producer *right)
{
paste_mutator *paster = new paste_mutator();
paster->LinkTo( left, 0);
paster->LinkTo( right, 1);
return paster;
}
block_producer *Add( block_producer *left, block_producer *right)
{
stream_header h;
left->GetStreamHeader( h);
sample_object_factory *factory_ptr = factory_factory::GetSampleFactory( h);
binary_block_processor *adder = factory_ptr->GetAdder();
delete factory_ptr;
adder->LinkTo( left, right);
return adder;
}
//
// join all samples in a range into a single sequence.
// Doesn't really need RAIterators, but is a lot slower otherwise.
//
template< class RAIterator, class Op>
block_producer *join_sounds( RAIterator begin, const RAIterator &end, Op op)
{
size_t dist = std::distance( begin, end);
if (dist == 0)
{
return 0;
}
if (dist == 1)
{
return *begin;
}
return op(
join_sounds( begin, begin+dist/2, op),
join_sounds( begin+dist/2, end, op)
);
}
// spread the sound in the iterator range over the stereo space (so that the first one is
// on the utter left channel and the last on the utter right.
//
template<typename iterator_t>
void spread_bars( iterator_t begin, iterator_t end)
{
if (begin == end) return;
iterator_t current = begin;
size_t count = std::distance( begin, end);
stream_header h;
(*begin)->GetStreamHeader( h);
sample_object_factory *factory_ptr = factory_factory::GetSampleFactory( h);
if (count > 1)
{
short step = 2 * (32767 / static_cast<short>(count-1));
short pan_position = -32768;
while (current != end)
{
block_producer *prod_ptr = * current;
block_mutator *panner = factory_ptr->GetPan( pan_position);
panner->LinkTo( prod_ptr);
*current = panner;
pan_position += step;
++current;
}
current = begin;
}
}
}
track_builder::track_builder( instrument_factory &instruments_, const std::string &default_name)
: note_seconds(.25),
instruments( instruments_),
last_measure_index(0),
current_note_seconds( 0.0),
track_name( default_name)
{
};
void track_builder::start_track( const string &rythm, const string §ion, int bpm, const string &comment)
{
note_seconds = 60.0/bpm;
track_name = rythm.empty()?string("track"): rythm;
section_name = section;
}
void track_builder::cleanup()
{
last_measure_index = 0;
push_note();
if (!current_bar.empty())
{
track.push_back( current_bar);
current_bar.clear();
}
if (!track.empty())
{
emit_track();
track.clear();
}
}
void write_file( const std::string &filename, block_producer *p)
{
block_sink *file_writer = filefactory::GetBlockSink( filename.c_str());
file_writer->LinkTo( p);
//
// write to file...
file_writer->Start();
}
void track_builder::emit_track()
{
typedef std::vector< block_producer *> temp_sound_vec;
temp_sound_vec bars;
BOOST_FOREACH( bar_vector &bar, track)
{
bars.push_back(
join_sounds( bar.begin(), bar.end(), Concatenate)
);
}
// spread over stereo space.
spread_bars( bars.begin(), bars.end());
// add all bars
block_producer *result =
join_sounds( bars.begin(), bars.end(), Add);
std::string filename = track_name;
if (!section_name.empty())
{
filename += "_" + section_name;
}
filename += ".wav";
block_sink *file_writer = filefactory::GetBlockSink( filename.c_str());
if (!file_writer)
{
throw std::runtime_error( "could not open file " + filename + " for writing, is it open in another application?");
}
file_writer->LinkTo( result);
//
// write to file...
file_writer->Start();
}
//
// start a new bar.
// precondition: current_bar.empty() == true
//
void track_builder::start_bar( const string &bar_name, const string &instrument_name)
{
string instrument = instrument_name;
if (instrument.empty())
{
instrument = bar_name;
}
if (instrument.empty())
{
instrument = "djembe1";
}
current_instrument = instruments.get_instrument( instrument);
}
void track_builder::start_nlet( int numerator, int denominator)
{
tempo.push( note_seconds);
if (denominator == 0) denominator = 1;
if (numerator == 0) numerator = 1;
//
// this may look counter-intuitive: if we encounter an nlet of the
// form n/m(...), for example 3/2(...), this means that the nlet itself takes 2 beats
// for every three notes encountered. So note duration becomes, in this case 2/3 of the original
// duration.
//
// a typical triplet would thus become 3/2(...).
//
note_seconds = (note_seconds * denominator) / numerator;
}
void track_builder::new_measure()
{
push_note();
last_measure_index = (int)current_bar.size();
}
void track_builder::repeat( int count)
{
if (count == 0) return;
push_note();
//
// create a copy of the notes to repeat, because we're going to invalidate all iterators by
// performing a copy into a vector.
//
bar_vector::iterator begin =
(last_measure_index != current_bar.size()) ?
(current_bar.begin() + last_measure_index)
: current_bar.begin();
bar_vector fragment( begin, current_bar.end());
//
// now copy count-1 times
//
while (--count)
{
std::copy( fragment.begin(), fragment.end(),
std::back_inserter( current_bar));
}
new_measure();
}
void track_builder::push_note()
{
if (current_note_seconds > .001)
{
//
// this will ask for a note with an empty name
// (current_note_name == "")
// if there is only silence to push
// (for instance when the bar starts with silence)
current_bar.push_back(
current_instrument->get_note(
current_note_name,
current_note_seconds
)
);
}
current_note_name.clear();
current_note_seconds = 0.0;
}
void track_builder::note( const string ¬e)
{
push_note();
current_note_name = note;
current_note_seconds = note_seconds;
}
void track_builder::pause()
{
current_note_seconds += note_seconds;
}
void track_builder::end_nlet()
{
note_seconds = tempo.top();
tempo.pop();
}
void track_builder::end_track()
{
cleanup();
}
void track_builder::end_bar()
{
push_note();
if (!current_bar.empty())
{
track.push_back( current_bar);
current_bar.clear();
last_measure_index = 0;
}
}
| [
"[email protected]"
]
| [
[
[
1,
331
]
]
]
|
324c27871b6010a8783a1fabc25dfec11d9df81a | 3fb88529ec63d45506d159bee677695698e690ee | /widgetconfigrrd.cpp | dbc4f604e9cc39680eca2ead477fdcb95750f807 | []
| no_license | cristifalcas/qt-rrd | 588f1d51555b146590dd84d969052123700a5217 | 249c1cb702020bcfe79465381053430e9e6f4e80 | refs/heads/master | 2021-01-14T13:20:53.669503 | 2009-11-12T22:16:08 | 2009-11-12T22:16:08 | 34,001,301 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,916 | cpp | #include "widgetconfigrrd.h"
#include <QVBoxLayout>
#include <QFormLayout>
#include <QGroupBox>
QString strTooltip[] =
{
"Defines how many of the primary data points are used to build a\n"
"consolidated data point. For simplicity, we will use in this program\n"
"as at least quadruple of the max interval defined (from the sections\n"
"in the configuration files. So be carefull how you combine them).",
"The xfiles factor defines what part of a consolidation \n"
"interval may be made up from *UNKNOWN* data while the \n"
"consolidated value is still regarded as known. It is given \n"
"as the ratio of allowed *UNKNOWN* PDPs to the number of\n"
"PDPs in the interval. Thus, it ranges from 0 to 1 (exclusive).",
"Consolidation function. You want average"
};
WidgetConfigRRD::WidgetConfigRRD()
{
MY_DEBUG;
spinboxStep = new QSpinBox;
doublespinboxXFactor = new QDoubleSpinBox;
comboboxConsolidationFunction = new QComboBox;
signalMapper = new QSignalMapper;
inforrd = RRDInfo::instance();
}
void WidgetConfigRRD::draw()
{
MY_DEBUG;
init();
connects();
layout();
}
void WidgetConfigRRD::init()
{
MY_DEBUG;
spinboxStep->setMinimum(1);
spinboxStep->setMaximum(2000);
spinboxStep->setSuffix(" sec");
spinboxStep->setAlignment(Qt::AlignRight);
spinboxStep->setValue(1);
spinboxStep->setToolTip(strTooltip[cxSTEP]);
inforrd->setRRASteps(spinboxStep->value());
doublespinboxXFactor->setRange(0.01,0.99);
doublespinboxXFactor->setDecimals(5);
doublespinboxXFactor->setSingleStep(0.01);
doublespinboxXFactor->setValue(.5);
doublespinboxXFactor->setToolTip(strTooltip[cxXFACTOR]);
inforrd->setRRAXFileFactor(doublespinboxXFactor->value());
for (unsigned int i=0; i<sizeof(stringValidateCF)/sizeof(QString); i++){
comboboxConsolidationFunction->addItem(stringValidateCF[i]);
}
comboboxConsolidationFunction->setToolTip(strTooltip[cxCONSOLIDFNCT]);
inforrd->setRRAConsolidationFunction(comboboxConsolidationFunction->currentText());
}
void WidgetConfigRRD::connects()
{
MY_DEBUG;
connect(signalMapper,
SIGNAL(mapped(int)),
this,
SLOT(updateRRDConfig(int))
);
signalMapper->setMapping(spinboxStep, cxSTEP);
signalMapper->setMapping(doublespinboxXFactor, cxXFACTOR);
signalMapper->setMapping(comboboxConsolidationFunction, cxCONSOLIDFNCT);
connect(spinboxStep, SIGNAL(valueChanged(int)),
signalMapper, SLOT(map()));
connect(doublespinboxXFactor, SIGNAL(valueChanged(double)),
signalMapper, SLOT(map()));
connect(comboboxConsolidationFunction, SIGNAL(currentIndexChanged(int)),
signalMapper, SLOT(map()));
}
void WidgetConfigRRD::layout()
{
MY_DEBUG;
QFormLayout *formlayout = new QFormLayout;
formlayout->addRow("Step",spinboxStep);
formlayout->addRow("X Factor",doublespinboxXFactor);
formlayout->addRow("Consolidation Function",comboboxConsolidationFunction);
formlayout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
QVBoxLayout * layout = new QVBoxLayout;
layout->addLayout(formlayout);
setLayout(layout);
}
void WidgetConfigRRD::updateRRDConfig(int value)
{
MY_DEBUG;
switch (value){
case cxSTEP:
inforrd->setRRASteps(spinboxStep->value());
break;
case cxXFACTOR:
inforrd->setRRAXFileFactor(doublespinboxXFactor->value());
break;
case cxCONSOLIDFNCT:
inforrd->setRRAConsolidationFunction(comboboxConsolidationFunction->currentText());
break;
default:
break;
}
}
WidgetConfigRRD::~WidgetConfigRRD()
{
MY_DEBUG;
}
| [
"[email protected]"
]
| [
[
[
1,
132
]
]
]
|
1908103efd1fdd85f8262d74fd77b1e199f9a2eb | a01b67b20207e2d31404262146763d3839ee833d | /trunk/Projet/trunk/Ui/layerindexdialog.h | 93855e4e16355431de5c6681e9160a3081e4a86d | []
| no_license | BackupTheBerlios/qtfin-svn | 49b59747b6753c72a035bf1e2e95601f91f5992c | ee18d9eb4f80a57a9121ba32dade96971196a3a2 | refs/heads/master | 2016-09-05T09:42:14.189410 | 2010-09-21T17:34:43 | 2010-09-21T17:34:43 | 40,801,620 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 561 | h | #ifndef LAYERINDEXDIALOG_H
#define LAYERINDEXDIALOG_H
#include "ui_layerindexdialog.h"
class LayerIndexDialog : public QDialog, private Ui::LayerIndexDialog {
Q_OBJECT
Q_DISABLE_COPY(LayerIndexDialog)
public:
explicit LayerIndexDialog(QWidget *parent = 0);
void setNbLayer(int nb) {
if(nb > 1) rankSpinBox->setMaximum(nb-1);
else rankSpinBox->setMaximum(0);
}
int getLayerRank() { return rankSpinBox->value(); }
protected:
virtual void changeEvent(QEvent *e);
};
#endif // LAYERINDEXDIALOG_H
| [
"kryptos@314bda93-af5c-0410-b653-d297496769b1"
]
| [
[
[
1,
21
]
]
]
|
7a6f405d11ddc75777c9f82ee4dfad375088ccb3 | b37d79e75a928795c76257a9b91e837075f08f62 | /Systray.cpp | 3b4313031fee3087a128c2670aa9ce5b7f041a3e | []
| no_license | voostindie/apache-watcher | f0c6a210574070d6852e7c43625fc5c094df3dea | c14573519158b15ac5c8ab2d2c7c82813549c9c6 | refs/heads/master | 2023-08-23T03:11:20.422892 | 2009-01-02T14:41:52 | 2009-01-02T14:41:52 | 407,803,347 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,756 | cpp | /*
* Systray.cpp
*
* Copyright (c) 1999 by Vincent Oostindie
*
* See Systray.h for global class information
*/
#include "stdafx.h"
#include "Systray.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Systray::Systray(HWND hWnd, UINT uID)
{
m_nidTrayIcon.cbSize = sizeof(NOTIFYICONDATA);
m_nidTrayIcon.hWnd = hWnd;
m_nidTrayIcon.uID = uID;
m_nidTrayIcon.uFlags = 0;
m_bVisible = false;
}
Systray::~Systray()
{
Hide();
}
//////////////////////////////////////////////////////////////////////
// Set methods
//////////////////////////////////////////////////////////////////////
void Systray::setIcon(const HICON hIcon)
{
m_nidTrayIcon.hIcon = hIcon;
m_nidTrayIcon.uFlags |= NIF_ICON;
Update();
}
void Systray::setCallbackMessage(const UINT uCallbackMessage)
{
m_nidTrayIcon.uCallbackMessage = uCallbackMessage;
m_nidTrayIcon.uFlags |= NIF_MESSAGE;
Update();
}
void Systray::setToolTip(LPCTSTR lpToolTip)
{
strncpy(m_nidTrayIcon.szTip, lpToolTip, sizeof(m_nidTrayIcon.szTip) - 1);
m_nidTrayIcon.uFlags |= NIF_TIP;
Update();
}
//////////////////////////////////////////////////////////////////////
// Show, Hide and Update methods
//////////////////////////////////////////////////////////////////////
void Systray::Show()
{
if (m_bVisible) return;
m_bVisible = true;
Shell_NotifyIcon(NIM_ADD, &m_nidTrayIcon);
}
void Systray::Hide()
{
if (!m_bVisible) return;
m_bVisible = false;
Shell_NotifyIcon(NIM_DELETE, &m_nidTrayIcon);
}
void Systray::Update()
{
Shell_NotifyIcon(NIM_MODIFY, &m_nidTrayIcon);
}
// [end of file] | [
"[email protected]"
]
| [
[
[
1,
79
]
]
]
|
56ddc7c5c31aa711cdd643d90f3d6c32bcaece00 | c1eae8224c4d3d380cc83ff6b218ba2a9df8d687 | /Source Codes/MeshUI/Numerical/Trackball.h | 55566e6da30b63f6808a398953814dc969cd3bbf | []
| no_license | pizibing/noise-removal | 15bad5c0fe1b3b5fb3f8b775040fc3dfeb48e49b | c087356bfa07305ce7ac6cce8745b1e676d6dc42 | refs/heads/master | 2016-09-06T17:40:15.754799 | 2010-03-05T06:47:59 | 2010-03-05T06:47:59 | 34,849,474 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,280 | h | /*_____________________________________________________
|
| 文件：Trackball.h
|
|_____________________________________________________*/
#if !defined(TRACKBALL_H)
#define TRACKBALL_H
#include "..\MeshLib\BasicElement.h"
class Trackball
{
public:
Trackball(void);
~Trackball(void);
public:
// 跟踪球的中心为窗口的中心
void SetTrackWindow(int iWidth, int iHeight);
// 跟踪球的中心为窗口坐标(centerX, centerY)
void SetTrackWindow(int iWidth, int iHeight, int iCenterX, int iCenterY);
// 输入刚按下鼠标时的坐标 (mouseX, mouseY)
void Start(int iMouseX, int iMouseY);
// 鼠标移动 (dx,dy), 计算旋转轴 axis 与角度 angle
void Tracking(int iDx, int iDy, Coord *axis, float *fAngle);
protected:
// 将鼠标(mouseX, mouseY)投影到球面一点 P
// 函数值即为球心到P的矢量
Coord MouseToCoord(int iMouseX, int iMouseY);
int m_iWidth, m_iHeight; // 窗口的宽高
int m_iCenterX, m_iCenterY; // 跟踪球中心
int m_iRadius; // 跟踪球半径
int m_iMouseX, m_iMouseY; // 鼠标位置
Coord m_start; // 刚按下时的鼠标投影矢量
Coord m_stop; // 移动(dx,dy)时的鼠标投影矢量
};
#endif // TRACKBALL_H
| [
"weihongyu1987@f7207f0a-2814-11df-8e46-3928208ddfa0"
]
| [
[
[
1,
49
]
]
]
|
b1322a5f674806c1d6827dd424eca525c954a156 | 555ce7f1e44349316e240485dca6f7cd4496ea9c | /DirectShowFilters/TsWriter/source/FileWriter.cpp | 0e9411449a68ba812f51a6a35505f8c5b77f053d | []
| no_license | Yura80/MediaPortal-1 | c71ce5abf68c70852d261bed300302718ae2e0f3 | 5aae402f5aa19c9c3091c6d4442b457916a89053 | refs/heads/master | 2021-04-15T09:01:37.267793 | 2011-11-25T20:02:53 | 2011-11-25T20:11:02 | 2,851,405 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,031 | cpp | /**
* FileWriter.cpp
* Copyright (C) 2006-2007 nate
*
* This file is part of TSFileSource, a directshow push source filter that
* provides an MPEG transport stream output.
*
* TSFileSource is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* TSFileSource is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with TSFileSource; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* nate can be reached on the forums at
* http://forums.dvbowners.com/
*/
#define _WIN32_WINNT 0x0502
#pragma warning(disable : 4995)
#include <streams.h>
#include "FileWriter.h"
#include <atlbase.h>
extern void LogDebug(const char *fmt, ...) ;
extern void LogDebug(const wchar_t *fmt, ...) ;
FileWriter::FileWriter() :
m_hFile(INVALID_HANDLE_VALUE),
m_pFileName(0),
m_bChunkReserve(FALSE),
m_chunkReserveSize(2000000),
m_chunkReserveFileSize(0),
m_maxFileSize(0)
{
}
FileWriter::~FileWriter()
{
CloseFile();
if (m_pFileName)
delete m_pFileName;
}
HRESULT FileWriter::GetFileName(LPWSTR *lpszFileName)
{
*lpszFileName = m_pFileName;
return S_OK;
}
HRESULT FileWriter::SetFileName(LPCWSTR pszFileName)
{
// Is this a valid filename supplied
CheckPointer(pszFileName,E_POINTER);
long length = wcslen(pszFileName);
if(length > MAX_PATH)
return ERROR_FILENAME_EXCED_RANGE;
// Take a copy of the filename
if (m_pFileName)
{
delete[] m_pFileName;
m_pFileName = NULL;
}
m_pFileName = new wchar_t[length+1];
if (m_pFileName == NULL)
return E_OUTOFMEMORY;
wcscpy(m_pFileName,pszFileName);
return S_OK;
}
//
// OpenFile
//
HRESULT FileWriter::OpenFile()
{
// Is the file already opened
if (m_hFile != INVALID_HANDLE_VALUE)
{
return NOERROR;
}
// Has a filename been set yet
if (m_pFileName == NULL)
{
return ERROR_INVALID_NAME;
}
// See the file is being read.
m_hFile = CreateFileW(m_pFileName, // The filename
(DWORD) GENERIC_WRITE, // File access
(DWORD) NULL, // Share access
NULL, // Security
(DWORD) OPEN_ALWAYS, // Open flags
(DWORD) 0, // More flags
NULL); // Template
if (m_hFile == INVALID_HANDLE_VALUE)
{
DWORD dwErr = GetLastError();
if (dwErr == ERROR_SHARING_VIOLATION)
{
return HRESULT_FROM_WIN32(dwErr);
}
return HRESULT_FROM_WIN32(dwErr);
}
CloseHandle(m_hFile);
// Try to open the file
m_hFile = CreateFileW(m_pFileName, // The filename
(DWORD) GENERIC_WRITE, // File access
(DWORD) FILE_SHARE_READ, // Share access
NULL, // Security
(DWORD) OPEN_ALWAYS, // Open flags
// (DWORD) FILE_FLAG_RANDOM_ACCESS,
// (DWORD) FILE_FLAG_WRITE_THROUGH, // More flags
(DWORD) 0, // More flags
NULL); // Template
if (m_hFile == INVALID_HANDLE_VALUE)
{
DWORD dwErr = GetLastError();
return HRESULT_FROM_WIN32(dwErr);
}
SetFilePointer(0, FILE_END);
m_chunkReserveFileSize = GetFilePointer();
SetFilePointer(0, FILE_BEGIN);
return S_OK;
}
//
// CloseFile
//
HRESULT FileWriter::CloseFile()
{
if (m_hFile == INVALID_HANDLE_VALUE)
{
return S_OK;
}
if (m_bChunkReserve)
{
__int64 currentPosition = GetFilePointer();
SetFilePointer(currentPosition, FILE_BEGIN);
SetEndOfFile(m_hFile);
}
CloseHandle(m_hFile);
m_hFile = INVALID_HANDLE_VALUE; // Invalidate the file
return S_OK;
}
BOOL FileWriter::IsFileInvalid()
{
return (m_hFile == INVALID_HANDLE_VALUE);
}
DWORD FileWriter::SetFilePointer(__int64 llDistanceToMove, DWORD dwMoveMethod)
{
LARGE_INTEGER li;
li.QuadPart = llDistanceToMove;
return ::SetFilePointer(m_hFile, li.LowPart, &li.HighPart, dwMoveMethod);
}
__int64 FileWriter::GetFilePointer()
{
LARGE_INTEGER li;
li.QuadPart = 0;
li.LowPart = ::SetFilePointer(m_hFile, 0, &li.HighPart, FILE_CURRENT);
return li.QuadPart;
}
HRESULT FileWriter::Write(PBYTE pbData, ULONG lDataLength)
{
HRESULT hr;
// If the file has already been closed, don't continue
if (m_hFile == INVALID_HANDLE_VALUE)
return S_FALSE;
if (m_bChunkReserve)
{
__int64 currentPosition = GetFilePointer();
if ((currentPosition + lDataLength > m_chunkReserveFileSize) &&
(m_chunkReserveFileSize < m_maxFileSize))
{
while (currentPosition + lDataLength > m_chunkReserveFileSize)
m_chunkReserveFileSize += m_chunkReserveSize;
if (m_chunkReserveFileSize > m_maxFileSize)
m_chunkReserveFileSize = m_maxFileSize;
SetFilePointer(m_chunkReserveFileSize, FILE_BEGIN);
SetEndOfFile(m_hFile);
SetFilePointer(currentPosition, FILE_BEGIN);
}
}
DWORD written = 0;
hr = WriteFile(m_hFile, (PVOID)pbData, (DWORD)lDataLength, &written, NULL);
if (FAILED(hr))
return hr;
if (written < (ULONG)lDataLength)
{
LogDebug(L"!!!!! Error writing to file %s: written %d of expected %d bytes", m_pFileName, written, lDataLength);
return S_FALSE;
}
return S_OK;
}
void FileWriter::SetChunkReserve(BOOL bEnable, __int64 chunkReserveSize, __int64 maxFileSize)
{
m_bChunkReserve = bEnable;
if (m_bChunkReserve)
{
m_chunkReserveSize = chunkReserveSize;
m_chunkReserveFileSize = 0;
m_maxFileSize = maxFileSize;
}
}
| [
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]"
]
| [
[
[
1,
2
],
[
4,
25
],
[
28,
32
],
[
36,
101
],
[
104,
105
],
[
107,
107
],
[
110,
121
],
[
123,
124
],
[
126,
128
],
[
131,
220
],
[
223,
223
],
[
225,
239
]
],
[
[
3,
3
]
],
[
[
26,
27
]
],
[
[
33,
33
],
[
35,
35
],
[
221,
221
],
[
224,
224
]
],
[
[
34,
34
],
[
102,
103
],
[
106,
106
],
[
108,
109
],
[
122,
122
],
[
125,
125
],
[
129,
130
],
[
222,
222
]
]
]
|
cdf9da513cf7a0ea1fe4d2e2487df4e5a6fd7e64 | 74c8da5b29163992a08a376c7819785998afb588 | /NetAnimal/addons/pa/dependencies/include/ParticleUniverse/ParticleAffectors/ParticleUniverseRandomiserTokens.h | ba7b355086fe54e1cb69816f881c17e02fab7470 | []
| no_license | dbabox/aomi | dbfb46c1c9417a8078ec9a516cc9c90fe3773b78 | 4cffc8e59368e82aed997fe0f4dcbd7df626d1d0 | refs/heads/master | 2021-01-13T14:05:10.813348 | 2011-06-07T09:36:41 | 2011-06-07T09:36:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,696 | h | /*
-----------------------------------------------------------------------------------------------
This source file is part of the Particle Universe product.
Copyright (c) 2010 Henry van Merode
Usage of this program is licensed under the terms of the Particle Universe Commercial License.
You can find a copy of the Commercial License in the Particle Universe package.
-----------------------------------------------------------------------------------------------
*/
#ifndef __PU_RANDOMISER_TOKENS_H__
#define __PU_RANDOMISER_TOKENS_H__
#include "ParticleUniversePrerequisites.h"
#include "ParticleUniverseAffectorTokens.h"
namespace ParticleUniverse
{
/** The RandomiserTranslator parses 'Randomiser' tokens
*/
class _ParticleUniverseExport RandomiserTranslator : public ScriptTranslator
{
public:
RandomiserTranslator(void){};
~RandomiserTranslator(void){};
virtual bool translateChildProperty(Ogre::ScriptCompiler* compiler, const Ogre::AbstractNodePtr &node);
virtual bool translateChildObject(Ogre::ScriptCompiler* compiler, const Ogre::AbstractNodePtr &node);
};
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
/**
*/
class _ParticleUniverseExport RandomiserWriter : public ParticleAffectorWriter
{
public:
RandomiserWriter(void) {};
virtual ~RandomiserWriter(void) {};
/** @see
ScriptWriter::write
*/
virtual void write(ParticleScriptSerializer* serializer , const IElement* element);
};
}
#endif
| [
"[email protected]"
]
| [
[
[
1,
50
]
]
]
|
02eb54cad25b6cdeb1c9949eb332a80f61c7c04c | ddaa7ebfabcd3b5c1742d12c48dd756ca6d60347 | /ttimer.h | e27504266b321d60dc729ca5da914610d75cb5c5 | []
| no_license | joelmandell/time | bd9cd44004416faeda515b1e47229433fb97c654 | c40cf7e3d9fbf961fd177bcfe9de0f77a6b89da9 | refs/heads/master | 2019-01-02T03:17:03.411631 | 2010-01-20T22:19:42 | 2010-01-20T22:19:42 | 470,903 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,852 | h | #ifndef TTIMER_H
#define TTIMER_H
#include <QMainWindow>
#include <QPushButton>
#include <QLineEdit>
#include <QWidget>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QGridLayout>
#include <QLabel>
#include <QTimer>
#include <QDomDocument>
#include <QXmlStreamReader>
#include <QStringList>
#include <QFile>
#include <QObject>
#include <QComboBox>
#include <QSignalMapper>
#include <Phonon/MediaObject>
#include <Phonon/VideoWidget>
#include <Phonon/AudioOutput>
#include <QThread>
class QComboBox;
class QFile;
class QStringList;
class QXmlStreamReader;
class QDomDocument;
class QTimer;
class QPushButton;
class QLineEdit;
class QVBoxLayout;
class QHBoxLayout;
class QWidget;
class QGridLayout;
class QLabel;
class QObject;
class MediaObject;
class VideoWidget;
class AudioOutput;
class QScrollArea;
class QThread;
class TTimerThread : public QThread
{
Q_OBJECT
public:
void run();
QTimer timer;
};
class TTimer : public QMainWindow
{
Q_OBJECT
public:
TTimer(QWidget *parent = 0);
TTimerThread *thread;
void firstRunWizard();
void startTiming();
QSignalMapper *signalMapper;
/*VAL*/
int seconds;
int minutes;
int countSpeechItem;
int totalNrOfItems;
int totalSeconds;
/*Config set:ed variables for the application.*/
QString xmlTimeSchemaFile;
/*Config variables end*/
QWidget *mainWidget;
QComboBox *timeSchedules;
QLabel *lblName;
QLabel *lblClock;
QStringList *allowingItemOverride;
QStringList *speechItemLength;
QPushButton *btnTimeAlert;
QPushButton *btnTimeStart;
QPushButton *btnTimeStop;
QHBoxLayout *mainLayout;
QHBoxLayout *cLayout;
QGridLayout *gridLayout;
QScrollArea *scrollArea;
/*Widgets for configuration dialog:*/
QWidget *configWidget;
QGridLayout *configLayout;
QLineEdit *configEdit;
QLabel *configLabel;
QPushButton *btnSpara;
void init();
void layoutResize();
public slots:
void endAlarm();
void playAlarm();
void setConfig();
void loadConfig();
void startClock();
void setTime();
void stopClock();
void moveIt(QString command);
private:
void createActions();
void createMenus();
QMenu *editMenu;
QAction *editProperties;
QAction *createSchema;
private slots:
void configDialog();
protected:
bool eventFilter(QObject *obj, QEvent *event);
void paintEvent ( QPaintEvent * event );
};
#endif
| [
"[email protected]"
]
| [
[
[
1,
129
]
]
]
|
b8b41b370772cdf0b271a3da83cee7b5b2323fb4 | d54d8b1bbc9575f3c96853e0c67f17c1ad7ab546 | /hlsdk-2.3-p3/multiplayer/dlls/monsters.h | c3fa0a6b70f7cc454ba8e2e829f6dd5538e76a2c | []
| no_license | joropito/amxxgroup | 637ee71e250ffd6a7e628f77893caef4c4b1af0a | f948042ee63ebac6ad0332f8a77393322157fa8f | refs/heads/master | 2021-01-10T09:21:31.449489 | 2010-04-11T21:34:27 | 2010-04-11T21:34:27 | 47,087,485 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,277 | h | /***
*
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
* Use, distribution, and modification of this source code and/or resulting
* object code is restricted to non-commercial enhancements to products from
* Valve LLC. All other use, distribution, or modification is prohibited
* without written permission from Valve LLC.
*
****/
#ifndef MONSTERS_H
#include "skill.h"
#define MONSTERS_H
/*
===== monsters.h ========================================================
Header file for monster-related utility code
*/
// Hit Group standards
#define HITGROUP_GENERIC 0
#define HITGROUP_HEAD 1
#define HITGROUP_CHEST 2
#define HITGROUP_STOMACH 3
#define HITGROUP_LEFTARM 4
#define HITGROUP_RIGHTARM 5
#define HITGROUP_LEFTLEG 6
#define HITGROUP_RIGHTLEG 7
// spawn flags 256 and above are already taken by the engine
extern void UTIL_MoveToOrigin( edict_t* pent, const Vector &vecGoal, float flDist, int iMoveType );
Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flGravityAdj = 1.0 );
Vector VecCheckThrow ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flSpeed, float flGravityAdj = 1.0 );
extern DLL_GLOBAL Vector g_vecAttackDir;
extern DLL_GLOBAL CONSTANT float g_flMeleeRange;
extern DLL_GLOBAL CONSTANT float g_flMediumRange;
extern DLL_GLOBAL CONSTANT float g_flLongRange;
extern void EjectBrass (const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype );
extern void ExplodeModel( const Vector &vecOrigin, float speed, int model, int count );
BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget );
BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTargetOrigin, float flSize = 0.0 );
// monster to monster relationship types
#define R_AL -2 // (ALLY) pals. Good alternative to R_NO when applicable.
#define R_FR -1// (FEAR)will run
#define R_NO 0// (NO RELATIONSHIP) disregard
#define R_DL 1// (DISLIKE) will attack
#define R_HT 2// (HATE)will attack this character instead of any visible DISLIKEd characters
#define R_NM 3// (NEMESIS) A monster Will ALWAYS attack its nemsis, no matter what
#define bits_MEMORY_KILLED ( 1 << 7 )// HACKHACK -- remember that I've already called my Killed()
//
// A gib is a chunk of a body, or a piece of wood/metal/rocks/etc.
//
class CGib : public CBaseEntity
{
public:
void Spawn( const char *szGibModel );
void EXPORT BounceGibTouch ( CBaseEntity *pOther );
void EXPORT StickyGibTouch ( CBaseEntity *pOther );
void EXPORT WaitTillLand( void );
void LimitVelocity( void );
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_DONT_SAVE; }
static void SpawnHeadGib( entvars_t *pevVictim );
static void SpawnRandomGibs( entvars_t *pevVictim, int cGibs, int human );
static void SpawnStickyGibs( entvars_t *pevVictim, Vector vecOrigin, int cGibs );
int m_bloodColor;
int m_cBloodDecals;
int m_material;
float m_lifeTime;
};
#endif //MONSTERS_H
| [
"joropito@23c7d628-c96c-11de-a380-73d83ba7c083"
]
| [
[
[
1,
88
]
]
]
|
f0cae7c58cbbbea7baf8f35ba6298932ff41acfd | 24bc1634133f5899f7db33e5d9692ba70940b122 | /src/ammo/game/game.hpp | 265dd46f8d4e123e014bca91bd590271728ec56c | []
| no_license | deft-code/ammo | 9a9cd9bd5fb75ac1b077ad748617613959dbb7c9 | fe4139187dd1d371515a2d171996f81097652e99 | refs/heads/master | 2016-09-05T08:48:51.786465 | 2009-10-09T05:49:00 | 2009-10-09T05:49:00 | 32,252,326 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,198 | hpp | #ifndef GAME_H_INCLUDED
#define GAME_H_INCLUDED
#include "ReplicaManager2.h"
#include "ammo/graphics/graphic_sys.hpp"
#include "ammo/network/netpeer.hpp"
#include "ammo/audio/sound_sys.hpp"
#include "ammo/game/gamestate.hpp"
#include "ammo/physics/physic_sys.hpp"
#include "ammo/graphics/icameratarget.hpp"
#include "ammo/input/input_sys.hpp"
namespace ammo
{
class NetPeer;
class GameState;
class Game
{
public:
Game() : _camTarget(NULL) {}
virtual void Update(float deltaTime) = 0;
virtual void Draw(float deltaTime) = 0;
// Getters
GraphicSys* GetGraphicSys(){ return _graphics;}
NetPeer* GetNetPeer(){return _peer;}
SoundSys* GetSoundSys() {return _sound;}
GameState* GetGameState() { return _gameState;}
PhysicSys* GetPhysicsSys() { return _physic;}
InputSys* GetInputSys() { return _input; }
void SetCameraTarget(ICameraTarget* target) { _camTarget = target;}
protected:
GraphicSys* _graphics;
NetPeer* _peer;
SoundSys* _sound;
GameState* _gameState;
PhysicSys* _physic;
InputSys* _input;
ICameraTarget* _camTarget;
};
}
#endif // GAME_H_INCLUDED
| [
"PhillipSpiess@d8b90d80-bb63-11dd-bed2-db724ec49875",
"j.nick.terry@d8b90d80-bb63-11dd-bed2-db724ec49875"
]
| [
[
[
1,
45
]
],
[
[
46,
47
]
]
]
|
2157a8a7e56186f19db0a1e01e4c62a3f75ff74a | 138a353006eb1376668037fcdfbafc05450aa413 | /source/ogre/OgreNewt/boost/mpl/set/set10_c.hpp | 7f2c5bc7978658873300abbbee3a0449c540bb14 | []
| no_license | sonicma7/choreopower | 107ed0a5f2eb5fa9e47378702469b77554e44746 | 1480a8f9512531665695b46dcfdde3f689888053 | refs/heads/master | 2020-05-16T20:53:11.590126 | 2009-11-18T03:10:12 | 2009-11-18T03:10:12 | 32,246,184 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,287 | hpp |
#ifndef BOOST_MPL_SET_SET10_C_HPP_INCLUDED
#define BOOST_MPL_SET_SET10_C_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
// Copyright David Abrahams 2003-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Source: /cvsroot/ogre/ogreaddons/ogrenewt/OgreNewt_Main/inc/boost/mpl/set/set10_c.hpp,v $
// $Date: 2006/04/17 23:49:48 $
// $Revision: 1.1 $
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/set/set0_c.hpp>
# include <boost/mpl/set/set10.hpp>
#endif
#include <boost/mpl/aux_/config/use_preprocessed.hpp>
#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE)
# define BOOST_MPL_PREPROCESSED_HEADER set10_c.hpp
# include <boost/mpl/set/aux_/include_preprocessed.hpp>
#else
# include <boost/preprocessor/iterate.hpp>
namespace boost { namespace mpl {
# define BOOST_PP_ITERATION_PARAMS_1 \
(3,(1, 10, <boost/mpl/set/aux_/numbered_c.hpp>))
# include BOOST_PP_ITERATE()
}}
#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
#endif // BOOST_MPL_SET_SET10_C_HPP_INCLUDED
| [
"Sonicma7@0822fb10-d3c0-11de-a505-35228575a32e"
]
| [
[
[
1,
45
]
]
]
|
8b871332e3b4a4908a2658c7920b793b74bfdfbf | 71ffdff29137de6bda23f02c9e22a45fe94e7910 | /LevelEditor/src/data/IUpdate.h | 16ffd988e10ecee723d0cd0ec743817e6d87f1d4 | []
| no_license | anhoppe/killakoptuz3000 | f2b6ecca308c1d6ebee9f43a1632a2051f321272 | fbf2e77d16c11abdadf45a88e1c747fa86517c59 | refs/heads/master | 2021-01-02T22:19:10.695739 | 2009-03-15T21:22:31 | 2009-03-15T21:22:31 | 35,839,301 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 561 | h | // ***************************************************************
// IUpdate version: 1.0 · date: 06/22/2007
// -------------------------------------------------------------
//
// -------------------------------------------------------------
// Copyright (C) 2007 - All Rights Reserved
// ***************************************************************
//
// ***************************************************************
#ifndef IUPDATE_H
#define IUPDATE_H
class IUpdate
{
public:
virtual void update() = 0;
};
#endif
| [
"anhoppe@9386d06f-8230-0410-af72-8d16ca8b68df"
]
| [
[
[
1,
20
]
]
]
|
e6343674dcf72693b000122b58ef78907fbe0cf6 | 1cc5720e245ca0d8083b0f12806a5c8b13b5cf98 | /v102/ok/10260/10260.cpp | 3ff74e3049ef71581ffdf7c75f3130966192ab3d | []
| no_license | Emerson21/uva-problems | 399d82d93b563e3018921eaff12ca545415fd782 | 3079bdd1cd17087cf54b08c60e2d52dbd0118556 | refs/heads/master | 2021-01-18T09:12:23.069387 | 2010-12-15T00:38:34 | 2010-12-15T00:38:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 525 | cpp | #include <stdio.h>
#include <string>
using namespace std;
int main() {
char s[30],v[30],vc;
string val = "01230120022455012623010202";
register int i, len, bet, c;
while(fgets(s,25,stdin)) {
vc = 0;
for(i=0;s[i]!='\r' && s[i]!='\n' && s[i]!='\0';i++) {
c = s[i] - 'A';
if(val[c]=='0') {
bet = 1;
continue;
}
if(vc==0 || bet==1 || (val[c]!=v[vc-1])) {
v[vc++] = val[c];
bet = 0;
}
}
v[vc] = 0;
printf("%s\n",v);
}
}
| [
"[email protected]"
]
| [
[
[
1,
36
]
]
]
|
cc7acb13391afe51e03508290abda204d1e05c13 | 4f469243a2e6fc370f0d1859ec68de5efce90fa1 | /infected/src/public/tier0/memoverride.cpp | 73036423b5551437644d54e0c45d4c758e956c66 | []
| no_license | sideshowdave7/hl2-infected-mod | c710d3958cc143381eba28b7237c8f4ccdd49982 | a69fe39a2e13cbac3978ecf57c84cd8e9aa7bb0d | refs/heads/master | 2020-12-24T15:41:30.546220 | 2011-04-30T03:05:50 | 2011-04-30T03:05:50 | 61,587,106 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 35,354 | cpp | //========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: Insert this file into all projects using the memory system
// It will cause that project to use the shader memory allocator
//
// $NoKeywords: $
//=============================================================================//
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
#undef PROTECTED_THINGS_ENABLE // allow use of _vsnprintf
#if defined( _WIN32 ) && !defined( _X360 )
#define WIN_32_LEAN_AND_MEAN
#include <windows.h>
#endif
#include "tier0/dbg.h"
#include "tier0/memalloc.h"
#include <string.h>
#include <stdio.h>
#include "memdbgoff.h"
// Tags this DLL as debug
#if defined( _DEBUG ) && !defined( _X360 )
DLL_EXPORT void BuiltDebug() {}
#endif
#ifdef _WIN32
// ARG: crtdbg is necessary for certain definitions below,
// but it also redefines malloc as a macro in release.
// To disable this, we gotta define _DEBUG before including it.. BLEAH!
#define _DEBUG 1
#include "crtdbg.h"
#ifdef NDEBUG
#undef _DEBUG
#endif
// Turn this back off in release mode.
#ifdef NDEBUG
#undef _DEBUG
#endif
#elif _LINUX
#define __cdecl
#endif
#if defined( _WIN32 ) && !defined( _X360 )
const char *MakeModuleFileName()
{
if ( g_pMemAlloc->IsDebugHeap() )
{
char *pszModuleName = (char *)HeapAlloc( GetProcessHeap(), 0, MAX_PATH ); // small leak, debug only
MEMORY_BASIC_INFORMATION mbi;
static int dummy;
VirtualQuery( &dummy, &mbi, sizeof(mbi) );
GetModuleFileName( reinterpret_cast<HMODULE>(mbi.AllocationBase), pszModuleName, MAX_PATH );
char *pDot = strrchr( pszModuleName, '.' );
if ( pDot )
{
char *pSlash = strrchr( pszModuleName, '\\' );
if ( pSlash )
{
pszModuleName = pSlash + 1;
*pDot = 0;
}
}
return pszModuleName;
}
return NULL;
}
static void *AllocUnattributed( size_t nSize )
{
static const char *pszOwner = MakeModuleFileName();
if ( !pszOwner )
return g_pMemAlloc->Alloc(nSize);
else
return g_pMemAlloc->Alloc(nSize, pszOwner, 0);
}
static void *ReallocUnattributed( void *pMem, size_t nSize )
{
static const char *pszOwner = MakeModuleFileName();
if ( !pszOwner )
return g_pMemAlloc->Realloc(pMem, nSize);
else
return g_pMemAlloc->Realloc(pMem, nSize, pszOwner, 0);
}
#else
#define MakeModuleFileName() NULL
inline void *AllocUnattributed( size_t nSize )
{
return g_pMemAlloc->Alloc(nSize);
}
inline void *ReallocUnattributed( void *pMem, size_t nSize )
{
return g_pMemAlloc->Realloc(pMem, nSize);
}
#endif
//-----------------------------------------------------------------------------
// Standard functions in the CRT that we're going to override to call our allocator
//-----------------------------------------------------------------------------
#if defined(_WIN32) && !defined(_STATIC_LINKED)
// this magic only works under win32
// under linux this malloc() overrides the libc malloc() and so we
// end up in a recursion (as g_pMemAlloc->Alloc() calls malloc)
#if _MSC_VER >= 1400
#define ALLOC_CALL _CRTNOALIAS _CRTRESTRICT
#define FREE_CALL _CRTNOALIAS
#else
#define ALLOC_CALL
#define FREE_CALL
#endif
extern "C"
{
ALLOC_CALL void *malloc( size_t nSize )
{
return AllocUnattributed( nSize );
}
FREE_CALL void free( void *pMem )
{
g_pMemAlloc->Free(pMem);
}
ALLOC_CALL void *realloc( void *pMem, size_t nSize )
{
return ReallocUnattributed( pMem, nSize );
}
ALLOC_CALL void *calloc( size_t nCount, size_t nElementSize )
{
void *pMem = AllocUnattributed( nElementSize * nCount );
memset(pMem, 0, nElementSize * nCount);
return pMem;
}
} // end extern "C"
//-----------------------------------------------------------------------------
// Non-standard MSVC functions that we're going to override to call our allocator
//-----------------------------------------------------------------------------
extern "C"
{
// 64-bit
#ifdef _WIN64
void* __cdecl _malloc_base( size_t nSize )
{
return AllocUnattributed( nSize );
}
#else
void *_malloc_base( size_t nSize )
{
return AllocUnattributed( nSize );
}
#endif
void *_calloc_base( size_t nSize )
{
void *pMem = AllocUnattributed( nSize );
memset(pMem, 0, nSize);
return pMem;
}
void *_realloc_base( void *pMem, size_t nSize )
{
return ReallocUnattributed( pMem, nSize );
}
void *_recalloc_base( void *pMem, size_t nSize )
{
void *pMemOut = ReallocUnattributed( pMem, nSize );
memset(pMemOut, 0, nSize);
return pMemOut;
}
void _free_base( void *pMem )
{
g_pMemAlloc->Free(pMem);
}
void *__cdecl _expand_base( void *pMem, size_t nNewSize, int nBlockUse )
{
Assert( 0 );
return NULL;
}
// crt
void * __cdecl _malloc_crt(size_t size)
{
return AllocUnattributed( size );
}
void * __cdecl _calloc_crt(size_t count, size_t size)
{
return _calloc_base( count * size );
}
void * __cdecl _realloc_crt(void *ptr, size_t size)
{
return _realloc_base( ptr, size );
}
void * __cdecl _recalloc_crt(void *ptr, size_t count, size_t size)
{
return _recalloc_base( ptr, size * count );
}
ALLOC_CALL void * __cdecl _recalloc ( void * memblock, size_t count, size_t size )
{
void *pMem = ReallocUnattributed( memblock, size * count );
memset( pMem, 0, size * count );
return pMem;
}
size_t _msize_base( void *pMem )
{
return g_pMemAlloc->GetSize(pMem);
}
size_t _msize( void *pMem )
{
return _msize_base(pMem);
}
size_t msize( void *pMem )
{
return g_pMemAlloc->GetSize(pMem);
}
void *__cdecl _heap_alloc( size_t nSize )
{
return AllocUnattributed( nSize );
}
void *__cdecl _nh_malloc( size_t nSize, int )
{
return AllocUnattributed( nSize );
}
void *__cdecl _expand( void *pMem, size_t nSize )
{
Assert( 0 );
return NULL;
}
unsigned int _amblksiz = 16; //BYTES_PER_PARA;
#if _MSC_VER >= 1400
HANDLE _crtheap = (HANDLE)1; // PatM Can't be 0 or CRT pukes
int __active_heap = 1;
#endif // _MSC_VER >= 1400
size_t __cdecl _get_sbh_threshold( void )
{
return 0;
}
int __cdecl _set_sbh_threshold( size_t )
{
return 0;
}
int _heapchk()
{
return g_pMemAlloc->heapchk();
}
int _heapmin()
{
return 1;
}
int __cdecl _heapadd( void *, size_t )
{
return 0;
}
int __cdecl _heapset( unsigned int )
{
return 0;
}
size_t __cdecl _heapused( size_t *, size_t * )
{
return 0;
}
#ifdef _WIN32
int __cdecl _heapwalk( _HEAPINFO * )
{
return 0;
}
#endif
} // end extern "C"
//-----------------------------------------------------------------------------
// Debugging functions that we're going to override to call our allocator
// NOTE: These have to be here for release + debug builds in case we
// link to a debug static lib!!!
//-----------------------------------------------------------------------------
extern "C"
{
void *malloc_db( size_t nSize, const char *pFileName, int nLine )
{
return g_pMemAlloc->Alloc(nSize, pFileName, nLine);
}
void free_db( void *pMem, const char *pFileName, int nLine )
{
g_pMemAlloc->Free(pMem, pFileName, nLine);
}
void *realloc_db( void *pMem, size_t nSize, const char *pFileName, int nLine )
{
return g_pMemAlloc->Realloc(pMem, nSize, pFileName, nLine);
}
} // end extern "C"
//-----------------------------------------------------------------------------
// These methods are standard MSVC heap initialization + shutdown methods
//-----------------------------------------------------------------------------
extern "C"
{
#if !defined( _X360 )
int __cdecl _heap_init()
{
return g_pMemAlloc != NULL;
}
void __cdecl _heap_term()
{
}
#endif
}
#endif
//-----------------------------------------------------------------------------
// Prevents us from using an inappropriate new or delete method,
// ensures they are here even when linking against debug or release static libs
//-----------------------------------------------------------------------------
#ifndef NO_MEMOVERRIDE_NEW_DELETE
void *__cdecl operator new( unsigned int nSize )
{
return AllocUnattributed( nSize );
}
void *__cdecl operator new( unsigned int nSize, int nBlockUse, const char *pFileName, int nLine )
{
return g_pMemAlloc->Alloc(nSize, pFileName, nLine);
}
void __cdecl operator delete( void *pMem )
{
g_pMemAlloc->Free( pMem );
}
void *__cdecl operator new[] ( unsigned int nSize )
{
return AllocUnattributed( nSize );
}
void *__cdecl operator new[] ( unsigned int nSize, int nBlockUse, const char *pFileName, int nLine )
{
return g_pMemAlloc->Alloc(nSize, pFileName, nLine);
}
void __cdecl operator delete[] ( void *pMem )
{
g_pMemAlloc->Free( pMem );
}
#endif
//-----------------------------------------------------------------------------
// Override some debugging allocation methods in MSVC
// NOTE: These have to be here for release + debug builds in case we
// link to a debug static lib!!!
//-----------------------------------------------------------------------------
#ifndef _STATIC_LINKED
#ifdef _WIN32
// This here just hides the internal file names, etc of allocations
// made in the c runtime library
#define CRT_INTERNAL_FILE_NAME "C-runtime internal"
class CAttibCRT
{
public:
CAttibCRT(int nBlockUse) : m_nBlockUse(nBlockUse)
{
if (m_nBlockUse == _CRT_BLOCK)
{
g_pMemAlloc->PushAllocDbgInfo(CRT_INTERNAL_FILE_NAME, 0);
}
}
~CAttibCRT()
{
if (m_nBlockUse == _CRT_BLOCK)
{
g_pMemAlloc->PopAllocDbgInfo();
}
}
private:
int m_nBlockUse;
};
#define AttribIfCrt() CAttibCRT _attrib(nBlockUse)
#elif defined(_LINUX)
#define AttribIfCrt()
#endif // _WIN32
extern "C"
{
void *__cdecl _nh_malloc_dbg( size_t nSize, int nFlag, int nBlockUse,
const char *pFileName, int nLine )
{
AttribIfCrt();
return g_pMemAlloc->Alloc(nSize, pFileName, nLine);
}
void *__cdecl _malloc_dbg( size_t nSize, int nBlockUse,
const char *pFileName, int nLine )
{
AttribIfCrt();
return g_pMemAlloc->Alloc(nSize, pFileName, nLine);
}
void *__cdecl _calloc_dbg( size_t nNum, size_t nSize, int nBlockUse,
const char *pFileName, int nLine )
{
AttribIfCrt();
void *pMem = g_pMemAlloc->Alloc(nSize * nNum, pFileName, nLine);
memset(pMem, 0, nSize * nNum);
return pMem;
}
void *__cdecl _realloc_dbg( void *pMem, size_t nNewSize, int nBlockUse,
const char *pFileName, int nLine )
{
AttribIfCrt();
return g_pMemAlloc->Realloc(pMem, nNewSize, pFileName, nLine);
}
void *__cdecl _expand_dbg( void *pMem, size_t nNewSize, int nBlockUse,
const char *pFileName, int nLine )
{
Assert( 0 );
return NULL;
}
void __cdecl _free_dbg( void *pMem, int nBlockUse )
{
AttribIfCrt();
g_pMemAlloc->Free(pMem);
}
size_t __cdecl _msize_dbg( void *pMem, int nBlockUse )
{
#ifdef _WIN32
return _msize(pMem);
#elif _LINUX
Assert( "_msize_dbg unsupported" );
return 0;
#endif
}
#ifdef _WIN32
#if defined(_DEBUG) && _MSC_VER >= 1300
// X360TBD: aligned and offset allocations may be important on the 360
// aligned base
ALLOC_CALL void *__cdecl _aligned_malloc_base( size_t size, size_t align )
{
return MemAlloc_AllocAligned( size, align );
}
ALLOC_CALL void *__cdecl _aligned_realloc_base( void *ptr, size_t size, size_t align )
{
return MemAlloc_ReallocAligned( ptr, size, align );
}
ALLOC_CALL void *__cdecl _aligned_recalloc_base( void *ptr, size_t size, size_t align )
{
Error( "Unsupported function\n" );
return NULL;
}
FREE_CALL void __cdecl _aligned_free_base( void *ptr )
{
MemAlloc_FreeAligned( ptr );
}
// aligned
ALLOC_CALL void * __cdecl _aligned_malloc( size_t size, size_t align )
{
return _aligned_malloc_base(size, align);
}
ALLOC_CALL void *__cdecl _aligned_realloc(void *memblock, size_t size, size_t align)
{
return _aligned_realloc_base(memblock, size, align);
}
ALLOC_CALL void * __cdecl _aligned_recalloc( void * memblock, size_t count, size_t size, size_t align )
{
return _aligned_recalloc_base(memblock, count * size, align);
}
FREE_CALL void __cdecl _aligned_free( void *memblock )
{
_aligned_free_base(memblock);
}
// aligned offset base
ALLOC_CALL void * __cdecl _aligned_offset_malloc_base( size_t size, size_t align, size_t offset )
{
Assert( IsPC() || 0 );
return NULL;
}
ALLOC_CALL void * __cdecl _aligned_offset_realloc_base( void * memblock, size_t size, size_t align, size_t offset)
{
Assert( IsPC() || 0 );
return NULL;
}
ALLOC_CALL void * __cdecl _aligned_offset_recalloc_base( void * memblock, size_t size, size_t align, size_t offset)
{
Assert( IsPC() || 0 );
return NULL;
}
// aligned offset
ALLOC_CALL void *__cdecl _aligned_offset_malloc(size_t size, size_t align, size_t offset)
{
return _aligned_offset_malloc_base( size, align, offset );
}
ALLOC_CALL void *__cdecl _aligned_offset_realloc(void *memblock, size_t size, size_t align, size_t offset)
{
return _aligned_offset_realloc_base( memblock, size, align, offset );
}
ALLOC_CALL void * __cdecl _aligned_offset_recalloc( void * memblock, size_t count, size_t size, size_t align, size_t offset )
{
return _aligned_offset_recalloc_base( memblock, count * size, align, offset );
}
#endif // _MSC_VER >= 1400
#endif
} // end extern "C"
//-----------------------------------------------------------------------------
// Override some the _CRT debugging allocation methods in MSVC
//-----------------------------------------------------------------------------
#ifdef _WIN32
extern "C"
{
int _CrtDumpMemoryLeaks(void)
{
return 0;
}
_CRT_DUMP_CLIENT _CrtSetDumpClient( _CRT_DUMP_CLIENT dumpClient )
{
return NULL;
}
int _CrtSetDbgFlag( int nNewFlag )
{
return g_pMemAlloc->CrtSetDbgFlag( nNewFlag );
}
// 64-bit port.
#define AFNAME(var) __p_ ## var
#define AFRET(var) &var
int _crtDbgFlag = _CRTDBG_ALLOC_MEM_DF;
int* AFNAME(_crtDbgFlag)(void)
{
return AFRET(_crtDbgFlag);
}
long _crtBreakAlloc; /* Break on this allocation */
long* AFNAME(_crtBreakAlloc) (void)
{
return AFRET(_crtBreakAlloc);
}
void __cdecl _CrtSetDbgBlockType( void *pMem, int nBlockUse )
{
DebuggerBreak();
}
_CRT_ALLOC_HOOK __cdecl _CrtSetAllocHook( _CRT_ALLOC_HOOK pfnNewHook )
{
DebuggerBreak();
return NULL;
}
long __cdecl _CrtSetBreakAlloc( long lNewBreakAlloc )
{
return g_pMemAlloc->CrtSetBreakAlloc( lNewBreakAlloc );
}
int __cdecl _CrtIsValidHeapPointer( const void *pMem )
{
return g_pMemAlloc->CrtIsValidHeapPointer( pMem );
}
int __cdecl _CrtIsValidPointer( const void *pMem, unsigned int size, int access )
{
return g_pMemAlloc->CrtIsValidPointer( pMem, size, access );
}
int __cdecl _CrtCheckMemory( void )
{
// FIXME: Remove this when we re-implement the heap
return g_pMemAlloc->CrtCheckMemory( );
}
int __cdecl _CrtIsMemoryBlock( const void *pMem, unsigned int nSize,
long *plRequestNumber, char **ppFileName, int *pnLine )
{
DebuggerBreak();
return 1;
}
int __cdecl _CrtMemDifference( _CrtMemState *pState, const _CrtMemState * oldState, const _CrtMemState * newState )
{
DebuggerBreak();
return FALSE;
}
void __cdecl _CrtMemDumpStatistics( const _CrtMemState *pState )
{
DebuggerBreak();
}
void __cdecl _CrtMemCheckpoint( _CrtMemState *pState )
{
// FIXME: Remove this when we re-implement the heap
g_pMemAlloc->CrtMemCheckpoint( pState );
}
void __cdecl _CrtMemDumpAllObjectsSince( const _CrtMemState *pState )
{
DebuggerBreak();
}
void __cdecl _CrtDoForAllClientObjects( void (*pfn)(void *, void *), void * pContext )
{
DebuggerBreak();
}
//-----------------------------------------------------------------------------
// Methods in dbgrpt.cpp
//-----------------------------------------------------------------------------
long _crtAssertBusy = -1;
int __cdecl _CrtSetReportMode( int nReportType, int nReportMode )
{
return g_pMemAlloc->CrtSetReportMode( nReportType, nReportMode );
}
_HFILE __cdecl _CrtSetReportFile( int nRptType, _HFILE hFile )
{
return (_HFILE)g_pMemAlloc->CrtSetReportFile( nRptType, hFile );
}
_CRT_REPORT_HOOK __cdecl _CrtSetReportHook( _CRT_REPORT_HOOK pfnNewHook )
{
return (_CRT_REPORT_HOOK)g_pMemAlloc->CrtSetReportHook( pfnNewHook );
}
int __cdecl _CrtDbgReport( int nRptType, const char * szFile,
int nLine, const char * szModule, const char * szFormat, ... )
{
static char output[1024];
va_list args;
va_start( args, szFormat );
_vsnprintf( output, sizeof( output )-1, szFormat, args );
va_end( args );
return g_pMemAlloc->CrtDbgReport( nRptType, szFile, nLine, szModule, output );
}
#if _MSC_VER >= 1400
#if defined( _DEBUG )
#endif /* defined( _DEBUG ) */
#if defined( _DEBUG ) || defined( USE_MEM_DEBUG )
int __cdecl __crtMessageWindowW( int nRptType, const wchar_t * szFile, const wchar_t * szLine,
const wchar_t * szModule, const wchar_t * szUserMessage )
{
Assert(0);
return 0;
}
int __cdecl _CrtDbgReportV( int nRptType, const wchar_t *szFile, int nLine,
const wchar_t *szModule, const wchar_t *szFormat, va_list arglist )
{
Assert(0);
return 0;
}
int __cdecl _CrtDbgReportW( int nRptType, const wchar_t *szFile, int nLine,
const wchar_t *szModule, const wchar_t *szFormat, ...)
{
Assert(0);
return 0;
}
int __cdecl _VCrtDbgReportA( int nRptType, const wchar_t * szFile, int nLine,
const wchar_t * szModule, const wchar_t * szFormat, va_list arglist )
{
Assert(0);
return 0;
}
int __cdecl _CrtSetReportHook2( int mode, _CRT_REPORT_HOOK pfnNewHook )
{
_CrtSetReportHook( pfnNewHook );
return 0;
}
#endif /* defined( _DEBUG ) || defined( USE_MEM_DEBUG ) */
extern "C" int __crtDebugCheckCount = FALSE;
extern "C" int __cdecl _CrtSetCheckCount( int fCheckCount )
{
int oldCheckCount = __crtDebugCheckCount;
return oldCheckCount;
}
extern "C" int __cdecl _CrtGetCheckCount( void )
{
return __crtDebugCheckCount;
}
// aligned offset debug
extern "C" void * __cdecl _aligned_offset_recalloc_dbg( void * memblock, size_t count, size_t size, size_t align, size_t offset, const char * f_name, int line_n )
{
Assert( IsPC() || 0 );
void *pMem = ReallocUnattributed( memblock, size * count );
memset( pMem, 0, size * count );
return pMem;
}
extern "C" void * __cdecl _aligned_recalloc_dbg( void *memblock, size_t count, size_t size, size_t align, const char * f_name, int line_n )
{
return _aligned_offset_recalloc_dbg(memblock, count, size, align, 0, f_name, line_n);
}
extern "C" void * __cdecl _recalloc_dbg ( void * memblock, size_t count, size_t size, int nBlockUse, const char * szFileName, int nLine )
{
return _aligned_offset_recalloc_dbg(memblock, count, size, 0, 0, szFileName, nLine);
}
_CRT_REPORT_HOOK __cdecl _CrtGetReportHook( void )
{
return NULL;
}
#endif
int __cdecl _CrtReportBlockType(const void * pUserData)
{
return 0;
}
} // end extern "C"
#endif // _WIN32
// Most files include this file, so when it's used it adds an extra .ValveDbg section,
// to help identify debug binaries.
#ifdef _WIN32
#ifndef NDEBUG // _DEBUG
#pragma data_seg("ValveDBG")
volatile const char* DBG = "*** DEBUG STUB ***";
#endif
#endif
#endif
// Extras added prevent dbgheap.obj from being included - DAL
#ifdef _WIN32
extern "C"
{
size_t __crtDebugFillThreshold = 0;
extern "C" void * __cdecl _heap_alloc_base (size_t size) {
assert(0);
return NULL;
}
void * __cdecl _heap_alloc_dbg( size_t nSize, int nBlockUse, const char * szFileName, int nLine)
{
return _heap_alloc(nSize);
}
// 64-bit
#ifdef _WIN64
static void * __cdecl realloc_help( void * pUserData, size_t * pnNewSize, int nBlockUse,const char * szFileName,
int nLine, int fRealloc )
{
assert(0); // Shouldn't be needed
return NULL;
}
#else
static void * __cdecl realloc_help( void * pUserData, size_t nNewSize, int nBlockUse, const char * szFileName,
int nLine, int fRealloc)
{
assert(0); // Shouldn't be needed
return NULL;
}
#endif
void __cdecl _free_nolock( void * pUserData)
{
// I don't think the second param is used in memoverride
_free_dbg(pUserData, 0);
}
void __cdecl _free_dbg_nolock( void * pUserData, int nBlockUse)
{
_free_dbg(pUserData, 0);
}
_CRT_ALLOC_HOOK __cdecl _CrtGetAllocHook ( void)
{
assert(0);
return NULL;
}
static int __cdecl CheckBytes( unsigned char * pb, unsigned char bCheck, size_t nSize)
{
int bOkay = TRUE;
return bOkay;
}
_CRT_DUMP_CLIENT __cdecl _CrtGetDumpClient ( void)
{
assert(0);
return NULL;
}
#if _MSC_VER >= 1400
static void __cdecl _printMemBlockData( _locale_t plocinfo, _CrtMemBlockHeader * pHead)
{
}
static void __cdecl _CrtMemDumpAllObjectsSince_stat( const _CrtMemState * state, _locale_t plocinfo)
{
}
#endif
void * __cdecl _aligned_malloc_dbg( size_t size, size_t align, const char * f_name, int line_n)
{
return _aligned_malloc(size, align);
}
void * __cdecl _aligned_realloc_dbg( void *memblock, size_t size, size_t align,
const char * f_name, int line_n)
{
return _aligned_realloc(memblock, size, align);
}
void * __cdecl _aligned_offset_malloc_dbg( size_t size, size_t align, size_t offset,
const char * f_name, int line_n)
{
return _aligned_offset_malloc(size, align, offset);
}
void * __cdecl _aligned_offset_realloc_dbg( void * memblock, size_t size, size_t align,
size_t offset, const char * f_name, int line_n)
{
return _aligned_offset_realloc(memblock, size, align, offset);
}
void __cdecl _aligned_free_dbg( void * memblock)
{
_aligned_free(memblock);
}
size_t __cdecl _CrtSetDebugFillThreshold( size_t _NewDebugFillThreshold)
{
assert(0);
return 0;
}
//===========================================
// NEW!!! 64-bit
char * __cdecl _strdup ( const char * string )
{
int nSize = strlen(string) + 1;
char *pCopy = (char*)AllocUnattributed( nSize );
if ( pCopy )
memcpy( pCopy, string, nSize );
return pCopy;
}
#if 0
_TSCHAR * __cdecl _tfullpath_dbg ( _TSCHAR *UserBuf, const _TSCHAR *path, size_t maxlen, int nBlockUse, const char * szFileName, int nLine )
{
Assert(0);
return NULL;
}
_TSCHAR * __cdecl _tfullpath ( _TSCHAR *UserBuf, const _TSCHAR *path, size_t maxlen )
{
Assert(0);
return NULL;
}
_TSCHAR * __cdecl _tgetdcwd_lk_dbg ( int drive, _TSCHAR *pnbuf, int maxlen, int nBlockUse, const char * szFileName, int nLine )
{
Assert(0);
return NULL;
}
_TSCHAR * __cdecl _tgetdcwd_nolock ( int drive, _TSCHAR *pnbuf, int maxlen )
{
Assert(0);
return NULL;
}
errno_t __cdecl _tdupenv_s_helper ( _TSCHAR **pBuffer, size_t *pBufferSizeInTChars, const _TSCHAR *varname, int nBlockUse, const char * szFileName, int nLine )
{
Assert(0);
return 0;
}
errno_t __cdecl _tdupenv_s_helper ( _TSCHAR **pBuffer, size_t *pBufferSizeInTChars, const _TSCHAR *varname )
{
Assert(0);
return 0;
}
_TSCHAR * __cdecl _ttempnam_dbg ( const _TSCHAR *dir, const _TSCHAR *pfx, int nBlockUse, const char * szFileName, int nLine )
{
Assert(0);
return 0;
}
_TSCHAR * __cdecl _ttempnam ( const _TSCHAR *dir, const _TSCHAR *pfx )
{
Assert(0);
return 0;
}
#endif
wchar_t * __cdecl _wcsdup_dbg ( const wchar_t * string, int nBlockUse, const char * szFileName, int nLine )
{
Assert(0);
return 0;
}
wchar_t * __cdecl _wcsdup ( const wchar_t * string )
{
Assert(0);
return 0;
}
} // end extern "C"
#if _MSC_VER >= 1400
//-----------------------------------------------------------------------------
// XBox Memory Allocator Override
//-----------------------------------------------------------------------------
#if defined( _X360 )
#if defined( _DEBUG ) || defined( USE_MEM_DEBUG )
#include "UtlMap.h"
MEMALLOC_DEFINE_EXTERNAL_TRACKING( XMem );
CThreadFastMutex g_XMemAllocMutex;
void XMemAlloc_RegisterAllocation( void *p, DWORD dwAllocAttributes )
{
if ( !g_pMemAlloc )
{
// core xallocs cannot be journaled until system is ready
return;
}
AUTO_LOCK_FM( g_XMemAllocMutex );
int size = XMemSize( p, dwAllocAttributes );
MemAlloc_RegisterExternalAllocation( XMem, p, size );
}
void XMemAlloc_RegisterDeallocation( void *p, DWORD dwAllocAttributes )
{
if ( !g_pMemAlloc )
{
// core xallocs cannot be journaled until system is ready
return;
}
AUTO_LOCK_FM( g_XMemAllocMutex );
int size = XMemSize( p, dwAllocAttributes );
MemAlloc_RegisterExternalDeallocation( XMem, p, size );
}
#else
#define XMemAlloc_RegisterAllocation( p, a ) ((void)0)
#define XMemAlloc_RegisterDeallocation( p, a ) ((void)0)
#endif
//-----------------------------------------------------------------------------
// XMemAlloc
//
// XBox Memory Allocator Override
//-----------------------------------------------------------------------------
LPVOID WINAPI XMemAlloc( SIZE_T dwSize, DWORD dwAllocAttributes )
{
LPVOID ptr;
XALLOC_ATTRIBUTES *pAttribs = (XALLOC_ATTRIBUTES *)&dwAllocAttributes;
bool bPhysical = ( pAttribs->dwMemoryType == XALLOC_MEMTYPE_PHYSICAL );
if ( !bPhysical && !pAttribs->dwHeapTracksAttributes && pAttribs->dwAllocatorId != eXALLOCAllocatorId_XUI )
{
MEM_ALLOC_CREDIT();
switch ( pAttribs->dwAlignment )
{
case XALLOC_ALIGNMENT_4:
ptr = g_pMemAlloc->Alloc( dwSize );
break;
case XALLOC_ALIGNMENT_8:
ptr = MemAlloc_AllocAligned( dwSize, 8 );
break;
case XALLOC_ALIGNMENT_DEFAULT:
case XALLOC_ALIGNMENT_16:
default:
ptr = MemAlloc_AllocAligned( dwSize, 16 );
break;
}
if ( pAttribs->dwZeroInitialize != 0 )
{
memset( ptr, 0, XMemSize( ptr, dwAllocAttributes ) );
}
return ptr;
}
ptr = XMemAllocDefault( dwSize, dwAllocAttributes );
if ( ptr )
{
XMemAlloc_RegisterAllocation( ptr, dwAllocAttributes );
}
return ptr;
}
//-----------------------------------------------------------------------------
// XMemFree
//
// XBox Memory Allocator Override
//-----------------------------------------------------------------------------
VOID WINAPI XMemFree( PVOID pAddress, DWORD dwAllocAttributes )
{
if ( !pAddress )
{
return;
}
XALLOC_ATTRIBUTES *pAttribs = (XALLOC_ATTRIBUTES *)&dwAllocAttributes;
bool bPhysical = ( pAttribs->dwMemoryType == XALLOC_MEMTYPE_PHYSICAL );
if ( !bPhysical && !pAttribs->dwHeapTracksAttributes && pAttribs->dwAllocatorId != eXALLOCAllocatorId_XUI )
{
switch ( pAttribs->dwAlignment )
{
case XALLOC_ALIGNMENT_4:
return g_pMemAlloc->Free( pAddress );
default:
return MemAlloc_FreeAligned( pAddress );
}
return;
}
XMemAlloc_RegisterDeallocation( pAddress, dwAllocAttributes );
XMemFreeDefault( pAddress, dwAllocAttributes );
}
//-----------------------------------------------------------------------------
// XMemSize
//
// XBox Memory Allocator Override
//-----------------------------------------------------------------------------
SIZE_T WINAPI XMemSize( PVOID pAddress, DWORD dwAllocAttributes )
{
XALLOC_ATTRIBUTES *pAttribs = (XALLOC_ATTRIBUTES *)&dwAllocAttributes;
bool bPhysical = ( pAttribs->dwMemoryType == XALLOC_MEMTYPE_PHYSICAL );
if ( !bPhysical && !pAttribs->dwHeapTracksAttributes && pAttribs->dwAllocatorId != eXALLOCAllocatorId_XUI )
{
switch ( pAttribs->dwAlignment )
{
case XALLOC_ALIGNMENT_4:
return g_pMemAlloc->GetSize( pAddress );
default:
return MemAlloc_GetSizeAligned( pAddress );
}
}
return XMemSizeDefault( pAddress, dwAllocAttributes );
}
#endif // _X360
#define MAX_LANG_LEN 64 /* max language name length */
#define MAX_CTRY_LEN 64 /* max country name length */
#define MAX_MODIFIER_LEN 0 /* max modifier name length - n/a */
#define MAX_LC_LEN (MAX_LANG_LEN+MAX_CTRY_LEN+MAX_MODIFIER_LEN+3)
struct _is_ctype_compatible {
unsigned long id;
int is_clike;
};
typedef struct setloc_struct {
/* getqloc static variables */
char *pchLanguage;
char *pchCountry;
int iLcidState;
int iPrimaryLen;
BOOL bAbbrevLanguage;
BOOL bAbbrevCountry;
LCID lcidLanguage;
LCID lcidCountry;
/* expand_locale static variables */
LC_ID _cacheid;
UINT _cachecp;
char _cachein[MAX_LC_LEN];
char _cacheout[MAX_LC_LEN];
/* _setlocale_set_cat (LC_CTYPE) static variable */
struct _is_ctype_compatible _Lcid_c[5];
} _setloc_struct, *_psetloc_struct;
struct _tiddata {
unsigned long _tid; /* thread ID */
uintptr_t _thandle; /* thread handle */
int _terrno; /* errno value */
unsigned long _tdoserrno; /* _doserrno value */
unsigned int _fpds; /* Floating Point data segment */
unsigned long _holdrand; /* rand() seed value */
char * _token; /* ptr to strtok() token */
wchar_t * _wtoken; /* ptr to wcstok() token */
unsigned char * _mtoken; /* ptr to _mbstok() token */
/* following pointers get malloc'd at runtime */
char * _errmsg; /* ptr to strerror()/_strerror() buff */
wchar_t * _werrmsg; /* ptr to _wcserror()/__wcserror() buff */
char * _namebuf0; /* ptr to tmpnam() buffer */
wchar_t * _wnamebuf0; /* ptr to _wtmpnam() buffer */
char * _namebuf1; /* ptr to tmpfile() buffer */
wchar_t * _wnamebuf1; /* ptr to _wtmpfile() buffer */
char * _asctimebuf; /* ptr to asctime() buffer */
wchar_t * _wasctimebuf; /* ptr to _wasctime() buffer */
void * _gmtimebuf; /* ptr to gmtime() structure */
char * _cvtbuf; /* ptr to ecvt()/fcvt buffer */
unsigned char _con_ch_buf[MB_LEN_MAX];
/* ptr to putch() buffer */
unsigned short _ch_buf_used; /* if the _con_ch_buf is used */
/* following fields are needed by _beginthread code */
void * _initaddr; /* initial user thread address */
void * _initarg; /* initial user thread argument */
/* following three fields are needed to support signal handling and
* runtime errors */
void * _pxcptacttab; /* ptr to exception-action table */
void * _tpxcptinfoptrs; /* ptr to exception info pointers */
int _tfpecode; /* float point exception code */
/* pointer to the copy of the multibyte character information used by
* the thread */
pthreadmbcinfo ptmbcinfo;
/* pointer to the copy of the locale informaton used by the thead */
pthreadlocinfo ptlocinfo;
int _ownlocale; /* if 1, this thread owns its own locale */
/* following field is needed by NLG routines */
unsigned long _NLG_dwCode;
/*
* Per-Thread data needed by C++ Exception Handling
*/
void * _terminate; /* terminate() routine */
void * _unexpected; /* unexpected() routine */
void * _translator; /* S.E. translator */
void * _purecall; /* called when pure virtual happens */
void * _curexception; /* current exception */
void * _curcontext; /* current exception context */
int _ProcessingThrow; /* for uncaught_exception */
void * _curexcspec; /* for handling exceptions thrown from std::unexpected */
#if defined (_M_IA64) || defined (_M_AMD64)
void * _pExitContext;
void * _pUnwindContext;
void * _pFrameInfoChain;
unsigned __int64 _ImageBase;
#if defined (_M_IA64)
unsigned __int64 _TargetGp;
#endif /* defined (_M_IA64) */
unsigned __int64 _ThrowImageBase;
void * _pForeignException;
#elif defined (_M_IX86)
void * _pFrameInfoChain;
#endif /* defined (_M_IX86) */
_setloc_struct _setloc_data;
void * _encode_ptr; /* EncodePointer() routine */
void * _decode_ptr; /* DecodePointer() routine */
void * _reserved1; /* nothing */
void * _reserved2; /* nothing */
void * _reserved3; /* nothing */
int _cxxReThrow; /* Set to True if it's a rethrown C++ Exception */
unsigned long __initDomain; /* initial domain used by _beginthread[ex] for managed function */
};
typedef struct _tiddata * _ptiddata;
class _LocaleUpdate
{
_locale_tstruct localeinfo;
_ptiddata ptd;
bool updated;
public:
_LocaleUpdate(_locale_t plocinfo)
: updated(false)
{
/*
if (plocinfo == NULL)
{
ptd = _getptd();
localeinfo.locinfo = ptd->ptlocinfo;
localeinfo.mbcinfo = ptd->ptmbcinfo;
__UPDATE_LOCALE(ptd, localeinfo.locinfo);
__UPDATE_MBCP(ptd, localeinfo.mbcinfo);
if (!(ptd->_ownlocale & _PER_THREAD_LOCALE_BIT))
{
ptd->_ownlocale |= _PER_THREAD_LOCALE_BIT;
updated = true;
}
}
else
{
localeinfo=*plocinfo;
}
*/
}
~_LocaleUpdate()
{
// if (updated)
// ptd->_ownlocale = ptd->_ownlocale & ~_PER_THREAD_LOCALE_BIT;
}
_locale_t GetLocaleT()
{
return &localeinfo;
}
};
#pragma warning(push)
#pragma warning(disable: 4483)
#if _MSC_FULL_VER >= 140050415
#define _NATIVE_STARTUP_NAMESPACE __identifier("<CrtImplementationDetails>")
#else /* _MSC_FULL_VER >= 140050415 */
#define _NATIVE_STARTUP_NAMESPACE __CrtImplementationDetails
#endif /* _MSC_FULL_VER >= 140050415 */
namespace _NATIVE_STARTUP_NAMESPACE
{
class NativeDll
{
private:
static const unsigned int ProcessDetach = 0;
static const unsigned int ProcessAttach = 1;
static const unsigned int ThreadAttach = 2;
static const unsigned int ThreadDetach = 3;
static const unsigned int ProcessVerifier = 4;
public:
inline static bool IsInDllMain()
{
return false;
}
inline static bool IsInProcessAttach()
{
return false;
}
inline static bool IsInProcessDetach()
{
return false;
}
inline static bool IsInVcclrit()
{
return false;
}
inline static bool IsSafeForManagedCode()
{
if (!IsInDllMain())
{
return true;
}
if (IsInVcclrit())
{
return true;
}
return !IsInProcessAttach() && !IsInProcessDetach();
}
};
}
#pragma warning(pop)
#endif // _MSC_VER >= 1400
#endif // !STEAM && !NO_MALLOC_OVERRIDE
#endif // _WIN32
| [
"[email protected]"
]
| [
[
[
1,
1380
]
]
]
|
39e7e37ecff5c2a08739acfc4a38fd29f11ce160 | 3449de09f841146a804930f2a51ccafbc4afa804 | /C++/FluidSystem/src/excel10.cpp | d31417a62f0459568413dd3a70722a8296d9c14b | []
| no_license | davies/daviescode | 0c244f4aebee1eb909ec3de0e4e77db3a5bbacee | bb00ee0cfe5b7d5388485c59211ebc9ba2d6ecbd | refs/heads/master | 2020-06-04T23:32:27.360979 | 2007-08-19T06:31:49 | 2007-08-19T06:31:49 | 32,641,672 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 199,125 | cpp | // Machine generated IDispatch wrapper class(es) created with ClassWizard
#include "stdafx.h"
#include "excel10.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
using namespace EXCEL10;
/////////////////////////////////////////////////////////////////////////////
// _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;
}
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;
}
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;
}
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);
}
long _Application::GetMemoryFree()
{
long result;
InvokeHelper(0x172, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long _Application::GetMemoryTotal()
{
long result;
InvokeHelper(0x173, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long _Application::GetMemoryUsed()
{
long result;
InvokeHelper(0x174, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
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::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);
}
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);
}
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);
}
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::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;
}
/////////////////////////////////////////////////////////////////////////////
// _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);
}
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;
}
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);
}
/////////////////////////////////////////////////////////////////////////////
// _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);
}
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;
}
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);
}
/////////////////////////////////////////////////////////////////////////////
// _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);
}
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;
}
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);
}
/////////////////////////////////////////////////////////////////////////////
// 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)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_VARIANT;
InvokeHelper(0x817, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Filename, &Stylesheets);
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& Font, 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, &Font, &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;
}
/////////////////////////////////////////////////////////////////////////////
// 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);
}
/////////////////////////////////////////////////////////////////////////////
// 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);
}
/////////////////////////////////////////////////////////////////////////////
// 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);
}
| [
"davies.liu@32811f3b-991a-0410-9d68-c977761b5317"
]
| [
[
[
1,
7664
]
]
]
|
d1c802816b84982a31d90fee8101fa0e0ef8121a | 1fe913f8627e94f337ce120c23423a614367dbf5 | /03_VarArgsPratice/C test/20091216/3p2.cpp | 52dfbe684d2ef792eafce92aa934b7e0dfb684bf | []
| no_license | jayska/Programming | 9abbbf70a85a1c90496fbf5da0b0461675da9f8c | a744da5ed9b7f266f130d2ea350cc376a74aa49f | refs/heads/master | 2021-01-20T11:24:56.280316 | 2010-01-02T03:45:04 | 2010-01-02T03:45:04 | null | 0 | 0 | null | null | null | null | BIG5 | C++ | false | false | 1,196 | cpp | #include <stdio.h>
#include <stdlib.h>
int len(int La, int Lb)
{
int Len = La - Lb;
return (0 <= Len) ? Len : -(Len);
}
int main()
{
int Iax = 0;
int Iay = 0;
int Ibx = 0;
int Iby = 0;
int LenX = 0;
int LenY = 0;
printf("請輸入one pointer(x1,y1):\n");
//scanf("%d %d", &Iax, &Iay);
printf("x1=");
scanf("%d", &Iax);
printf("y1=");
scanf("%d", &Iay);
printf("請輸入two pointer(x2,y2):\n");
//scanf("%d %d", &Ibx, &Iby);
printf("x2=");
scanf("%d", &Ibx);
printf("y2=");
scanf("%d", &Iby);
LenX = len(Iax, Ibx);
LenY = len(Iay, Iby);
//LenX = ((Iax - Ibx) >= 0) ? (Iax -Ibx) : -(Iax - Ibx);
//LenY = ((Iay - Iby) >= 0) ? (Iay - Iby) : -(Iay - Iby);
if (LenX == 0 || LenY == 0) printf("enter error!\n");
else if (LenX == LenY) printf("正方形!\n");
else printf("長方形!\n");
/*if (len(Iax, Ibx) <= 0 || len(Iay, Iby) <= 0) printf("輸入錯誤\n");
else if (len(Iax, Ibx) == len(Iay, Iby)) printf("此為正方形\n");
else printf("此為長方形\n");*/
/*if ((Iax - Ibx) == (Iay - Iby))
{
printf("此為正方形\n");
} else {
printf("此為長方形\n");
}*/
system("PAUSE");
return 0;
} | [
"[email protected]"
]
| [
[
[
1,
52
]
]
]
|
25588f620423da884c3a5503a28e41199bc4506f | ea613c6a4d531be9b5d41ced98df1a91320c59cc | /7-Zip/CPP/7zip/Archive/Wim/WimRegister.cpp | 9ae27625bda527b9ae44e2285f569c89ed5147c9 | []
| no_license | f059074251/interested | 939f938109853da83741ee03aca161bfa9ce0976 | b5a26ad732f8ffdca64cbbadf9625dd35c9cdcb2 | refs/heads/master | 2021-01-15T14:49:45.217066 | 2010-09-16T10:42:30 | 2010-09-16T10:42:30 | 34,316,088 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 334 | cpp | // WimRegister.cpp
#include "StdAfx.h"
#include "../../Common/RegisterArc.h"
#include "WimHandler.h"
static IInArchive *CreateArc() { return new NArchive::NWim::CHandler; }
static CArcInfo g_ArcInfo =
{ L"Wim", L"wim swm", 0, 0xE6, { 'M', 'S', 'W', 'I', 'M', 0, 0, 0 }, 8, false, CreateArc, 0 };
REGISTER_ARC(Wim)
| [
"[email protected]@8d1da77e-e9f6-11de-9c2a-cb0f5ba72f9d"
]
| [
[
[
1,
13
]
]
]
|
ff1d3b02d8d8831eea135b4596245edda0902cb7 | 56c17f756480a02c77aecc69b217c29294f4c180 | /Src/Libs/Rastering/FontView.cpp | 022c1ee47c63c97b47e10e704dfa1b61e66cc23e | []
| no_license | sangongs/qbert3d | 5fd88b9720b68ca7617a8c5510568911b3dc34c5 | 296b78451b73032e16e64ae1cc4f0200ef7ca734 | refs/heads/master | 2021-01-10T04:02:37.685309 | 2008-09-12T16:13:04 | 2008-09-12T16:13:04 | 46,944,626 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,559 | cpp | #include "StdAfx.h"
#include <SDL\SDL.h>
#include <SDL\SDL_opengl.h>
#include <SDL\SDL_TTF.h>
#include "MathUtils.h"
#include "FontView.h"
namespace BGComplete
{
FontView::FontView(const std::string& fileName, unsigned fontSize) : _texture(0)
{
if (TTF_Init())
throw std::exception("Can't intilize SDL_TTF");
_font = FontEncapsulator_Ptr(new FontEncapsulator(fileName, fontSize));
}
FontView::~FontView()
{
if (_texture)
{
glFinish();
glDeleteTextures(1, &_texture);
}
}
void FontView::CameraMove(float /*deltaX*/, float /*deltaY*/, float /*deltaZ*/, float /*xRotate*/, float /*yRotate*/, float /*zRotate*/, char /*viewKey*/){}
void FontView::Init(){}
void FontView::SetText(const std::string& text, unsigned char r, unsigned char g, unsigned char b, float* points)
{
if (_texture)
{
glFinish();
glDeleteTextures(1, &_texture);
}
if (points == 0)
_fitView = true;
else
{
memcpy(_quadPoints, points, sizeof(float) * 12);
_fitView = false;
}
SDL_Color color = {r, g, b, 0};
SDL_Surface *firstText = TTF_RenderText_Blended(_font->Font, text.c_str(), color );
_clip.Points[0] = (float)firstText->w / (float)Math::NextPowerOfTwo(firstText->w);
_clip.Points[1] = (float)firstText->h / (float)Math::NextPowerOfTwo(firstText->h);
SDL_Surface *intermediary = SDL_CreateRGBSurface(0, Math::NextPowerOfTwo(firstText->w), Math::NextPowerOfTwo(firstText->h), 32,
0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
SDL_BlitSurface(firstText, 0, intermediary, 0);
glGenTextures( 1, &_texture );
glBindTexture( GL_TEXTURE_2D, _texture);
glTexImage2D( GL_TEXTURE_2D, 0, 4, intermediary->w, intermediary->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, intermediary->pixels );
SDL_FreeSurface(firstText);
SDL_FreeSurface(intermediary);
}
void FontView::Draw(bool clearAndSwap, unsigned startX, unsigned startY, unsigned width, unsigned height)
{
if (clearAndSwap)
{
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glViewport(startX, startY, width, height);
glBindTexture( GL_TEXTURE_2D, _texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glEnable(GL_TEXTURE_2D);
glColor3f(1.0f, 1.0f, 1.0f);
glDisable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glFrustum(-(float)width / 2.0f, (float)width / 2.0f, -(float)height / 2.0f, (float)height / 2.0f, 1.0f, 1000.0f);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glBlendFunc(GL_ONE, GL_ONE);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBegin(GL_QUADS);
if (_fitView)
{
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-(float)width * 0.5f, (float)height * 0.5f, -1.0f);
glTexCoord2f(_clip.Points[0], 0.0f);
glVertex3f((float)width * 0.5f, (float)height * 0.5f, -1.0f);
glTexCoord2f(_clip.Points[0], _clip.Points[1]);
glVertex3f((float)width * 0.5f, -(float)height * 0.5f, -1.0f);
glTexCoord2f(0.0f, _clip.Points[1]);
glVertex3f(-(float)width * 0.5f, -(float)height * 0.5f, -1.0f);
}
else
{
glTexCoord2f(0.0f, 0.0f);
glVertex3fv(_quadPoints);
glTexCoord2f(_clip.Points[0], 0.0f);
glVertex3fv(_quadPoints + 3);
glTexCoord2f(_clip.Points[0], _clip.Points[1]);
glVertex3fv(_quadPoints + 6);
glTexCoord2f(0.0f, _clip.Points[1]);
glVertex3fv(_quadPoints + 9);
}
glEnd();
glDisable(GL_BLEND);
if (clearAndSwap)
SDL_GL_SwapBuffers();
}
} | [
"haimbender@97581c8e-fe54-0410-aa42-dd6ba39e7182"
]
| [
[
[
1,
129
]
]
]
|
b5e2d3512f7ffc72b00ccc430bc996c28140b96a | 555ce7f1e44349316e240485dca6f7cd4496ea9c | /DirectShowFilters/shared/DvbUtil.h | 767ac77508f1a4e52bba8fd573865d102f3680c4 | []
| no_license | Yura80/MediaPortal-1 | c71ce5abf68c70852d261bed300302718ae2e0f3 | 5aae402f5aa19c9c3091c6d4442b457916a89053 | refs/heads/master | 2021-04-15T09:01:37.267793 | 2011-11-25T20:02:53 | 2011-11-25T20:11:02 | 2,851,405 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,077 | h | /*
* Copyright (C) 2006-2008 Team MediaPortal
* http://www.team-mediaportal.com
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#pragma once
DWORD crc32 (char *data, int len);
class CDvbUtil
{
public:
CDvbUtil(void);
void getString468A(BYTE *buf, int bufLen, char *text, int textLen);
public:
virtual ~CDvbUtil(void);
};
| [
"[email protected]",
"[email protected]"
]
| [
[
[
1,
28
],
[
30,
32
]
],
[
[
29,
29
]
]
]
|
cbaefc1f6e25a6afd2deff181f9ffd42a3534174 | 1e90ca0380b31edfa5bd00307e802d8bb5aaa817 | /ogl_learning/ogl_learning/test.cpp | 896dde8cfc862a80227f284ee76fffaf1ea517a1 | []
| no_license | vanish87/my-opengl-ge | e89cc31816357f83caaddd153ed3bd99d1cc15a1 | 6c3340a8f5219dbbb6a2ece80d867bc751509c0d | refs/heads/master | 2021-01-23T22:39:38.669472 | 2011-01-14T12:26:53 | 2011-01-14T12:26:53 | 32,132,332 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 169 | cpp | #include "StdAfx.h"
#include "test.h"
test::test(void)
{
a=100;
b=false;
}
test::~test(void)
{
}
void test::test1()
{
a++;
if(!b)
a++;
}
| [
"vanish8.7@7f91644b-6a5f-28f5-645b-ee1a16f7b3bf"
]
| [
[
[
1,
21
]
]
]
|
df60185f3f4245b58da27adf44eae376e5d295b8 | d1ea218c71be93ffd47242279b21acc7e6c60b87 | /Recognizer/serial_bluetooth.cpp | a0c22850f0b862723c2c23b3ab0f4c2022108ea6 | []
| no_license | habs57/tablet-interaction | 7e0001e8a88ba705e7a116bcc7a1402887991e8e | 1dcf74804ca7473e7997465fa6d3a19375d3da26 | refs/heads/master | 2021-01-23T12:32:04.293638 | 2011-01-22T11:00:39 | 2011-01-22T11:00:39 | 40,707,478 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 3,669 | cpp | #include <Windows.h>
#include <stdio.h>
#include <commctrl.h>
#include "recognizer.h"
#include "resource.h"
extern HWND hWnd;
extern int Sending_flag;
HANDLE hFile;
HANDLE g_handle;
void sneding_value(unsigned int val);
DWORD WINAPI RecvData( VOID * dummy );
struct coordinate
{
short X;
short reserved;
};
BOOL Open()
{
HWND hCombo2;
char str[6];
int i;
DWORD nThreadId;
hCombo2 = GetDlgItem(hWnd, IDC_COM_PORT);
i = SendMessage(hCombo2, CB_GETCURSEL, 0, 0);
SendMessage(hCombo2, CB_GETLBTEXT, i, (LPARAM)str);
// 컴포트 열기
hFile = CreateFile(str,
GENERIC_READ | GENERIC_WRITE,
0, // 비공유
0, // 시큐리티 속성:사용안함
OPEN_EXISTING, // 기존 파일 오픈
0, 0 ); // 속성, 템플레이트
if(hFile == INVALID_HANDLE_VALUE)
MessageBox(0, "Can't Open COM port!","Caution", MB_ICONERROR);
DCB dcb;
// 지정한 통신 디바이스의 현재 DCB 설정 얻기
// DCB : Device Control Block 디바이스 제어 블럭
GetCommState(hFile , &dcb);
// 설정을 변경할 때는 코드 추가
// :
// DCB의 지정에 따라 통신 디바이스 구성
// 하드웨어와 제어 설정 초기화
SetCommState(hFile , &dcb);
// wsprintf(szBuffer, "BaudRate %d : ByteSize %d", dcb.BaudRate, dcb.ByteSize);
// 다이알로그박스 캡션에 BaudRate:ByteSize 사이즈 표시
// SetWindowText(hWnd, szBuffer);
COMMTIMEOUTS cTimeout;
// 현재 설정중인 타임아웃 자료 얻기
//GetCommTimeouts(hFile, &cTimeout);
cTimeout.ReadIntervalTimeout = 1000;
cTimeout.ReadTotalTimeoutMultiplier = 0;
cTimeout.ReadTotalTimeoutConstant = 1000;
cTimeout.WriteTotalTimeoutMultiplier = 0;
cTimeout.WriteTotalTimeoutConstant = 0;
SetCommTimeouts(hFile, &cTimeout);
// CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RecvData, NULL, 0, &nThreadId);
CloseHandle(g_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RecvData, NULL, 0, &nThreadId));
return TRUE;
}
DWORD WINAPI RecvData( VOID * dummy )
{
DWORD dwByte;
char szRecv[2];
char recv_ch;
char Buffer[5];
int buf_cnt = 0;
int ch;
int i;
int nRet;
HWND hListCrl;
char tmp[25];
char str[50];
struct coordinate * data;
int cnt = 0;
LVITEM LI;
LI.mask = LVIF_TEXT;
hListCrl = GetDlgItem(hWnd, IDC_LIST_CONTROL);
while(1)
{
nRet = ReadFile(hFile, szRecv, 1, &dwByte, 0);
if(dwByte == 1)
{
recv_ch = szRecv[0];
szRecv[1] = 0;
// MessageBox(hWnd,(LPCSTR)szRecv, (LPCSTR)"Error", MB_OK);
if(recv_ch == '#' )
{
//MessageBox(hWnd,(LPCSTR)szRecv, (LPCSTR)"Error", MB_OK);
//ReadFile(hFile, szRecv, 1, &dwByte, 0);
//recv_ch = szRecv[0];
//szRecv[1] = 0;
break;
}
}
}
while(243){
if(Sending_flag == 0)
{
CloseHandle(hFile);
return 0;
}
// 한 문자 수신
nRet = ReadFile(hFile, szRecv, 1, &dwByte, 0);
// ReadFile()은 성공하면 0이외를 반환, 타임아웃도 성공
if(dwByte == 1)
{
ch = szRecv[0];
Buffer[buf_cnt] = ch;
if(buf_cnt == 4)
{
int val;
Buffer[4] = 0;
sprintf(tmp, "%s", Buffer);
LI.pszText = tmp;
SetDlgItemText(hWnd, IDC_EDIT1, tmp);
val = atoi(Buffer);
//if(cnt%20 == 0)
sneding_value(val);
cnt++;
buf_cnt = 0;
for(i = 0 ; i < 5 ; i++)
{
Buffer[i] = NULL;
}
} else
buf_cnt++;
}
}
return 0;
} | [
"khkwak243@001af8ad-599a-f9f0-d94e-71ba1c934c06"
]
| [
[
[
1,
178
]
]
]
|
c836d77a655e0e3295cd32181db39636072fd754 | be2e23022d2eadb59a3ac3932180a1d9c9dee9c2 | /GameServer/MapGroupKernel/Magic_Process.cpp | fcf082b57e4752a8a11fc93d5cfd28da2d20a8a2 | []
| no_license | cronoszeu/revresyksgpr | 78fa60d375718ef789042c452cca1c77c8fa098e | 5a8f637e78f7d9e3e52acdd7abee63404de27e78 | refs/heads/master | 2020-04-16T17:33:10.793895 | 2010-06-16T12:52:45 | 2010-06-16T12:52:45 | 35,539,807 | 0 | 2 | null | null | null | null | GB18030 | C++ | false | false | 95,313 | cpp | #include "AllMsg.h"
#include "GameObj.h"
#include "Magic.h"
#include "MapGroup.h"
#include "StatusOnce.h"
#include "StatusMore.h"
#include "MapTrap.h"
#include "Npc.h"
/*/ 4超级的特殊状态，及超级回复
3500 3500 0002 回复术
3501 3501 0006 钢铁皮肤
3502 3502 0006 魔法护盾
3503 3503 0006 神圣祈祷
3504 3504 0006 魔力加持
*/
const int SUPER_MAGIC_RECRUIT = 3500;
const int SUPER_MAGIC_DEFENCE = 3501;
const int SUPER_MAGIC_MGC_DEFENCE = 3502;
const int SUPER_MAGIC_ATTACK = 3503;
const int SUPER_MAGIC_MGC_ATTACK = 3504;
const int THROW_WEAPON_DROP_RANGE = 1; // 扔武器攻击可掉物品的范围
void MovePos(POINT* pPos, int nDir)
{
nDir %= 8;
pPos->x += _DELTA_X[nDir];
pPos->y += _DELTA_X[nDir];
}
void DDALine(int x0, int y0, int x1, int y1, int nRange, vector<POINT>& vctPoint)
{
if (x0 == x1 && y0 == y1)
return;
float scale = 1.0f*nRange/sqrt((float)(x1-x0)*(x1-x0)+(y1-y0)*(y1-y0));
x1 = int(0.5f+scale*(x1-x0)+x0);
y1 = int(0.5f+scale*(y1-y0)+y0);
::DDALineEx(x0, y0, x1, y1, vctPoint);
}
// launch
int CMagic::Launch()
{
if(!m_pMagic)
return 0;
if(!m_pOwner->IsAlive())
{
ShowMiss();
return 0;
}
int ret = 0;
switch(m_pMagic->GetInt(MAGICDATA_SORT))
{
case MAGICSORT_ATTACK:
ret = ProcessAttack();
break;
case MAGICSORT_RECRUIT:
ret = ProcessRecruit();
break;
case MAGICSORT_CROSS:
ret = ProcessCross();
break;
case MAGICSORT_LINE:
case MAGICSORT_LINE_PENETRABLE:
ret = ProcessLine();
break;
case MAGICSORT_FAN:
ret = ProcessFan();
break;
case MAGICSORT_BOMB:
ret = ProcessBomb();
break;
case MAGICSORT_BOMB_LOCKALL:
ret = ProcessBombLockAll();
break;
case MAGICSORT_ATTACHSTATUS:
case MAGICSORT_TEAM_MAGIC:
ret = ProcessAttach();
break;
case MAGICSORT_DETACHSTATUS:
ret = ProcessDetach();
break;
case MAGICSORT_SQUARE:
ret = ProcessSquare();
break;
case MAGICSORT_JUMPATTACK:
ret = ProcessJumpAtk();
break;
case MAGICSORT_RANDOMTRANS:
ret = ProcessRandomTrans();
break;
case MAGICSORT_DISPATCHXP:
ret = ProcessDispatchXP();
break;
case MAGICSORT_COLLIDE:
ret = ProcessCollide();
break;
case MAGICSORT_ATKSTATUS:
ret = ProcessAtkStatus();
break;
case MAGICSORT_CALLTEAMMEMBER:
ret = ProcessCallTeamMember();
break;
case MAGICSORT_RECORDTRANSSPELL:
ret = ProcessRecordTransSpell();
break;
case MAGICSORT_TRANSFORM:
ret = ProcessTransform();
break;
case MAGICSORT_ADDMANA:
ret = ProcessAddMana();
break;
case MAGICSORT_LAYTRAP:
ret = ProcessLayTrap();
break;
case MAGICSORT_CALLPET:
ret = ProcessCallPet();
break;
case MAGICSORT_DECLIFE:
ret = ProcessDecLife();
break;
case MAGICSORT_GROUNDSTING:
ret = ProcessGroundSting();
break;
case MAGICSORT_REBORN:
ret = ProcessReborn();
break;
case MAGICSORT_SORB_SOUL:
ret = ProcessSorbSoul();
break;
case MAGICSORT_STEAL:
ret = ProcessSteal();
break;
/////////////////////////////////////////////////
// 新增幻兽魔法类型
case MAGICSORT_BLAST_THUNDER:
ret = ProcessBlastThunder();
break;
case MAGICSORT_MULTI_ATTACHSTATUS:
ret = ProcessMultiAttach();
break;
case MAGICSORT_MULTI_DETACHSTATUS:
ret = ProcessMultiDetach();
break;
case MAGICSORT_MULTI_CURE:
ret = ProcessMultiCure();
break;
case MAGICSORT_STEAL_MONEY:
ret = ProcessStealMoney();
break;
case MAGICSORT_KO:
ret = ProcessKO();
break;
case MAGICSORT_ESCAPE:
ret = ProcessEscape();
break;
/////////////////////////////////////////////////
default:
ASSERT(!"switch magic sort");
}
return ret;
}
// magic process
bool CMagic::ProcessAttack()
{
CHECKF(m_pMagic);
CHECKF(m_pOwner);
/*
// check syn of user
if (!m_pOwner->SynPosition(m_pos.x, m_pos.y))
{
UserManager()->KickOutSocket(m_pOwner->GetSocketID(), "SynPosition");
return false;
}
*/
m_setTargetLocked.clear();
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
// if(m_pOwner->GetDistance(pTarget->GetPosX(), pTarget->GetPosY()) > m_pMagic->GetInt(MAGICDATA_DISTANCE))
// return false;
if (this->IsImmunity(pTarget))
return false;
if (m_pMagic->GetInt(MAGICDATA_FLOOR_ATTR)) // 0: need not check
{
int nAttr = m_pOwner->GetMap()->GetFloorAttr(pTarget->GetPosX(), pTarget->GetPosY());
if(m_pMagic->GetInt(MAGICDATA_FLOOR_ATTR) != nAttr)
return false;
}
m_setTargetLocked.push_back(pTarget->GetID());
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true);
int nTotalExp = 0;
for (int k=0; k<m_nApplyTimes; k++)
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pTarget, GetPower(k));
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
CheckCrime(pTarget);
if (nPower)
{
int nLifeLost = nPower;
if (pTarget->TransferShield(HitByMagic(), m_pOwner, nPower))
{
}
else
{
nLifeLost = __min(pTarget->GetLife(), nPower);
pTarget->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
pTarget->BeAttack(HitByMagic(), m_pOwner, nPower);
}
nTotalExp += nLifeLost;
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPower, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
}
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k);
}
if (nTotalExp > 0)
AwardExpOfLife(pTarget, nTotalExp);
m_pos.x = pTarget->GetPosX();
m_pos.y = pTarget->GetPosY();
// if (!pTarget->IsAlive())
// m_pOwner->Kill(pTarget, GetDieMode());
//? 未增加武器熟练度，也未损耗双方装备。
// drop weapon in weapon skill
if(m_pMagic->GetInt(MAGICDATA_USE_XP) == TYPE_KONGFU && m_pMagic->GetInt(MAGICDATA_DROPWEAPON) == THROW_WERPONR_TARGET)
{
CItem* pWeapon = m_pOwner->GetWeaponR();
IF_OK(pWeapon)
{
POINT pos;
pos.x = pTarget->GetPosX();
pos.y = pTarget->GetPosY();
m_pOwner->GetMap()->FindDropItemCell(THROW_WEAPON_DROP_RANGE, &pos);
m_pOwner->DropItem(pWeapon->GetID(), pos.x, pos.y); // 没找到CELL也扔，但会重叠。
}
}
return true;
}
bool CMagic::ProcessAtkStatus()
{
CHECKF(m_pMagic);
// vector<OBJID> setLastLocked;
// if (!m_setTargetLocked.empty())
// copy(m_setTargetLocked.begin(), m_setTargetLocked.end(), back_inserter(setLastLocked));
m_setTargetLocked.clear();
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
// if(m_pOwner->GetDistance(pTarget->GetPosX(), pTarget->GetPosY()) > m_pMagic->GetInt(MAGICDATA_DISTANCE))
// return false;
if (this->IsImmunity(pTarget))
return false;
// m_setTargetLocked.push_back(pTarget->GetID());
int nPower = 0;
bool bAttachStatus = false;
int nStatusPower = 0;
int nSecs = 0;
int nTimes = 0;
DWORD nStatus = 0;
if(HitByWeapon()) // && !CBattleSystem::IsTargetDodged(m_pOwner, pTarget))
{
int nAdjust = 0;
switch(m_pMagic->GetInt(MAGICDATA_STATUS))
{
case STATUS_ATTACK:
{
int nAdjustAtk = GetPower();
nPower = CBattleSystem::CalcAttackPower(m_pOwner, pTarget, &nAdjustAtk, 0);
}
break;
case STATUS_DEFENCE1:
case STATUS_DEFENCE2:
case STATUS_DEFENCE3:
{
int nAdjustDef = GetPower();
nPower = CBattleSystem::CalcAttackPower(m_pOwner, pTarget, 0, &nAdjustDef);
}
break;
// case STATUS_WEAPONDAMAGE:
// {
// int nAdjustDmg = GetPower();
// nPower = CBattleSystem::CalcAttackPower(m_pOwner, pTarget);
// nPower = ::CutRange(m_pOwner->AdjustData(nPower, nAdjustDmg, pTarget->GetLife()), 0, (int)pTarget->GetMaxLife()*9/10);
// }
// break;
case STATUS_ATKSPEED:
{
int nPause = GetPower();
nPower = CBattleSystem::CalcAttackPower(m_pOwner, pTarget);
pTarget->SetFightPause(nPause);
}
break;
// 根据策划要求，取消这个状态以避免MAGICDATA_PERCENT的使用冲突
// case STATUS_STOP:
// {
// int nAdjustAtk = GetPower();
// int nMilliSecs = m_pMagic->GetInt(MAGICDATA_STEP);
// nPower = CBattleSystem::CalcAttackPower(m_pOwner, pTarget, &nAdjustAtk);
// if(pTarget->IsMonster() && ::RandGet(100) < m_pMagic->GetInt(MAGICDATA_PERCENT))
// {
// CMsgAction msg;
// IF_OK(msg.Create(pTarget->GetID(), pTarget->GetPosX(), pTarget->GetPosY(), pTarget->GetDir(), actionMoveStop, nMilliSecs))
// pTarget->SendMsg(&msg);
// }
// }
// break;
case STATUS_VAMPIRE:
{
int nAdjustAtk = GetPower();
int nAwardPercent = m_pMagic->GetInt(MAGICDATA_WIDTH);
CHECKF(nAwardPercent >= 0 && nAwardPercent <= 100);
nPower = CBattleSystem::CalcAttackPower(m_pOwner, pTarget, &nAdjustAtk);
int nAddLife = MulDiv(::CutTrail((int)pTarget->GetLife(), nPower), nAwardPercent, 100);
if(nAddLife > 0 && m_pOwner->GetLife() < m_pOwner->GetMaxLife() && m_pOwner->IsAlive())
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nAddLife, UPDATE_TRUE);
}
break;
case STATUS_NORMAL:
break;
default: // other status
{
if (::RandGet(100) < m_pMagic->GetInt(MAGICDATA_STATUS_CHANCE))
{
bAttachStatus = true;
nStatusPower = GetPower();
nSecs = m_pMagic->GetInt(MAGICDATA_STEP);
nTimes = m_pMagic->GetInt(MAGICDATA_TIMES);
nStatus = m_pMagic->GetInt(MAGICDATA_STATUS);
ASSERT(nStatusPower > 0);
// CRole::AttachStatus(pTarget, nStatus, nStatusPower, nSecs, nTimes);
}
nPower = CBattleSystem::CalcAttackPower(m_pOwner, pTarget);
}
break;
}
}
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
CheckCrime(pTarget);
if (nPower)
{
CNpc* pNpc = NULL;
int nLifeLost = nPower;
if (pTarget->TransferShield(HitByMagic(), m_pOwner, nPower))
{
}
else
{
nLifeLost = __min(pTarget->GetLife(), nPower);
pTarget->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
CUser* pTargetUser=NULL;
if(pTarget->QueryObj(OBJ_USER, IPP_OF(pTargetUser)))
pTargetUser->BroadcastTeamLife();
if(pTarget->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
pTarget->BeAttack(HitByMagic(), m_pOwner, nPower);
}
int nExp = 0;
if (pTarget->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += m_pOwner->AdjustExp(pTarget, nLifeLost);
if (!pTarget->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = pTarget->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(pTarget, nBonusExp);
nExp += m_pOwner->AdjustExp(pTarget, nBonusExp, true);
}
}
// 必须在分配组队经验之后杀死
if (!pTarget->IsAlive())
m_pOwner->Kill(pTarget, GetDieMode());
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPower, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
this->AwardExp(nExp);
}
// 把原来的先加状态后算攻击修改为先算攻击后加状态
// 原因是例如冰冻之类的魔法会在BeAttack的时候解除，因此必须在BeAttack之后调用加状态
if (bAttachStatus)
{
if(pTarget->IsAlive())
CRole::AttachStatus(pTarget, nStatus, nStatusPower, nSecs, nTimes);
}
//? 未增加武器熟练度，也未损耗双方装备。
return true;
}
bool CMagic::ProcessRecruit()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
vector<IRole*> setRole;
vector<int> setPower;
CTeam* pTeam = m_pOwner->GetTeam();
if(pTeam && m_pMagic->GetInt(MAGICDATA_MULTI))
{
for(int i = 0; i < pTeam->GetMemberAmount(); i++)
{
OBJID idTarget = pTeam->GetMemberByIndex(i);
IRole* pRole = m_pOwner->FindAroundRole(idTarget);
CNpc* pNpc;
if(!pRole || !pRole->IsAlive() || pRole->QueryObj(OBJ_NPC, IPP_OF(pNpc)))
continue;
setRole.push_back(pRole);
if (m_pOwner->GetID() != pRole->GetID())
m_setTargetLocked.push_back(pRole->GetID());
}
}
else
{
IRole* pRole = m_pOwner->FindAroundRole(m_idTarget);
if(!pRole || !pRole->IsAlive())
return false;
setRole.push_back(pRole);
m_setTargetLocked.push_back(pRole->GetID());
}
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true);
int nExp = 0;
for (int k=0; k<m_nApplyTimes; k++)
{
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = GetPower(k);
if (nPower == ADJUST_FULL)
nPower = pRole->GetMaxLife() - pRole->GetLife();
// 超级回复
if(m_pMagic && m_pMagic->GetInt(MAGICDATA_TYPE)>=SUPER_MAGIC_RECRUIT)
nPower *= m_pOwner->GetSoulSum();
setPower.push_back(nPower);
msg.AppendRole(setRole[i]->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
for(int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
int nAddLife = ::CutOverflow(setPower[i], ::CutTrail(0, (int)(setRole[i]->GetMaxLife()-setRole[i]->GetLife())));
if(nAddLife > 0)
{
setRole[i]->AddAttrib(_USERATTRIB_LIFE, nAddLife, SYNCHRO_TRUE);
CUser* pUser=NULL;
if(setRole[i]->QueryObj(OBJ_USER, IPP_OF(pUser)))
pUser->BroadcastTeamLife();
}
CNpc* pNpc = NULL;
if (setRole[i])
{
setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc));
if(pNpc && pNpc->IsGoal())
{
nAddLife = nAddLife*GOAL_EXP_PERCENT/100;
}
}
nExp += nAddLife;
}
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k);
}
this->AwardExp(0);
return true;
}
bool CMagic::ProcessCross()
{
CHECKF(m_pMagic);
int nRange1 = m_pMagic->GetInt(MAGICDATA_RANGE) % 100;
int nRange2 = m_pMagic->GetInt(MAGICDATA_RANGE) / 100;
int nSize = nRange1*2 + 1;
int nBufSize = nSize * nSize;
MAPTHING_SET setTarget;
vector<IRole*> setRole;
vector<int> setPower;
POINT pos;
int nExp = 0;
int nPowerSum = 0;
for (int k=0; k<m_nApplyTimes; k++)
{
// 搜索目标集
{
m_setTargetLocked.clear();
setTarget.clear();
setRole.clear();
setPower.clear();
int nDir = ::GetDirByPos(m_pOwner->GetPosX(), m_pOwner->GetPosY(), m_pos.x, m_pos.y);
pos.x = m_pOwner->GetPosX();
pos.y = m_pOwner->GetPosY();
m_pOwner->GetMap()->CollectMapThing(setTarget, pos, nRange1, OBJ_USER|OBJ_MONSTER|OBJ_NPC);
int nThisDir = nDir;
for(int i = 0; i < 4; i++)
{
POINT posThis = pos;
for(int j = 0; j < (i%2 ? nRange1 : nRange2); j++)
{
MovePos(&posThis, nThisDir);
if(!m_pOwner->GetMap()->IsValidPoint(posThis))
continue;
if(!m_pOwner->GetMap()->IsAltEnable(pos, posThis, MAGICDAMAGE_ALT))
continue;
int idx = POS2INDEX(posThis.x - pos.x + nRange1, posThis.y - pos.y + nRange1, nSize, nSize);
ASSERT(idx>=0 && idx<setTarget.size());
if(setTarget[idx])
{
IRole* pRole = NULL;
if(setTarget[idx]->QueryRole(IPP_OF(pRole)) && pRole->IsAlive() && !IsImmunity(pRole))
{
//if(nLoseLife)
{
setRole.push_back(pRole);
// 只锁定一个攻击目标
if (pRole->GetID() == m_idTarget)
m_setTargetLocked.push_back(pRole->GetID());
}
}
}
}
nThisDir = (nThisDir+2) % 8;
}
}
// 锁定目标
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower(k));
setPower.push_back(nPower);
msg.AppendRole(pRole->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
// set crime status
CheckCrime(&setRole);
for (int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setRole[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setRole[i]->GetLife(), setPower[i]);
setRole[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setRole[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setRole[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += m_pOwner->AdjustExp(setRole[i], nLifeLost);
if (!setRole[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setRole[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setRole[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setRole[i], nBonusExp, true);
}
}
}
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k);
// 必须先发轨迹后发kill消息
for (int i = 0; i < setRole.size(); i++)
{
if(!setRole[i]->IsAlive())
m_pOwner->Kill(setRole[i], GetDieMode());
}
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
return true;
}
bool CMagic::ProcessLine()
{
CHECKF(m_pMagic);
vector<IRole*> setTarget;
vector<int> setPower;
vector<POINT> setPoint;
int nExp = 0;
int nPowerSum = 0;
bool bAtkerPenetrable = (m_pMagic->GetInt(MAGICDATA_SORT) == MAGICSORT_LINE_PENETRABLE);
for (int k=0; k<m_nApplyTimes; k++)
{
// 搜索目标集
{
m_setTargetLocked.clear();
setTarget.clear();
setPower.clear();
setPoint.clear();
POINT pos;
pos.x = m_pOwner->GetPosX();
pos.y = m_pOwner->GetPosY();
DDALine(pos.x, pos.y, m_pos.x, m_pos.y, m_pMagic->GetInt(MAGICDATA_RANGE), setPoint);
for(int i = 0; i < setPoint.size(); i++)
{
POINT posThis = setPoint[i];
if(!m_pOwner->GetMap()->IsValidPoint(posThis))
continue;
if(!m_pOwner->GetMap()->IsAltEnable(pos, posThis, MAGICDAMAGE_ALT))
continue;
IRole* pTarget = m_pOwner->GetMap()->QueryRole(setPoint[i].x, setPoint[i].y, ID_NONE);
if(!pTarget || !pTarget->IsAlive() || this->IsImmunity(pTarget))
continue;
// attack now
setTarget.push_back(pTarget);
if (m_pOwner->GetID() != pTarget->GetID())
m_setTargetLocked.push_back(pTarget->GetID());
}
}
// 锁定目标
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_pos.x, m_pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setTarget.size(); i++)
{
IRole* pRole = setTarget[i];
if (pRole && pRole->IsAlive())
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower(k));
setPower.push_back(nPower);
msg.AppendRole(pRole->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
// set crime status
CheckCrime(&setTarget);
for (int i = 0; i < setTarget.size(); i++)
{
if (!setTarget[i]->IsAlive())
continue;
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setTarget[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setTarget[i]->GetLife(), setPower[i]);
setTarget[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setTarget[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setTarget[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setTarget[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += this->m_pOwner->AdjustExp(setTarget[i], nLifeLost);
if (!setTarget[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setTarget[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setTarget[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setTarget[i], nBonusExp, true);
}
}
}
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k, bAtkerPenetrable);
// 必须先发轨迹后发kill消息
for (int i = 0; i < setTarget.size(); i++)
{
if(!setTarget[i]->IsAlive())
m_pOwner->Kill(setTarget[i], GetDieMode());
}
}
if(HitByWeapon() && !m_pOwner->GetMap()->IsTrainMap())
{
m_pOwner->AddEquipmentDurability(ITEMPOSITION_WEAPONR, -1*LINE_WEAPON_DURABILITY);
m_pOwner->AddEquipmentDurability(ITEMPOSITION_WEAPONL, -1*LINE_WEAPON_DURABILITY);
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
return true;
}
bool CMagic::ProcessFan()
{
CHECKF(m_pMagic);
MAPTHING_SET setTarget;
vector<IRole*> setRole;
vector<int> setPower;
POINT pos; // source of fan
int nRange = m_pMagic->GetInt(MAGICDATA_RANGE)+MAX_SIZEADD;
int nWidth = m_pMagic->GetInt(MAGICDATA_WIDTH);
if(!nWidth)
nWidth = DEFAULT_MAGIC_FAN;
int nSize = nRange*2 + 1;
int nBufSize = nSize * nSize;
int nExp = 0;
int nPowerSum = 0;
for (int k=0; k<m_nApplyTimes; k++)
{
// 搜索目标集
{
m_setTargetLocked.clear();
setTarget.clear();
setRole.clear();
setPower.clear();
if(m_pMagic->GetInt(MAGICDATA_GROUND))
{
pos.x = m_pOwner->GetPosX();
pos.y = m_pOwner->GetPosY();
}
else
{
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
pos.x = pTarget->GetPosX();
pos.y = pTarget->GetPosY();
// 只锁定一个攻击目标
setRole.push_back(pTarget);
m_setTargetLocked.push_back(pTarget->GetID());
}
m_pOwner->GetMap()->CollectMapThing(setTarget, pos, nRange, OBJ_USER|OBJ_MONSTER|OBJ_NPC);
for(int i = ::CutTrail((int)pos.x-nRange, 0); i <= pos.x+nRange && i < m_pOwner->GetMap()->GetWidth(); i++)
{
for(int j = ::CutTrail((int)pos.y-nRange, 0); j <= pos.y+nRange && j < m_pOwner->GetMap()->GetHeight(); j++)
{
POINT posThis;
posThis.x = i;
posThis.y = j;
if(!m_pOwner->IsInFan(posThis, pos, nRange, nWidth, m_pos)) // m_pos: target pos
continue;
int idx = POS2INDEX(posThis.x - pos.x + nRange, posThis.y - pos.y + nRange, nSize, nSize);
ASSERT(idx>=0 && idx<setTarget.size());
if(setTarget[idx])
{
IRole* pRole = NULL;
if(setTarget[idx]->QueryRole(IPP_OF(pRole)) && pRole->IsAlive() && !IsImmunity(pRole)
) //&& m_pOwner->GetDistance(pRole->QueryMapThing()) <= m_pOwner->GetAttackRange(pRole->GetSizeAdd()))
{
//if(nLoseLife)
{
if (pRole->GetID() != m_idTarget) // m_idTarget如果存在前面已经push到setRole中了
setRole.push_back(pRole);
}
}
}
}
}
}
// 锁定目标
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower(k));
setPower.push_back(nPower);
msg.AppendRole(pRole->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
// set crime status
CheckCrime(&setRole);
for (int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setRole[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setRole[i]->GetLife(), setPower[i]);
setRole[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setRole[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setRole[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += this->m_pOwner->AdjustExp(setRole[i], nLifeLost);
if (!setRole[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setRole[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setRole[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setRole[i], nBonusExp, true);
}
}
}
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k);
// 必须先发轨迹后发kill消息
for (int i = 0; i < setRole.size(); i++)
{
if(!setRole[i]->IsAlive())
m_pOwner->Kill(setRole[i], GetDieMode());
}
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
return true;
}
bool CMagic::ProcessBomb()
{
CHECKF(m_pMagic);
ROLE_SET setRole;
vector<int> setPower;
POINT pos;
int nExp = 0;
int nPowerSum = 0;
for (int k=0; k<m_nApplyTimes; k++)
{
// 搜索目标集
{
setRole.clear();
setPower.clear();
CollectTargetSet_Bomb(setRole, pos, LOCK_NONE);
}
// 锁定目标
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true); // 可以重复调用
// 广播法术效果，计算伤害
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower(k));
setPower.push_back(nPower);
msg.AppendRole(pRole->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
// set crime status
CheckCrime(&setRole);
// 伤害
for (int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setRole[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setRole[i]->GetLife(), setPower[i]);
setRole[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setRole[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setRole[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += this->m_pOwner->AdjustExp(setRole[i], nLifeLost);
if (!setRole[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setRole[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setRole[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setRole[i], nBonusExp, true);
}
}
}
// 调整移动轨迹
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k);
// 必须先发轨迹后发kill消息
for (int i = 0; i < setRole.size(); i++)
{
if(!setRole[i]->IsAlive())
m_pOwner->Kill(setRole[i], GetDieMode());
}
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
return true;
}
bool CMagic::ProcessBombLockAll()
{
CHECKF(m_pMagic);
POINT pos;
ROLE_SET setRole;
vector<int> setPower;
// 收集目标集
CollectTargetSet_Bomb(setRole, pos, LOCK_ALL);
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true);
int nExp = 0;
int nPowerSum = 0;
for (int k=0; k<m_nApplyTimes; k++)
{
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower(k));
setPower.push_back(nPower);
msg.AppendRole(pRole->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
// set crime status
CheckCrime(&setRole);
for (int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setRole[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setRole[i]->GetLife(), setPower[i]);
setRole[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setRole[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setRole[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += this->m_pOwner->AdjustExp(setRole[i], nLifeLost);
if (!setRole[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setRole[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setRole[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setRole[i], nBonusExp, true);
}
}
}
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k);
// 必须先发轨迹后发kill消息
for (int i = 0; i < setRole.size(); i++)
{
if(!setRole[i]->IsAlive())
m_pOwner->Kill(setRole[i], GetDieMode());
}
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
return true;
}
bool CMagic::ProcessSquare()
{
CHECKF(m_pMagic);
MAPTHING_SET setTarget;
vector<IRole*> setRole;
vector<int> setPower;
POINT pos;
int nRange = m_pMagic->GetInt(MAGICDATA_RANGE);
if(HitByWeapon())
nRange = m_pOwner->GetAttackRange(MAX_SIZEADD);
int nSize = nRange*2 + 1;
int nBufSize = nSize * nSize;
int nExp = 0;
int nPowerSum = 0;
for (int k=0; k<m_nApplyTimes; k++)
{
// 搜索目标集
{
m_setTargetLocked.clear();
setTarget.clear();
setRole.clear();
setPower.clear();
int nDir = m_pOwner->GetDir();
if(m_pMagic->GetInt(MAGICDATA_GROUND))
{
pos.x = m_pos.x;
pos.y = m_pos.y;
}
else
{
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
pos.x = pTarget->GetPosX();
pos.y = pTarget->GetPosY();
}
m_pOwner->GetMap()->CollectMapThing(setTarget, pos, nRange, OBJ_USER|OBJ_MONSTER|OBJ_NPC);
for(int i = ::CutTrail((int)pos.x-nRange, 0); i <= pos.x+nRange && i < m_pOwner->GetMap()->GetWidth(); i++)
{
for(int j = ::CutTrail((int)pos.y-nRange, 0); j <= pos.y+nRange && j < m_pOwner->GetMap()->GetHeight(); j++)
{
POINT posThis;
posThis.x = i;
posThis.y = j;
int idx = POS2INDEX(posThis.x - pos.x + nRange, posThis.y - pos.y + nRange, nSize, nSize);
ASSERT(idx>=0 && idx<setTarget.size());
if(setTarget[idx])
{
IRole* pRole = NULL;
if(setTarget[idx]->QueryRole(IPP_OF(pRole)) && pRole->IsAlive() && !IsImmunity(pRole)
&& m_pOwner->GetDistance(pRole->QueryMapThing()) <= m_pOwner->GetAttackRange(pRole->GetSizeAdd()))
{
//if(nLoseLife)
{
setRole.push_back(pRole);
// 只锁定一个攻击目标
if (pRole->GetID() == m_idTarget)
m_setTargetLocked.push_back(pRole->GetID());
}
}
}
}
}
}
// 锁定目标
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower(k));
setPower.push_back(nPower);
msg.AppendRole(pRole->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
// set crime status
CheckCrime(&setRole);
for (int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setRole[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setRole[i]->GetLife(), setPower[i]);
setRole[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setRole[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setRole[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += this->m_pOwner->AdjustExp(setRole[i], nLifeLost);
if (!setRole[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setRole[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setRole[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setRole[i], nBonusExp, true);
}
}
}
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k);
// 必须先发轨迹后发kill消息
for (int i = 0; i < setRole.size(); i++)
{
if(!setRole[i]->IsAlive())
m_pOwner->Kill(setRole[i], GetDieMode());
}
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
//? 未增加武器熟练度，也未损耗双方装备。
return true;
}
bool CMagic::ProcessAttach()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
IRole* pRole = m_pOwner->FindAroundRole(m_idTarget);
if(!pRole || !pRole->IsAlive())
return false;
// if(m_pOwner->GetDistance(pRole->GetPosX(), pRole->GetPosY()) > m_pMagic->GetInt(MAGICDATA_DISTANCE))
// return false;
int nPower = GetPower();
int nSecs = m_pMagic->GetInt(MAGICDATA_STEP);
int nTimes = m_pMagic->GetInt(MAGICDATA_TIMES);
DWORD nStatus = m_pMagic->GetInt(MAGICDATA_STATUS);
ASSERT(nPower > 0);
// m_setTargetLocked.push_back(m_idTarget);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, 0, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
CheckCrime(pRole);
// user status only
void* pTemp;
if(!pRole->QueryObj(OBJ_USER, IPP_OF(pTemp))
&& (nStatus == STATUS_LURKER /*|| nStatus == STATUS_ATKRANGE*/ || nStatus == STATUS_REFLECT || nStatus == STATUS_REFLECTMAGIC))
return false;
if(nStatus == STATUS_LURKER || nStatus == STATUS_ATKSPEED) // 不可叠加
{
CRole::DetachWellStatus(pRole);
}
// superman list
// if(nStatus == STATUS_SUPERMAN || nStatus == STATUS_TORNADO)
// {
//// m_pOwner->CalcSupermanKills();
// nSecs += m_pOwner->GetSupermanAddSecs();
// }
// 4超级的特殊状态，及超级回复
if(m_pMagic && m_pMagic->GetInt(MAGICDATA_TYPE)>=SUPER_MAGIC_DEFENCE && m_pMagic->GetInt(MAGICDATA_TYPE)<=SUPER_MAGIC_MGC_ATTACK)
nPower *= m_pOwner->GetSoulSum()/2;
switch(m_pMagic->GetInt(MAGICDATA_TYPE))
{
case SUPER_MAGIC_DEFENCE:
{
CRole::DetachStatus(m_pOwner, STATUS_SUPER_ATK);
//CRole::DetachStatus(m_pOwner, STATUS_SUPER_DEF);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_MATK);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_MDEF);
}
break;
case SUPER_MAGIC_MGC_DEFENCE:
{
CRole::DetachStatus(m_pOwner, STATUS_SUPER_ATK);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_DEF);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_MATK);
//CRole::DetachStatus(m_pOwner, STATUS_SUPER_MDEF);
}
break;
case SUPER_MAGIC_ATTACK:
{
//CRole::DetachStatus(m_pOwner, STATUS_SUPER_ATK);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_DEF);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_MATK);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_MDEF);
}
break;
case SUPER_MAGIC_MGC_ATTACK:
{
CRole::DetachStatus(m_pOwner, STATUS_SUPER_ATK);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_DEF);
//CRole::DetachStatus(m_pOwner, STATUS_SUPER_MATK);
CRole::DetachStatus(m_pOwner, STATUS_SUPER_MDEF);
}
break;
}
// 疾行技能特殊处理
if (nStatus == STATUS_PELT && pRole->QueryStatus(STATUS_PELT))
CRole::DetachStatus(pRole, nStatus);
else
CRole::AttachStatus(pRole, nStatus, nPower, nSecs, nTimes);
AwardExp(0); // false: not award battle exp
// hint
if(nPower >= 30000)
{
int nPowerTimes = (nPower-30000) / 100;
MSGBUF szMsg;
switch(nStatus)
{
// case STATUS_HITRATE:
// {
// sprintf(szMsg, STR_HITRATE_ADD, nSecs, nPowerTimes);
// pRole->SendSysMsg(szMsg);
// }
// break;
case STATUS_DEFENCE1:
case STATUS_DEFENCE2:
case STATUS_DEFENCE3:
{
sprintf(szMsg, STR_DEFENCE_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_ATTACK:
{
sprintf(szMsg, STR_ATTACK_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
}
}
else
{
int nPowerTimes = nPower;
MSGBUF szMsg;
switch(nStatus)
{
// case STATUS_HITRATE:
// {
// sprintf(szMsg, STR_HITRATE_ADD2, nSecs, nPowerTimes);
// pRole->SendSysMsg(szMsg);
// }
// break;
case STATUS_DEFENCE1:
case STATUS_DEFENCE2:
case STATUS_DEFENCE3:
{
sprintf(szMsg, STR_DEFENCE_ADD2, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_ATTACK:
{
sprintf(szMsg, STR_ATTACK_ADD2, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_SUPER_ATK:
{
sprintf(szMsg, STR_SUPER_ATK_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_SUPER_DEF:
{
sprintf(szMsg, STR_SUPER_DEF_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_SUPER_MATK:
{
sprintf(szMsg, STR_SUPER_MATK_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_SUPER_MDEF:
{
sprintf(szMsg, STR_SUPER_MDEF_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
}
}
// 组队界结提示
if (m_pMagic->GetInt(MAGICDATA_SORT) == MAGICSORT_TEAM_MAGIC)
{
CUser* pUser = NULL;
if (m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser)))
{
CTeam* pTeam = pUser->GetTeam();
if (pTeam && pTeam->GetMemberAmount() >= TEAM_STATUS_REQ_ROLES)
{
char szMsg[256] = "";
if (pTeam->GetMemberAmount() == TEAM_STATUS_REQ_ROLES)
sprintf(szMsg, STR_TEAM_MAGIC, m_pMagic->GetName());
else
sprintf(szMsg, STR_TEAM_MAGIC2, m_pMagic->GetName(), 10*(pTeam->GetMemberAmount()-TEAM_STATUS_REQ_ROLES));
CMsgTalk msg;
if (msg.Create(SYSTEM_NAME, ALLUSERS_NAME, szMsg, NULL, 0xff0000, _TXTATR_SYSTEM))
pTeam->BroadcastTeamMsg(&msg);
}
}
}
return true;
}
bool CMagic::ProcessDetach()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
IRole* pRole = m_pOwner->FindAroundRole(m_idTarget);
if(!pRole)
return false;
int nPower = 0; //解状态 GetPower();
int nSecs = m_pMagic->GetInt(MAGICDATA_STEP);
int nTimes = m_pMagic->GetInt(MAGICDATA_TIMES);
int nStatus = m_pMagic->GetInt(MAGICDATA_STATUS);
ASSERT(nPower == 0); // 0 : 减少
if (!pRole->IsAlive())
{
if (STATUS_DIE != nStatus)
return false;
void* pTemp;
if (!pRole->QueryObj(OBJ_USER, IPP_OF(pTemp)))
return false;
}
// pk field will disable reborn magic
if (STATUS_DIE == nStatus)
{
CGameMap* pMap = m_pOwner->GetMap();
if (pMap && pMap->IsPkField())
return false;
}
if(nStatus == STATUS_DETACH_ALL)
{
CRole::DetachAllStatus(pRole);
}
else if(nStatus == STATUS_DETACH_BADLY)
{
CRole::DetachBadlyStatus(pRole);
}
else
{
IStatus* pStatus = pRole->QueryStatus(nStatus);
if(pStatus)
pStatus->ChangeData(nPower, nSecs, nTimes);
}
// m_setTargetLocked.push_back(m_idTarget);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, nStatus, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
CheckCrime(pRole);
pRole->ClsStatus(nStatus, SYNCHRO_TRUE);
if (STATUS_DIE == nStatus)
{ // reborn
CUser* pUser = NULL;
pRole->QueryObj(OBJ_USER, IPP_OF(pUser));
if (pUser)
{
bool bChgPos = false;
pUser->Reborn(bChgPos);
}
}
AwardExp(0);
return true;
}
bool CMagic::ProcessJumpAttackFaild(int x, int y)
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
int nPower = 0;
OBJID idTarget = ID_NONE;
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), x, y, idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
m_pOwner->ProcessOnMove(MOVEMODE_JUMPMAGICATTCK);
m_pOwner->JumpPos(x, y);
return true;
}
bool CMagic::ProcessJumpAtk()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
// if(m_pOwner->GetDistance(m_pos.x, m_pos.y) > m_pMagic->GetInt(MAGICDATA_DISTANCE))
// {
// ::GmLogSave("玩家[%s]XP技跳砍的距离非法!", m_pOwner->GetName());
// return false;
// }
POINT pos;
IRole* pTarget = NULL;
if(m_pMagic->GetInt(MAGICDATA_GROUND))
{
pos.x = m_pos.x;
pos.y = m_pos.y;
}
else
{
pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
if(pTarget->GetDistance(m_pos.x, m_pos.y) > m_pOwner->GetAttackRange(pTarget->GetSizeAdd()))
return false;
if (this->IsImmunity(pTarget))
return false;
pos.x = pTarget->GetPosX();
pos.y = pTarget->GetPosY();
}
// if(m_pOwner->GetDistance(pos.x, pos.y) > m_pMagic->GetInt(MAGICDATA_DISTANCE))
// return false;
int nRange = m_pMagic->GetInt(MAGICDATA_RANGE);
int nPower = 0;
if(pTarget)
{
nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pTarget, GetPower());
}
// m_setTargetLocked.push_back(m_idTarget);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_pos.x, m_pos.y, m_idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
if(pTarget)
CheckCrime(pTarget);
// move!!! 攻击方需要锁定坐标
m_pOwner->ProcessOnMove(MOVEMODE_JUMPMAGICATTCK);
m_pOwner->JumpPos(m_pos.x, m_pos.y);
if (nPower && pTarget)
{
CNpc* pNpc = NULL;
int nLifeLost = nPower;
if (pTarget->TransferShield(HitByMagic(), m_pOwner, nPower))
{
}
else
{
nLifeLost = __min(pTarget->GetLife(), nPower);
pTarget->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(pTarget->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
pTarget->BeAttack(HitByMagic(), m_pOwner, nPower);
}
if(pTarget->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
// correct exp here
int nExp = this->m_pOwner->AdjustExp(pTarget, nLifeLost);
// kill bonus
if (!pTarget->IsAlive()) // target was killed
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = pTarget->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(pTarget, nBonusExp);
nExp += m_pOwner->AdjustExp(pTarget, nBonusExp, true);
}
this->AwardExp(nExp);
}
if (!pTarget->IsAlive())
m_pOwner->Kill(pTarget, GetDieMode());
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPower, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
}
//? 未增加武器熟练度，也未损耗双方装备。
return true;
}
bool CMagic::ProcessRandomTrans()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
int nWidth = GetPower() * 2 + 1;
AwardExp(0);
for(int i = 0; i < RANDOMTRANS_TRY_TIMES; i++)
{
int x = (int)m_pOwner->GetPosX()+nWidth/2-::RandGet(nWidth);
int y = (int)m_pOwner->GetPosY()+nWidth/2-::RandGet(nWidth);
if(m_pOwner->GetMap()->IsStandEnable(x, y))
{
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), x, y, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// move!!! 攻击方需要锁定坐标
m_pOwner->ProcessOnMove(MOVEMODE_TRANS);
m_pOwner->TransPos(x, y); //? may be optimize to JumpPos(,)
m_pOwner->Synchro();
return true;
}
}
m_pOwner->SendSysMsg(STR_MAGIC_FAILED);
return false;
}
bool CMagic::ProcessDispatchXP()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
vector<CUser*> setUser;
vector<int> setPower;
CTeam* pTeam = m_pOwner->GetTeam();
if(pTeam)
{
MSGBUF szMsg;
sprintf(szMsg, STR_DISPATCHXP_s, m_pOwner->GetName());
for(int i = 0; i < pTeam->GetMemberAmount(); i++)
{
OBJID idUser = pTeam->GetMemberByIndex(i);
IRole* pRole = m_pOwner->FindAroundRole(idUser);
CUser* pUser = NULL;
if (pRole)
pRole->QueryObj(OBJ_USER, IPP_OF(pUser));
if(idUser != ID_NONE && pUser && pUser->IsAlive() && pUser->GetID() != m_pOwner->GetID())
{
pUser->AddXp(DISPATCHXP_NUMBER);
setUser.push_back(pUser);
setPower.push_back(DISPATCHXP_NUMBER);
// m_setTargetLocked.push_back(pUser->GetID());
pUser->SendSysMsg(szMsg);
}
}
}
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_pos.x, m_pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setUser.size(); i++)
msg.AppendRole(setUser[i]->GetID(), setPower[i]);
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
AwardExp(0);
return true;
}
bool CMagic::ProcessCollideFail(int x, int y, int nDir)
{
m_setTargetLocked.clear();
// target data is dir
int nTargetX = m_pos.x+_DELTA_X[nDir];
int nTargetY = m_pos.y+_DELTA_Y[nDir];
int nPower = 0;
OBJID idTarget = ID_NONE;
IF_NOT(m_pOwner->GetMap()->IsStandEnable(nTargetX, nTargetY))
{
m_pOwner->SendSysMsg(STR_INVALID_MSG);
CUser* pUser = NULL;
if (m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser)))
UserManager()->KickOutSocket(pUser->GetSocketID(), "COLLIDE coord!");
return false;
}
MsgInteract msg;
IF_OK (msg.Create(INTERACT_BUMP, m_pOwner->GetID(), idTarget, nTargetX, nTargetY, nDir*0x01000000+nPower))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// move now...
// if (!(m_pOwner->GetPosX() == m_pos.x && m_pOwner->GetPosY() == m_pos.y))
{
m_pOwner->ProcessOnMove(MOVEMODE_COLLIDE);
m_pOwner->MoveToward(nDir);
}
return true;
}
bool CMagic::ProcessCollide()
{
CHECKF(m_pMagic);
CHECKF(m_pOwner);
m_setTargetLocked.clear();
// check syn of user
IF_NOT(m_pOwner->SynPosition(m_pos.x, m_pos.y))
{
CUser* pUser = NULL;
if (m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser)))
UserManager()->KickOutSocket(pUser->GetSocketID(), "ProcessCollide SynPosition");
return false;
}
// target data is dir
int nDir = m_nData;
int nTargetX = m_pos.x+_DELTA_X[nDir];
int nTargetY = m_pos.y+_DELTA_Y[nDir];
IF_NOT(m_pOwner->GetMap()->IsStandEnable(nTargetX, nTargetY))
{
m_pOwner->SendSysMsg(STR_INVALID_MSG);
CUser* pUser = NULL;
if (m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser)))
UserManager()->KickOutSocket(pUser->GetSocketID(), "COLLIDE coord!");
return false;
}
// search the target
bool bSuc = true;
IRole* pTarget = m_pOwner->GetMap()->QueryRole(nTargetX, nTargetY, ID_NONE);
if(!pTarget || !pTarget->IsAlive())
bSuc = false;
if (!pTarget || this->IsImmunity(pTarget))
bSuc = false;
//if (m_pOwner->GetDistance(nTargetX, nTargetY) > m_pMagic->GetInt(MAGICDATA_DISTANCE))
// bSuc = false;
int nPower = 0;
bool bBackEnable = false;
OBJID idTarget = ID_NONE;
CNpc* pNpc = NULL;
if (pTarget)
{
pTarget->QueryObj(OBJ_NPC, IPP_OF(pNpc));
// int nHitRate = 100;
// if (::RandGet(100) >= nHitRate)
// bSuc = false;
if (bSuc)
{
bBackEnable = pTarget->GetMap()->IsStandEnable(nTargetX+_DELTA_X[nDir], nTargetY+_DELTA_Y[nDir]);
if(pNpc)
bBackEnable = false;
if (!bBackEnable)
nDir = MAX_DIRSIZE;
if (HitByWeapon()) // && !CBattleSystem::IsTargetDodged(m_pOwner, pTarget))
{
nPower += CBattleSystem::CalcAttackPower(m_pOwner, pTarget);
if(bBackEnable || pNpc)
nPower = MulDiv(nPower, COLLIDE_POWER_PERCENT, 100);
else
nPower = m_pOwner->AdjustData(nPower, GetPower());
}
if(!m_pOwner->GetMap()->IsTrainMap())
m_pOwner->AddEquipmentDurability(ITEMPOSITION_WEAPONL, -1*COLLIDE_SHIELD_DURABILITY);
}
idTarget = pTarget->GetID();
// m_setTargetLocked.push_back(idTarget);
}
MsgInteract msg;
DWORD dwData = nDir*0x01000000+nPower;
if (!bBackEnable)
dwData += 1*0x10000000;
IF_OK (msg.Create(INTERACT_BUMP, m_pOwner->GetID(), idTarget, nTargetX, nTargetY, dwData))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
if (m_pOwner->IsPM())
{
CUser* pUser = NULL;
if (m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser)))
pUser->SendSysMsg(_TXTATR_NORMAL, "bump move:(%u, %u)->(%u, %u)",
pUser->GetPosX(), pUser->GetPosY(),
nTargetX, nTargetY);
}
// move now...
// if (!(m_pOwner->GetPosX() == m_pos.x && m_pOwner->GetPosY() == m_pos.y))
if (bBackEnable)
{
m_pOwner->ProcessOnMove(MOVEMODE_COLLIDE);
m_pOwner->MoveToward(nDir);
}
if (pTarget && bBackEnable && bSuc)
{
pTarget->ProcessOnMove(MOVEMODE_COLLIDE);
pTarget->MoveToward(nDir);
// paled - set not synchro yet
CUser* pTargetUser;
if(pTarget->QueryObj(OBJ_USER, IPP_OF(pTargetUser)))
{
// syn pos of client
pTargetUser->SetSynchro(false);
}
}
// set crime status
if(pTarget)
CheckCrime(pTarget);
if (nPower && pTarget)
{
CNpc* pNpc = NULL;
int nLifeLost = nPower;
if (pTarget->TransferShield(HitByMagic(), m_pOwner, nPower))
{
}
else
{
nLifeLost = __min(pTarget->GetLife(), nPower);
pTarget->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(pTarget->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
pTarget->BeAttack(HitByMagic(), m_pOwner, nPower);
}
if(pTarget->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
// correct exp here
int nExp = this->m_pOwner->AdjustExp(pTarget, nLifeLost);
// kill bonus
if (!pTarget->IsAlive()) // target was killed
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = pTarget->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(pTarget, nBonusExp);
nExp += m_pOwner->AdjustExp(pTarget, nBonusExp, true);
}
this->AwardExp(nExp);
}
if (!pTarget->IsAlive())
m_pOwner->Kill(pTarget, GetDieMode());
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPower, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
}
return true;
}
bool CMagic::ProcessSerialCut()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
POINT pos;
pos.x = m_pos.x;
pos.y = m_pos.y;
int nRange = 1;
int nSize = nRange*2 + 1;
int nBufSize = nSize * nSize;
vector<IRole*> setRole;
vector<int> setPower;
for(int i = 0; i < MAX_SERIALCUTSIZE; i++)
{
MAPTHING_SET setTarget;
m_pOwner->GetMap()->CollectMapThing(setTarget, pos, nRange, OBJ_USER|OBJ_MONSTER|OBJ_NPC);
IRole* pTarget = NULL;
for(int j = 0; j < setTarget.size(); j++)
{
int idx = j;
ASSERT(idx>=0 && idx<setTarget.size());
if(setTarget[idx])
{
IRole* pRole = NULL;
if(setTarget[idx]->QueryRole(IPP_OF(pRole)) && pRole->IsAlive() && !IsImmunity(pRole))
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower());
//if(nLoseLife)
{
setRole.push_back(pRole);
setPower.push_back(nPower);
// 只锁定一个攻击目标
// if (pRole->GetID() == m_idTarget)
// m_setTargetLocked.push_back(pRole->GetID());
if(nPower >= pRole->GetLife())
pTarget = pRole; // continue next cut
break;
}
}
}
}
if(!pTarget)
break;
pos.x = pTarget->GetPosX();
pos.y = pTarget->GetPosY();
}
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
msg.AppendRole(setRole[i]->GetID(), setPower[i]);
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
int nPowerSum = 0;
int nExp = 0;
for (int i = 0; i < setRole.size(); i++)
{
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setRole[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setRole[i]->GetLife(), setPower[i]);
setRole[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setRole[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setRole[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += this->m_pOwner->AdjustExp(setRole[i], nLifeLost);
if (!setRole[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setRole[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setRole[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setRole[i], nBonusExp, true);
}
}
if(!setRole[i]->IsAlive())
m_pOwner->Kill(setRole[i], GetDieMode());
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
//? 未增加武器熟练度，也未损耗双方装备。
return true;
}
bool CMagic::ProcessCallTeamMember()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
CTeam* pTeam = m_pOwner->GetTeam();
if(!pTeam)
return false;
if (!m_pOwner->GetMap())
return false;
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_pOwner->GetID(), 0, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
for(int i = 0; i < pTeam->GetMemberAmount(); i++)
{
OBJID idTarget = pTeam->GetMemberByIndex(i);
if(idTarget != ID_NONE && idTarget != m_pOwner->GetID())
{
CUser* pTarget = UserManager()->GetUser(idTarget);
if(pTarget)
{
if (!pTarget->IsAlive())
return false;
// m_setTargetLocked.push_back(pTarget->GetID());
pTarget->FlyMap(m_pOwner->GetMap()->GetID(), m_pOwner->GetPosX(), m_pOwner->GetPosY());
}
else
MapGroup(PID)->QueryIntraMsg()->ChangeTeam(CHANGETEAM_FLY, m_pOwner->GetMap()->GetID(), idTarget, MAKELONG(m_pOwner->GetPosX(), m_pOwner->GetPosY()));
}
}
AwardExp(0);
return true;
}
bool CMagic::ProcessRecordTransSpell()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, 0, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
CItem* pItem = m_pOwner->FindSpaceTransSpell();
if(pItem)
{
OBJID idMap = ID_NONE;
if (m_pOwner->GetMap())
idMap = m_pOwner->GetMap()->GetID();
pItem->SetInt(ITEMDATA_DATA, idMap, UPDATE_FALSE);
pItem->SetInt(ITEMDATA_AMOUNT, m_pOwner->GetPosX(), UPDATE_FALSE);
pItem->SetInt(ITEMDATA_AMOUNTLIMIT, m_pOwner->GetPosY(), UPDATE_TRUE);
CMsgItemInfo msg;
msg.Create(pItem, ITEMINFO_UPDATE);
m_pOwner->SendMsg(&msg);
}
AwardExp(0);
return true;
}
bool CMagic::ProcessTransform()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, 0, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
m_pOwner->Transform(GetPower(), GetPower());
this->AwardExp(0);
return true;
}
bool CMagic::ProcessAddMana()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
int nAddMana = GetPower();
nAddMana = ::CutOverflow(nAddMana, (int)m_pOwner->GetMaxMana()-(int)m_pOwner->GetMana());
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_pOwner->GetID(), nAddMana, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
int nExp = m_pOwner->GetMaxMana() - m_pOwner->GetMana();
m_pOwner->AddAttrib(_USERATTRIB_MANA, nAddMana, SYNCHRO_TRUE);
this->AwardExp(0);
return true;
}
bool CMagic::ProcessLayTrap()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
int nTrapType = GetPower();
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_pOwner->GetID(), 0, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
int nCostDir = abs(m_pOwner->GetPosX() - m_pos.x) < abs(m_pOwner->GetPosY() - m_pos.y) ? 0 : 2;
TRAP_INFO info;
info.id = ID_NONE; //? set id in CreateNew()
info.idMap = ID_NONE;
if (m_pOwner->GetMap())
info.idMap = m_pOwner->GetMap()->GetID();
info.idOwner = m_pOwner->GetID();
info.usLook = (nCostDir + 4) % MAX_DIRSIZE; // 4: rotate 90 degree
info.usPosX = m_pos.x;
info.usPosY = m_pos.y;
info.usType = nTrapType;
// 暂时这么修改，等魔法系统修改完成后，还需要修改陷阱为使用IRole为入口参数
CUser* pUser = NULL;
if (m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser)))
{
CMapTrap* pTrap = CMapTrap::CreateNew(m_idProcess, &info, pUser);
if(pTrap)
RoleManager()->QuerySet()->AddObj(pTrap->QueryRole());
}
this->AwardExp(0);
return true;
}
bool CMagic::ProcessCallPet()
{
CHECKF(m_pMagic);
CUser* pUser = NULL;
if (!m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser)))
return false;
m_setTargetLocked.clear();
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_pos.x, m_pos.y, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
pUser->CallPet(GetPower(), m_pos.x, m_pos.y, m_pMagic->GetInt(MAGICDATA_STEP));
this->AwardExp(0);
return true;
}
bool CMagic::ProcessDecLife()
{
CHECKF(m_pMagic);
m_setTargetLocked.clear();
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
// if(m_pOwner->GetDistance(pTarget->GetPosX(), pTarget->GetPosY()) > m_pMagic->GetInt(MAGICDATA_DISTANCE))
// return false;
if (this->IsImmunity(pTarget))
return false;
int nPower = ::CutTrail(0, CRole::AdjustDataEx(pTarget->GetLife(), GetPower()));
// m_setTargetLocked.push_back(m_idTarget);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
CheckCrime(pTarget);
if (nPower)
{
int nLifeLost = nPower;
if (pTarget->TransferShield(HitByMagic(), m_pOwner, nPower))
{
}
else
{
nLifeLost = __min(pTarget->GetLife(), nPower);
pTarget->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
pTarget->BeAttack(HitByMagic(), m_pOwner, nPower);
}
AwardExpOfLife(pTarget, nLifeLost);
if (!pTarget->IsAlive())
m_pOwner->Kill(pTarget, GetDieMode());
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPower, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
}
//? 未增加武器熟练度，也未损耗双方装备。
return true;
}
bool CMagic::ProcessGroundSting()
{
CHECKF(m_pMagic);
vector<IRole*> setRole;
vector<int> setPower;
POINT pos;
int nCount = ::CutOverflow(4, m_pMagic->GetInt(MAGICDATA_LEVEL) + 2);
int nExp = 0;
int nPowerSum = 0;
for (int k=0; k<m_nApplyTimes; k++)
{
// 搜索目标集
{
m_setTargetLocked.clear();
setRole.clear();
setPower.clear();
if(m_pMagic->GetInt(MAGICDATA_GROUND))
{
pos.x = m_pos.x;
pos.y = m_pos.y;
}
else
{
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
pos.x = pTarget->GetPosX();
pos.y = pTarget->GetPosY();
}
IRole* pRole = NULL;
switch(nCount)
{
case 2:
if(::RandGet(2) == 0)
{
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x-1, pos.y);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x+1, pos.y);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
}
else
{
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x, pos.y-1);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x, pos.y+1);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
}
break;
case 3:
{
int nRand = ::RandGet(4);
if(nRand != 0)
{
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x-1, pos.y);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
}
if(nRand != 1)
{
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x+1, pos.y);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
}
if(nRand != 2)
{
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x, pos.y-1);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
}
if(nRand != 3)
{
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x, pos.y+1);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
}
}
break;
case 4:
{
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x-1, pos.y);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x+1, pos.y);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x, pos.y-1);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
pRole = m_pOwner->GetMap()->QueryRoleByPos(pos.x, pos.y+1);
if(pRole && pRole->IsAlive() && !IsImmunity(pRole))
{
m_setTargetLocked.push_back(pRole->GetID());
setRole.push_back(pRole);
}
}
break;
}
}
// 锁定目标
if (m_pMagic->GetSTrackAmount() > 0)
LockTarget(true);
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower(k));
setPower.push_back(nPower);
msg.AppendRole(pRole->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
// set crime status
CheckCrime(&setRole);
for (int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setRole[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setRole[i]->GetLife(), setPower[i]);
setRole[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setRole[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setRole[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += m_pOwner->AdjustExp(setRole[i], nLifeLost);
if (!setRole[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setRole[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setRole[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setRole[i], nBonusExp, true);
}
}
}
if (m_pMagic->GetSTrackAmount() > 0)
AdjustPosByTrack(k);
// 必须先发轨迹后发kill消息
for (int i = 0; i < setRole.size(); i++)
{
if(!setRole[i]->IsAlive())
m_pOwner->Kill(setRole[i], GetDieMode());
}
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
return true;
}
bool CMagic::ProcessReborn()
{
CHECKF (m_pMagic);
m_setTargetLocked.clear();
IRole* pRole = m_pOwner->FindAroundRole(m_idTarget);
if(!pRole || pRole->IsAlive())
return false;
CUser* pTarget = NULL;
if (!pRole->QueryObj(OBJ_USER, IPP_OF(pTarget)))
return false;
// if(m_pOwner->GetDistance(pTarget->GetPosX(), pTarget->GetPosY()) > m_pMagic->GetInt(MAGICDATA_DISTANCE))
// return false;
// if (this->IsImmunity(pRole))
// return false;
int nPower = ::CutTrail(0, CRole::AdjustDataEx(pTarget->GetLife(), GetPower()));
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
CheckCrime(pRole);
bool bChgPos = false;
pTarget->Reborn(bChgPos);
if (nPower)
{
// 设置HP -- 复活以后不是满血更真实
}
//? 未增加武器熟练度，也未损耗双方装备。
this->AwardExp(0);
return true;
}
bool CMagic::ProcessSorbSoul()
{
CHECKF (m_pMagic);
m_setTargetLocked.clear();
IRole* pRole = m_pOwner->FindAroundRole(m_idTarget);
if (!pRole || pRole->IsAlive() || !pRole->IsMonster())
return false;
int nPower = GetPower();
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// TODO: 吸收尸体的灵魂转换为魔力
// 通过前面的CheckCondition判断，以下条件判断已经是冗余的
CMonster* pMonster = NULL;
if (pRole->QueryObj(OBJ_MONSTER, IPP_OF(pMonster))
&& (pMonster->GetMaskData() & MASK_DISABLE_SORB_SOUL) == 0)
{
pMonster->SetMaskData(MASK_DISABLE_SORB_SOUL);
pMonster->DelMonster(true); // 立刻删除怪物尸体
pMonster->SetStatus(STATUS_DISAPPEARING);
m_pOwner->AddAttrib(_USERATTRIB_MANA, nPower, SYNCHRO_TRUE);
}
this->AwardExp(0);
return true;
}
bool CMagic::ProcessSteal()
{
CHECKF(m_pMagic);
CHECKF(m_pOwner);
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
CUser* pTargetUser = NULL;
if (!pTarget->QueryObj(OBJ_USER, IPP_OF(pTargetUser)))
return false;
m_setTargetLocked.clear();
int nPower = GetPower();
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
CheckCrime(pTarget);
if (nPower)
{
CItem* pItem = pTargetUser->GetItemByType(GHOST_GEM_AVOID_STEAL);
if (pItem)
{
pTargetUser->SendSysMsg(STR_AUTO_USE_ANTISTEAL, pItem->GetStr(ITEMDATA_NAME));
pTargetUser->SendSysMsg(STR_AVOID_STEAL, m_pOwner->GetName());
pTargetUser->EraseItem(pItem->GetID(), true);
return false;
}
else
{
IUserPackage* pPackage = pTargetUser->QueryPackage();
if (pPackage)
{
int nStealNum = __min(nPower, pPackage->GetAmount());
for (int i=0; i<nStealNum; i++)
{
OBJID idItem = pPackage->RandGetItem();
CItem* pItem = pTargetUser->PopItem(idItem, true, true);
if (pItem)
{
pTargetUser->SendSysMsg(STR_STOLEN, m_pOwner->GetName(), pItem->GetStr(ITEMDATA_NAME));
if (!m_pOwner->AddItem(pItem, true))
{
pItem->DeleteRecord();
pItem->ReleaseByOwner();
}
}
}
}
}
}
this->AwardExp(0);
return true;
}
bool CMagic::ProcessBlastThunder()
{
CHECKF(m_pMagic);
CHECKF(m_pOwner);
vector<IRole*> setRole;
vector<int> setPower;
POINT pos;
m_setTargetLocked.clear();
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
pos.x = m_pOwner->GetPosX();
pos.y = m_pOwner->GetPosY();
// 搜索目标集
while (pTarget)
{
if (m_pOwner->GetDistance(pos.x, pos.y) > m_pMagic->GetInt(MAGICDATA_DISTANCE)
|| !pTarget->IsAlive()
|| IsImmunity(pTarget))
{
break;
}
setRole.push_back(pTarget);
pTarget = NULL;
int nDirX = ::RandGet(MAX_DIRSIZE);
int nDirY = ::RandGet(MAX_DIRSIZE);
POINT pt = {pos.x, pos.y};
for (int i=0; i<m_pMagic->GetInt(MAGICDATA_DISTANCE); i++)
{
pt.x += _DELTA_X[nDirX];
pt.y += _DELTA_Y[nDirY];
IRole* pRole = m_pOwner->GetMap()->QueryRoleByPos(pt.x, pt.y);
if (pRole && pRole->IsAlive() && !IsImmunity(pRole)
&& m_pOwner->FindAroundRole(pRole->GetID())) // 必须在自己的广播区内，这里暂时这么实现，效率不够高 -- zlong
{
// 避免重复
bool bInTargetSet = false;
for (int k=0; k<setRole.size(); k++)
{
if (setRole[k] && setRole[k]->GetID() == pRole->GetID())
{
bInTargetSet = true;
break;
}
}
if (!bInTargetSet)
pTarget = pRole;
}
}
} // end of while
// 广播法术效果，计算伤害
CMsgMagicEffect msg;
IF_OK(msg.CreateByPos(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_pOwner->GetPosX(), m_pOwner->GetPosY(), m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pRole, GetPower());
setPower.push_back(nPower);
msg.AppendRole(pRole->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
CheckCrime(&setRole);
int nExp = 0;
int nPowerSum = 0;
for (int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
nPowerSum += setPower[i];
CNpc* pNpc = NULL;
int nLifeLost = setPower[i];
if (setPower[i] && setRole[i]->TransferShield(HitByMagic(), m_pOwner, setPower[i]))
{
}
else
{
nLifeLost = __min(setRole[i]->GetLife(), setPower[i]);
setRole[i]->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
if(setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc)) && pNpc->IsAwardScore())
m_pOwner->AwardSynWarScore(pNpc, nLifeLost);
setRole[i]->BeAttack(HitByMagic(), m_pOwner, setPower[i]);
}
if (setRole[i]->IsMonster() || pNpc && pNpc->IsGoal() && m_pOwner->GetLev() >= pNpc->GetLev())
{
nExp += this->m_pOwner->AdjustExp(setRole[i], nLifeLost);
if (!setRole[i]->IsAlive())
{
// 有组队，并且队伍中有其他队员，则奖励其他队员经验
int nBonusExp = setRole[i]->GetMaxLife()*KILLBONUS_PERCENT/100;
OtherMemberAwardExp(setRole[i], nBonusExp);
nExp += m_pOwner->AdjustExp(setRole[i], nBonusExp, true);
}
}
if(!setRole[i]->IsAlive())
m_pOwner->Kill(setRole[i], GetDieMode());
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPowerSum, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
AwardExp(nExp);
return true;
}
bool CMagic::CollectTargetSet_Bomb(ROLE_SET& setRole, POINT& pos, int nLockType)
{
CHECKF (m_pMagic);
int nRange = m_pMagic->GetInt(MAGICDATA_RANGE);
int nSize = nRange*2 + 1;
int nBufSize = nSize * nSize;
MAPTHING_SET setTarget;
m_setTargetLocked.clear();
setRole.clear();
int nDir = m_pOwner->GetDir();
if (m_pMagic->GetInt(MAGICDATA_GROUND))
{
pos.x = m_pOwner->GetPosX(); //m_pos.x;
pos.y = m_pOwner->GetPosY(); //m_pos.y;
}
else
{
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
pos.x = pTarget->GetPosX();
pos.y = pTarget->GetPosY();
}
m_pOwner->GetMap()->CollectMapThing(setTarget, pos, nRange, OBJ_USER|OBJ_MONSTER|OBJ_NPC);
for(int i = ::CutTrail((int)pos.x-nRange, 0); i <= pos.x+nRange && i < m_pOwner->GetMap()->GetWidth(); i++)
{
for(int j = ::CutTrail((int)pos.y-nRange, 0); j <= pos.y+nRange && j < m_pOwner->GetMap()->GetHeight(); j++)
{
POINT posThis;
posThis.x = i;
posThis.y = j;
if (!CUser::IsInCircle(posThis, pos, nRange))
continue;
int idx = POS2INDEX(posThis.x - pos.x + nRange, posThis.y - pos.y + nRange, nSize, nSize);
ASSERT(idx>=0 && idx<setTarget.size());
if(setTarget[idx])
{
IRole* pRole = NULL;
if(setTarget[idx]->QueryRole(IPP_OF(pRole)) && pRole->IsAlive() && !IsImmunity(pRole))
{
//if(nLoseLife)
{
setRole.push_back(pRole);
// 锁定攻击目标
if ((nLockType == LOCK_ONE && pRole->GetID() == m_idTarget)
|| nLockType == LOCK_ALL)
{
m_setTargetLocked.push_back(pRole->GetID());
}
}
}
}
}
}
return true;
}
bool CMagic::CollectTargetSet_Team(ROLE_SET& setRole)
{
// 如果是幻兽则需要先获得主人
CUser* pUser = NULL;
CMonster* pMonster = NULL;
if (m_pOwner->QueryObj(OBJ_MONSTER, IPP_OF(pMonster)))
pUser = pMonster->QueryOwnerUser();
else
m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser));
if (!pUser)
return false;
int nRange = m_pMagic->GetInt(MAGICDATA_RANGE);
POINT pos = { m_pOwner->GetPosX(), m_pOwner->GetPosY() };
// 先搜索玩家集合
vector<CUser*> setUser;
setUser.push_back(pUser);
CTeam* pTeam = pUser->GetTeam();
if (pTeam)
{
for (int i=0; i<pTeam->GetMemberAmount(); i++)
{
OBJID idMember = pTeam->GetMemberByIndex(i);
IRole* pMember = m_pOwner->FindAroundRole(idMember);
CUser* pMemberUser = NULL;
if (pMember && pMember->GetID() != pUser->GetID()
&& pMember->QueryObj(OBJ_USER, IPP_OF(pMemberUser)))
{
setUser.push_back(pMemberUser);
}
}
}
// 然后搜索目标集合——包括满足条件的玩家和幻兽
POINT posThis;
for (int i=0; i<setUser.size(); i++)
{
CUser* pTarget = setUser[i];
posThis.x = pTarget->GetPosX();
posThis.y = pTarget->GetPosY();
if (pTarget->IsAlive() && CUser::IsInCircle(posThis, pos, nRange))
setRole.push_back(pTarget->QueryRole());
for (int k=0; k<pTarget->GetEudemonAmount(); k++)
{
CMonster* pEudemon = pTarget->QueryEudemonByIndex(i);
if (pEudemon)
{
posThis.x = pEudemon->GetPosX();
posThis.y = pEudemon->GetPosY();
if (pEudemon->IsAlive() && CUser::IsInCircle(posThis, pos, nRange))
setRole.push_back(pEudemon->QueryRole());
}
}
}
return true;
}
bool CMagic::ProcessMultiAttach()
{
CHECKF (m_pMagic);
CHECKF (m_pOwner);
ROLE_SET setRole;
POINT pos;
// 搜索目标集
if (m_pMagic->GetInt(MAGICDATA_CRIME))
{
if (!CollectTargetSet_Bomb(setRole, pos, LOCK_NONE))
return false;
}
else
{
pos.x = m_pOwner->GetPosX();
pos.y = m_pOwner->GetPosY();
if (!CollectTargetSet_Team(setRole))
return false;
}
int nPower = GetPower();
int nSecs = m_pMagic->GetInt(MAGICDATA_STEP);
int nTimes = m_pMagic->GetInt(MAGICDATA_TIMES);
DWORD nStatus = m_pMagic->GetInt(MAGICDATA_STATUS);
ASSERT(nPower>0);
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for (int i=0; i<setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
msg.AppendRole(pRole->GetID(), 0);
}
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
CheckCrime(&setRole);
for (int i=0; i<setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (!pRole || !pRole->IsAlive())
continue;
void* pTemp = NULL;
if(!pRole->QueryObj(OBJ_USER, IPP_OF(pTemp))
&& (nStatus == STATUS_LURKER /*|| nStatus == STATUS_ATKRANGE*/ || nStatus == STATUS_REFLECT || nStatus == STATUS_REFLECTMAGIC))
continue;
if(nStatus == STATUS_LURKER || nStatus == STATUS_ATKSPEED) // 不可叠加
CRole::DetachWellStatus(pRole);
// 暂时不做超级状态，有要求再说
// 疾行技能特殊处理
if (nStatus == STATUS_PELT && pRole->QueryStatus(STATUS_PELT))
CRole::DetachStatus(pRole, nStatus);
else
CRole::AttachStatus(pRole, nStatus, nPower, nSecs, nTimes);
// hint
if(nPower >= 30000)
{
int nPowerTimes = (nPower-30000) / 100;
MSGBUF szMsg;
switch (nStatus)
{
case STATUS_DEFENCE1:
case STATUS_DEFENCE2:
case STATUS_DEFENCE3:
{
sprintf(szMsg, STR_DEFENCE_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_ATTACK:
{
sprintf(szMsg, STR_ATTACK_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
}
}
else
{
int nPowerTimes = nPower;
MSGBUF szMsg;
switch(nStatus)
{
case STATUS_DEFENCE1:
case STATUS_DEFENCE2:
case STATUS_DEFENCE3:
{
sprintf(szMsg, STR_DEFENCE_ADD2, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_ATTACK:
{
sprintf(szMsg, STR_ATTACK_ADD2, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_SUPER_ATK:
{
sprintf(szMsg, STR_SUPER_ATK_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_SUPER_DEF:
{
sprintf(szMsg, STR_SUPER_DEF_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_SUPER_MATK:
{
sprintf(szMsg, STR_SUPER_MATK_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
case STATUS_SUPER_MDEF:
{
sprintf(szMsg, STR_SUPER_MDEF_ADD, nSecs, nPowerTimes);
pRole->SendSysMsg(szMsg);
}
break;
}
}
}
AwardExp(0); // false: not award battle exp
return true;
}
bool CMagic::ProcessMultiDetach()
{
CHECKF (m_pMagic);
CHECKF (m_pOwner);
int nPower = 0;
int nSecs = m_pMagic->GetInt(MAGICDATA_STEP);
int nTimes = m_pMagic->GetInt(MAGICDATA_TIMES);
DWORD nStatus = m_pMagic->GetInt(MAGICDATA_STATUS);
// PK场不能使用复活魔法
if (STATUS_DIE == nStatus)
{
if (m_pOwner->GetMap() && m_pOwner->GetMap()->IsPkField())
return false;
}
ROLE_SET setRole;
POINT pos;
// 搜索目标集
if (m_pMagic->GetInt(MAGICDATA_CRIME))
{
if (!CollectTargetSet_Bomb(setRole, pos, LOCK_NONE))
return false;
}
else
{
pos.x = m_pOwner->GetPosX();
pos.y = m_pOwner->GetPosY();
if (!CollectTargetSet_Team(setRole))
return false;
}
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), pos.x, pos.y, m_pOwner->GetDir()))
{
for (int i=0; i<setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (!pRole)
continue;
if (!pRole->IsAlive())
{
// 对于死亡的对象，只能使用复活魔法，并且只能对玩家使用
if (STATUS_DIE !=nStatus)
continue;
void* pTemp;
if (!pRole->QueryObj(OBJ_USER, IPP_OF(pTemp)))
continue;
}
msg.AppendRole(pRole->GetID(), 0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
CheckCrime(&setRole);
for (int i=0; i<setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (!pRole || !pRole->IsAlive())
continue;
if (STATUS_DETACH_ALL == nStatus)
{
CRole::DetachAllStatus(pRole);
}
else if (STATUS_DETACH_BADLY == nStatus)
{
CRole::DetachBadlyStatus(pRole);
}
else
{
IStatus* pStatus = pRole->QueryStatus(nStatus);
if (pStatus)
pStatus->ChangeData(nPower, nSecs, nTimes);
}
pRole->ClsStatus(nStatus, SYNCHRO_TRUE);
if (STATUS_DIE == nStatus)
{
CUser* pUser = NULL;
if (pRole->QueryObj(OBJ_USER, IPP_OF(pUser)))
{
bool bChgPos = false;
pUser->Reborn(bChgPos);
}
}
}
AwardExp(0);
return true;
}
bool CMagic::ProcessMultiCure()
{
CHECKF(m_pMagic);
ROLE_SET setRole;
vector<int> setPower;
POINT pos;
// 搜索目标集
if (m_pMagic->GetInt(MAGICDATA_CRIME))
{
if (!CollectTargetSet_Bomb(setRole, pos, LOCK_NONE))
return false;
}
else
{
pos.x = m_pOwner->GetPosX();
pos.y = m_pOwner->GetPosY();
if (!CollectTargetSet_Team(setRole))
return false;
}
// if (m_pMagic->GetSTrackAmount() > 0)
// LockTarget(true);
int nExp = 0;
// for (int k=0; k<m_nApplyTimes; k++)
{
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, m_pOwner->GetDir()))
{
for(int i = 0; i < setRole.size(); i++)
{
IRole* pRole = setRole[i];
if (pRole && pRole->IsAlive())
{
int nPower = GetPower();
if (nPower == ADJUST_FULL)
nPower = pRole->GetMaxLife() - pRole->GetLife();
// 超级回复
// if(m_pMagic && m_pMagic->GetInt(MAGICDATA_TYPE)>=SUPER_MAGIC_RECRUIT)
// nPower *= m_pOwner->GetSoulSum();
setPower.push_back(nPower);
msg.AppendRole(setRole[i]->GetID(), nPower);
}
else
setPower.push_back(0);
}
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
}
for(int i = 0; i < setRole.size(); i++)
{
if (!setRole[i]->IsAlive())
continue;
int nAddLife = ::CutOverflow(setPower[i], ::CutTrail(0, (int)(setRole[i]->GetMaxLife()-setRole[i]->GetLife())));
if(nAddLife > 0)
{
setRole[i]->AddAttrib(_USERATTRIB_LIFE, nAddLife, SYNCHRO_TRUE);
CUser* pUser=NULL;
if(setRole[i]->QueryObj(OBJ_USER, IPP_OF(pUser)))
pUser->BroadcastTeamLife();
}
CNpc* pNpc = NULL;
if (setRole[i])
{
setRole[i]->QueryObj(OBJ_NPC, IPP_OF(pNpc));
if(pNpc && pNpc->IsGoal())
{
nAddLife = nAddLife*GOAL_EXP_PERCENT/100;
}
}
nExp += nAddLife;
}
// if (m_pMagic->GetSTrackAmount() > 0)
// AdjustPosByTrack(k);
}
this->AwardExp(0);
return true;
}
bool CMagic::ProcessStealMoney()
{
CHECKF (m_pMagic);
CHECKF (m_pOwner);
m_setTargetLocked.clear();
IRole* pRole = m_pOwner->FindAroundRole(m_idTarget);
if (!(pRole && pRole->IsAlive()))
return false;
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, 0, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
int nMoneyStolen = 0;
CMonster* pMonster = NULL;
CUser* pUser = NULL;
if (pRole->QueryObj(OBJ_MONSTER, IPP_OF(pMonster)))
{
if ((pMonster->GetMaskData() & MASK_DISABLE_STEAL_MONEY) == 0)
{
pMonster->SetMaskData(MASK_DISABLE_STEAL_MONEY);
nMoneyStolen = pMonster->GetDropMoneyAvg()*(::RandGet(50)+1)/100;
}
}
else if (pRole->QueryObj(OBJ_USER, IPP_OF(pUser)))
{
nMoneyStolen = pUser->GetMoney()*(::RandGet(10)+1)/100;
pUser->SpendMoney(nMoneyStolen, true);
}
if (nMoneyStolen > 0)
{
if (!m_pOwner->QueryObj(OBJ_USER, IPP_OF(pUser)))
pUser = m_pOwner->QueryOwnerUser();
if (pUser)
pUser->AddMoney(nMoneyStolen);
}
this->AwardExp(0);
return true;
}
bool CMagic::ProcessKO()
{
CHECKF (m_pMagic);
CHECKF (m_pOwner);
IRole* pRole = m_pOwner->FindAroundRole(m_idTarget);
if (!(pRole && pRole->IsAlive()))
return false;
if (pRole->GetLife()*100 / pRole->GetMaxLife() > MAGIC_KO_LIFE_PERCENT)
return false;
int nPower = pRole->GetLife();
int nExp = nPower;
if (nPower)
{
if (pRole->TransferShield(HitByMagic(), m_pOwner, nPower))
{
}
else
{
pRole->AddAttrib(_USERATTRIB_LIFE, -1*nPower, SYNCHRO_TRUE);
pRole->BeAttack(HitByMagic(), m_pOwner, nPower);
if (!pRole->IsAlive())
m_pOwner->Kill(pRole, GetDieMode());
}
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPower, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
}
AwardExpOfLife(pRole, nExp);
return true;
}
bool CMagic::ProcessEscape()
{
CHECKF (m_pMagic);
CHECKF (m_pOwner);
IRole* pRole = m_pOwner->FindAroundRole(m_idTarget);
if(!pRole || !pRole->IsAlive())
return false;
const int MIN_TRANS_DISTANCE = 5;
const int MAX_TRANS_DISTANCE = 20;
const int DIV_DIR[] = {-1, 1};
const int MAX_TRY_TIMES = 20;
// find random pos
int nPosX = 0;
int nPosY = 0;
int i=0;
for (i=0; i<MAX_TRY_TIMES; i++)
{
int nDivX = ::RandGet(MAX_TRANS_DISTANCE - MIN_TRANS_DISTANCE + 1) + MIN_TRANS_DISTANCE;
int nDivY = ::RandGet(MAX_TRANS_DISTANCE - MIN_TRANS_DISTANCE + 1) + MIN_TRANS_DISTANCE;
nPosX = pRole->GetPosX() + DIV_DIR[::RandGet(2)] * nDivX;
nPosY = pRole->GetPosY() + DIV_DIR[::RandGet(2)] * nDivY;
if (pRole->GetMap() && pRole->GetMap()->IsStandEnable(nPosX, nPosY))
break;
}
if (i >= MAX_TRY_TIMES)
return false;
pRole->ActiveTransPos(nPosX, nPosY);
AwardExp(0);
return true;
}
/*
bool CMagic::ProcessFlashAttack()
{
CHECKF(m_pMagic);
CHECKF(m_pOwner);
m_setTargetLocked.clear();
IRole* pTarget = m_pOwner->FindAroundRole(m_idTarget);
if(!pTarget || !pTarget->IsAlive())
return false;
if (this->IsImmunity(pTarget))
return false;
if (m_pMagic->GetInt(MAGICDATA_FLOOR_ATTR)) // 0: need not check
{
int nAttr = m_pOwner->GetMap()->GetFloorAttr(pTarget->GetPosX(), pTarget->GetPosY());
if(m_pMagic->GetInt(MAGICDATA_FLOOR_ATTR) != nAttr)
return false;
}
m_setTargetLocked.push_back(pTarget->GetID());
LockTarget(true);
// 记录目标周围可以站立的坐标点
vector<POINT> setPosition;
int nSize = 0;
for (int i=-1; i<=1; i++)
{
for (int j=-1; j<=1; j++)
{
if (i!=0 || j!=0)
{
if (m_pOwner->GetMap()->IsStandEnable(pTarget->GetPosX()+i, pTarget->GetPosY()+j))
{
setPosition.resize(nSize+1);
setPosition[nSize].x = pTarget->GetPosX()+i;
setPosition[nSize].y = pTarget->GetPosY()+j;
++nSize;
}
}
}
}
int nTotalExp = 0;
const int FLASH_ATTACK_STEPS = 5; // 5次攻击
for (i=0; i<FLASH_ATTACK_STEPS; i++)
{
int nPower = CBattleSystem::CalcPower(HitByMagic(), m_pOwner, pTarget, GetPower());
// 广播法术效果
CMsgMagicEffect msg;
IF_OK(msg.Create(m_pOwner->GetID(), m_pMagic->GetInt(MAGICDATA_TYPE), m_pMagic->GetInt(MAGICDATA_LEVEL), m_idTarget, nPower, m_pOwner->GetDir()))
m_pOwner->BroadcastRoomMsg(&msg, INCLUDE_SELF);
// set crime status
CheckCrime(pTarget);
if (nPower)
{
int nLifeLost = __min(pTarget->GetLife(), nPower);
pTarget->AddAttrib(_USERATTRIB_LIFE, -1*nLifeLost, SYNCHRO_TRUE);
nTotalExp += nLifeLost;
pTarget->BeAttack(HitByMagic(), m_pOwner, nPower);
IStatus* pStatus = m_pOwner->QueryStatus(STATUS_DMG2LIFE);
if (pStatus)
{
int nLifeGot = ::CutTrail(0, MulDiv(nPower, pStatus->GetPower(), 100));
if (nLifeGot > 0)
m_pOwner->AddAttrib(_USERATTRIB_LIFE, nLifeGot, SYNCHRO_TRUE);
}
}
// TODO:
}
if (nTotalExp > 0)
AwardExpOfLife(pTarget, nTotalExp);
m_pos.x = pTarget->GetPosX();
m_pos.y = pTarget->GetPosY();
//? 未增加武器熟练度，也未损耗双方装备。
// drop weapon in weapon skill
if(m_pMagic->GetInt(MAGICDATA_USE_XP) == TYPE_KONGFU && m_pMagic->GetInt(MAGICDATA_DROPWEAPON) == THROW_WERPONR_TARGET)
{
CItem* pWeapon = m_pOwner->GetWeaponR();
IF_OK(pWeapon)
{
POINT pos;
pos.x = pTarget->GetPosX();
pos.y = pTarget->GetPosY();
m_pOwner->GetMap()->FindDropItemCell(THROW_WEAPON_DROP_RANGE, &pos);
m_pOwner->DropItem(pWeapon->GetID(), pos.x, pos.y); // 没找到CELL也扔，但会重叠。
}
}
return true;
}*/
| [
"rpgsky.com@cc92e6ba-efcf-11de-bf31-4dec8810c1c1"
]
| [
[
[
1,
3567
]
]
]
|
6eeb64fd8ad3b52cb2590e4aa3f0269849f8fe19 | e2e49023f5a82922cb9b134e93ae926ed69675a1 | /tools/aosdesigner/view/EditionToolView.hpp | e7840b0fcffc0bc64594a02c240e94da96ee49d7 | []
| no_license | invy/mjklaim-freewindows | c93c867e93f0e2fe1d33f207306c0b9538ac61d6 | 30de8e3dfcde4e81a57e9059dfaf54c98cc1135b | refs/heads/master | 2021-01-10T10:21:51.579762 | 2011-12-12T18:56:43 | 2011-12-12T18:56:43 | 54,794,395 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,575 | hpp | #ifndef HGUARD_AOSD_VIEW_EDITIONTOOLVIEW_HPP__
#define HGUARD_AOSD_VIEW_EDITIONTOOLVIEW_HPP__
#pragma once
#include <QDockWidget>
namespace aosd
{
namespace core
{
class Project;
class EditionSession;
}
namespace view
{
class EditionToolView
: public QDockWidget
{
Q_OBJECT
protected:
EditionToolView();
virtual ~EditionToolView();
void activate() { change_state( true ); }
void deactivate() { change_state( false ); }
virtual void begin_edition_session( const core::EditionSession& edition_session ) = 0;
virtual void end_edition_session( const core::EditionSession& edition_session ) = 0;
virtual void connect_edition( const core::EditionSession& edition_session ) = 0;
virtual void disconnect_edition( const core::EditionSession& edition_session ) = 0;
virtual void connect_project( const core::Project& project ) {}
virtual void disconnect_project( const core::Project& project ) {}
private slots:
void react_project_open( const core::Project& );
void react_project_closed( const core::Project& );
void react_edition_begin();
void react_edition_end();
void react_edition_session_begin( const core::EditionSession& edition_session );
void react_edition_session_end( const core::EditionSession& edition_session );
void react_edition_selected( const core::EditionSession& edition_session );
void react_edition_deselected( const core::EditionSession& edition_session );
private:
void change_state( bool is_active );
};
}
}
#endif
| [
"klaim@localhost"
]
| [
[
[
1,
65
]
]
]
|
a572718b15f6491d53a2a5a2f1b8e3ee9f0b7b16 | 6131815bf1b62accfc529c2bc9db21194c7ba545 | /FrameworkApp/D3D9Window.cpp | 820e4029d8d0e705d8853d7eeb25e4f4c583de73 | []
| no_license | dconefourseven/honoursproject | b2ee664ccfc880c008f29d89aad03d9458480fc8 | f26b967fda8eb6937f574fd6f3eb76c8fecf072a | refs/heads/master | 2021-05-29T07:14:35.261586 | 2011-05-15T18:27:49 | 2011-05-15T18:27:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,196 | cpp | #include "D3D9Window.h"
//#pragma comment (lib, "d3d9.lib")
D3D9Window::D3D9Window(void)
:Window()
{
g_pD3D = NULL; // Used to create the D3DDevice
g_pd3dDevice = NULL;
}
D3D9Window::~D3D9Window(void)
{
}
HRESULT D3D9Window::InitWindow( HINSTANCE hInstance, int nCmdShow )
{
return Window::InitWindow(hInstance, nCmdShow);
}
HRESULT D3D9Window::InitDevice()
{
// Create the D3D object, which is needed to create the D3DDevice.
if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;
// Set up the structure used to create the D3DDevice. Most parameters are
// zeroed out. We set Windowed to TRUE, since we want to do D3D in a
// window, and then set the SwapEffect to "discard", which is the most
// efficient method of presenting the back buffer to the display. And
// we request a back buffer format that matches the current desktop display
// format.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof( d3dpp ) );
d3dpp.Windowed = true;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
//d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
d3dpp.BackBufferWidth = getWindowWidth();
d3dpp.BackBufferHeight = getWindowHeight();
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24X8;
//d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
// Create the Direct3D device. Here we are using the default adapter (most
// systems only have one, unless they have multiple graphics hardware cards
// installed) and requesting the HAL (which is saying we want the hardware
// device rather than a software one). Software vertex processing is
// specified since we know it will work on all cards. On cards that support
// hardware vertex processing, though, we would see a big performance gain
// by specifying hardware vertex processing.
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
{
return E_FAIL;
}
// Device state would normally be set here
return S_OK;
}
void D3D9Window::CleanupDevice()
{
if( g_pd3dDevice != NULL )
g_pd3dDevice->Release();
if( g_pD3D != NULL )
g_pD3D->Release();
}
//void D3D9Window::Render(Game* pGame)
//{
// //if( NULL == g_pd3dDevice )
// // return;
//
// // // Clear the backbuffer to a blue color
// // g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(100, 149, 237), 1.0f, 0 );
//
// // // Begin the scene
// // if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
// // {
// // // Rendering of scene objects can happen here
// pGame->Draw();
// // // End the scene
// // g_pd3dDevice->EndScene();
// // }
//
// // // Present the backbuffer contents to the display
// // g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
//}
| [
"davidclarke1990@fa56ba20-0011-6cdf-49b4-5b20436119f6"
]
| [
[
[
1,
94
]
]
]
|
d6722154f5a554274cba8239b6cbcbe0c414e586 | 72449e9f77d221deddcc5371901c61303387ef09 | /Layers/Layer.h | 7cdc29fef870b9b763ff2b87084f7c0787b223fc | []
| no_license | dsrbecky/PipeWars | a427f006292033f361260b0075929ade9b3f0c44 | 109a05e3db35f3725647d917a770332d8badeecc | refs/heads/master | 2020-05-20T11:23:05.394233 | 2010-01-14T08:23:06 | 2010-01-14T16:00:25 | 958,353 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,113 | h | #ifndef __Layer__
#define __Layer__
class Layer
{
public:
static const int maxKey = 0x100;
bool keyDown[maxKey];
bool keyToggled[maxKey];
bool keyToggled_Alt[maxKey];
Layer()
{
ZeroMemory(keyDown, sizeof(keyDown));
ZeroMemory(keyToggled, sizeof(keyToggled));
ZeroMemory(keyToggled_Alt, sizeof(keyToggled_Alt));
}
// Return true to indicate that the event was handled and should be no longer processed
virtual bool KeyboardProc(UINT nChar, bool bKeyDown, bool bAltDown)
{
if (nChar < maxKey) {
if (!bAltDown) {
keyDown[nChar] = bKeyDown;
}
if (bKeyDown) {
if (bAltDown) {
keyToggled_Alt[nChar] = !keyToggled_Alt[nChar];
} else {
keyToggled[nChar] = !keyToggled[nChar];
}
}
}
return false;
}
virtual bool MouseProc(bool bLeftButtonDown, bool bRightButtonDown, bool bMiddleButtonDown, int nMouseWheelDelta, int xPos, int yPos) { return false; }
virtual void FrameMove(double fTime, float fElapsedTime) {}
virtual void Render(IDirect3DDevice9* dev) {}
virtual void ReleaseDeviceResources() {}
};
#endif | [
"[email protected]"
]
| [
[
[
1,
44
]
]
]
|
664f3ee15a2cfc111254805fcb5a9e7021b7c863 | 27bf1951e08b36c01374014a6da855a706680f7b | /USACO-Solution/src/2.1.3.cpp | 355210c5b3a906fbd9ae6def56d909cd599eb9b2 | []
| no_license | zinking/algorithm-exercise | 4c520fd3ff6c14804d32e4ea427e5f7809cc7315 | c58902709e9f12146d3d1f66610306e5ff19cfff | refs/heads/master | 2016-09-05T22:27:19.791962 | 2009-07-24T04:45:18 | 2009-07-24T04:45:18 | 32,133,027 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,928 | cpp | /*
ID: zinking1
PROG: castle
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <climits>
using namespace std;
ifstream fin("castle.in");
ofstream fout("castle.out");
#define out fout
#define in fin
int n,m;
int c[50*50];
int data[50][50];
int colors[50][50];
int color_cnt;
const int W = 1;
const int N = 2;
const int E = 4;
const int S = 8;
void color(int i,int j,int color);
void solve()
{
in>>m>>n;
memset(c,0,sizeof(0));
memset(colors,-1,sizeof(colors));
color_cnt = 0;
for(int i=0;i<n;++i)
for(int j=0;j<m;++j){
in>>data[i][j];
}
for(int i=0;i<n;++i)
for(int j=0;j<m;++j){
if(colors[i][j]==-1){
color(i,j,color_cnt++);
}
}
out<<color_cnt<<endl;
int largest = INT_MIN;
for(int i=0;i<color_cnt;++i){
largest = max(largest,c[i]);
}
out<<largest<<endl;
largest = INT_MIN;
int walli,wallj;
char dir;
for(int j=0;j<m;++j)
for(int i=n-1;i>=0;--i)
{
if(i-1>=0){
if( colors[i][j]!=colors[i-1][j]){
if( largest<c[colors[i][j]]+c[colors[i-1][j]]){
largest=c[colors[i][j]]+c[colors[i-1][j]];
walli = i;
wallj = j;
dir = 'N';
}
}
}
if(j+1<m){
if( colors[i][j]!=colors[i][j+1]){
if(largest<c[colors[i][j]]+c[colors[i][j+1]]){
largest = c[colors[i][j]]+c[colors[i][j+1]];
walli = i;
wallj = j;
dir = 'E';
}
}
}
}
out<<largest<<endl;
out<<walli+1<<' '<<wallj+1<<' '<<dir<<endl;
}
void color(int i,int j,int clr)
{
if(colors[i][j]!=-1)
return;
colors[i][j] = clr;
c[clr]++;
if((data[i][j]&S)==0&&(i+1<n)){
color(i+1,j,clr);
}
if((data[i][j]&E)==0&&(j+1<m)){
color(i,j+1,clr);
}
if((data[i][j]&W)==0&&(j-1>=0)){
color(i,j-1,clr);
}
if((data[i][j]&N)==0&&(i-1>=0)){
color(i-1,j,clr);
}
}
int main(int argc,char *argv[])
{
solve();
return 0;
}
//#include <iostream>
//#include <fstream>
//#include <string>
//#include <algorithm>
//
//using namespace std;
//const int WEST_DIRECTION = 0x00000001;
//const int NORTH_DIRECTION = 0x00000002;
//const int EAST_DIRECTION = 0x00000004;
//const int SOUTH_DIRECTION = 0x00000008;
//
//const int MAX_N = 50;
//int Room[MAX_N][MAX_N];
//int RoomStatus[MAX_N][MAX_N];
//int AdjMatrix[MAX_N][MAX_N];
//
//int M=0, N=0;
//int room_num =0;
//int RoomSize[MAX_N];
//
//void floodFill( int x, int y, int room_no ){
// if( RoomStatus[x][y] != 0 ) return;
// RoomStatus[x][y] = room_no;
// RoomSize[room_no]++;
// if( x > 0 ){//not out of bound
// if( !(Room[x][y] & NORTH_DIRECTION) ) floodFill( x-1, y , room_no);
// else{// there is a wall north
// if( RoomStatus[x-1][y] != 0 && RoomStatus[x-1][y] != room_no ) {
// AdjMatrix[room_no][ RoomStatus[x-1][y] ] =1;
// AdjMatrix[RoomStatus[x-1][y] ][room_no ] =1;
// }
// }
// }
//
// if( x < M-1 ){
// if( !(Room[x][y] & SOUTH_DIRECTION) ) floodFill( x+1, y , room_no );
// else{// there is a wall north
// if( RoomStatus[x+1][y] != 0 && RoomStatus[x+1][y] != room_no ){
// AdjMatrix[room_no][ RoomStatus[x+1][y] ] =1;
// AdjMatrix[RoomStatus[x+1][y]][ room_no ] =1;
// }
// }
// }
//
// if( y > 0 ){//not out of bound
// if( !(Room[x][y] & WEST_DIRECTION) ) floodFill( x, y-1 , room_no);
// else{// there is a wall north
// if( RoomStatus[x][y-1] != 0 && RoomStatus[x][y-1] != room_no ){
// AdjMatrix[room_no][ RoomStatus[x][y-1] ] =1;
// AdjMatrix[RoomStatus[x][y-1]][ room_no ] =1;
// }
// }
// }
//
// if( y < N-1 ){
// if( !(Room[x][y] & EAST_DIRECTION) ) floodFill( x, y+1 , room_no);
// else{// there is a wall north
// if( RoomStatus[x][y+1] != 0 && RoomStatus[x][y+1] != room_no ){
// AdjMatrix[room_no][ RoomStatus[x][y+1] ] =1;
// AdjMatrix[RoomStatus[x][y+1]][ room_no ] =1;
// }
// }
// }
//}
//
//void debug(){
// cout << "AdjMatrix "<< endl;
// for ( int i=1; i<room_num+1; i++ ){
// for( int j=1; j<room_num+1; j++){
// cout << AdjMatrix[i][j]<<" ";
// }
// cout << endl;
// }
//
// cout << "RoomStatus " << endl;
// for( int i=0; i<M; i++ ){
// for( int j=0; j<N; j++ ){
// cout << RoomStatus[i][j] << " ";
// }
// cout << endl;
// }
//}
//
//void color_walls(){
// for( int i=0; i<M; i++ ){
// for( int j=0; j<N; j++ ){
// if( RoomStatus[i][j] == 0 ) floodFill( i,j,++room_num);
// }
// }
//}
//
//
//
//
//
//int main() {
// ofstream fout ("castle.out");
// ifstream fin ("castle.in");
//
// fin >> N >> M;
// for( int i=0; i<M; i++ ){
// for( int j=0; j<N; j++ ){
// fin >> Room[i][j];
// }
// }
//
// color_walls();
// fout << room_num << endl;
//
// int *pBiggestRoom = max_element( RoomSize,RoomSize+room_num+1 );
// fout << *pBiggestRoom << endl;
// int pBiggestRoomNO = pBiggestRoom - RoomSize;
// int secondBiggestRoomSize = -1;
// int secondBiggestRoomNo = 0;
//
// int merged = *pBiggestRoom;
//
// //debug();
//
// //for( int i=1; i<room_num+1; i++ ) {
// // if( AdjMatrix[i][pBiggestRoomNO] == 1 ){
// // if( RoomSize[i] > secondBiggestRoomSize ) {
// // secondBiggestRoomSize = RoomSize[i];//roomsize index from 1
// // secondBiggestRoomNo = i;//index
// // }
// // }
// //}
//
// for( int i=1; i<room_num+1; i++ ){
// for( int j=1; j<i; j++ ){
// if( AdjMatrix[i][j] == 1 ){
// if( RoomSize[i] + RoomSize[j] > merged ){
// merged = RoomSize[i] + RoomSize[j];
// pBiggestRoomNO = i;
// secondBiggestRoomNo = j;
// }
// }
// }
// }
//
// //int merged = *pBiggestRoom + secondBiggestRoomSize;
// fout << merged << endl;
//
//
// bool found = false;
// for( int i=M-1; i>=0; i--){
//
// for( int j=N-1; j>=0; j--){
// if( RoomStatus[i][j] != pBiggestRoomNO && RoomStatus[i][j] != secondBiggestRoomNo ) continue;
// if( RoomStatus[i][j-1] != pBiggestRoomNO && RoomStatus[i][j-1] != secondBiggestRoomNo ) continue;
// if( RoomStatus[i][j-1] == RoomStatus[i][j] ) continue;
// if( RoomSize[ RoomStatus[i][j] ] + RoomSize[ RoomStatus[i][j-1] ] == merged){
// fout << i+1 << " " << j << " " << "E" << endl;
// found = true;
// break;
// }
// }
// if( found ) break;
//
// for( int j=0; j<=N-1; j++){
// if( RoomStatus[i][j] != pBiggestRoomNO && RoomStatus[i][j] != secondBiggestRoomNo ) continue;
// if( RoomStatus[i-1][j] != pBiggestRoomNO && RoomStatus[i-1][j] != secondBiggestRoomNo ) continue;
// if( RoomSize[ RoomStatus[i][j] ] + RoomSize[ RoomStatus[i-1][j] ] == merged){
// fout << i+1 << " " << j+1 << " " << "N" << endl;
// found = true;
// break;
// }
// }
// if( found ) break;
//
// }
//
//
//
// return 0;
//}
| [
"zinking3@e423e194-685c-11de-ba0c-230037762ff9"
]
| [
[
[
1,
310
]
]
]
|
a5a05d8fe138bd11d8e92bdf0ea47b5d725857c2 | 5a39be53de11cddb52af7d0b70b56ef94cc52d35 | /doc/P3相关工具包/ChiAnalyzer/Segment/Segment.cpp | 8bb6fa97fa528675aa22bbde5534d8d2adbfb0e6 | []
| no_license | zchn/jsepku | 2b76eb5d118f86a5c942a9f4ec25a5adae24f802 | 8290fef5ff8abaf62cf050cead489dc7d44efa5f | refs/heads/master | 2016-09-10T19:44:23.882210 | 2008-01-01T07:32:13 | 2008-01-01T07:32:13 | 33,052,475 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 16,573 | cpp | //此部分代码使用 计算所汉语词法分析系统 ICTCLAS
//
//此部分代码为免费使用 版权保护
//
//特在此特别申明
//
//
//Author: Kevin Zhang (张华平); Qun Liu(刘群)
//
//Inst. of Computing Tech., Chinese Academy of Sciences
//
//Email: [email protected]
//
//Tel: +86-10-88455001/5/7 to 714
//////////////////////////////////////////////////////////////////////
/****************************************************************************
*
* Copyright (c) 2000, 2001
* Machine Group
* Software Research Lab.
* Institute of Computing Tech.
* Chinese Academy of Sciences
* All rights reserved.
*
* This file is the confidential and proprietary property of
* Institute of Computing Tech. and the posession or use of this file requires
* a written license from the author.
* Filename: Segment.cpp
* Abstract:
* implementation of the CSegment class.
* Author: Kevin Zhang
* ([email protected])
* Date: 2002-4-23
*
* Notes: N-Shortest paths Word segmentation
*
****************************************************************************/
//#include "stdafx.h"
#include "Segment.h"
#include "..\\Utility\\Dictionary.h"
#include "..\\Utility\\Utility.h"
#include "NShortPath.h"
#include <string.h>
#include <math.h>
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CSegment::CSegment()
{
//malloc buffer
m_pWordSeg=new PWORD_RESULT[MAX_SEGMENT_NUM];
for(int i=0;i<MAX_SEGMENT_NUM;i++)
{
m_pWordSeg[i]=new WORD_RESULT[MAX_WORDS];
}
m_npWordPosMapTable=0;//Record the start position of possible words
m_nWordCount=0;//Record the End position of possible words
m_graphOptimum.SetRowFirst();//Set row first
}
CSegment::~CSegment()
{
//free buffer
for(int i=0;i<MAX_SEGMENT_NUM;i++)
{
delete m_pWordSeg[i];
}
delete m_pWordSeg;
}
bool CSegment::Segment(char *sSentence,CDictionary &dictCore,int nResultCount)
{
int **nSegRoute;//The segmentation route
nSegRoute=new int*[MAX_SEGMENT_NUM];
for(int i=0;i<MAX_SEGMENT_NUM;i++)
{
nSegRoute[i]=new int[MAX_SENTENCE_LEN/2];
memset(nSegRoute[i],0,MAX_SENTENCE_LEN/2*sizeof(int));
}
m_graphSeg.m_segGraph.SetRowFirst(false);
m_graphOptimum.SetRowFirst(false);
m_graphSeg.GenerateWordNet(sSentence,dictCore);
CNShortPath sp(&m_graphSeg.m_segGraph,nResultCount);
sp.ShortPath();
sp.Output((int **)nSegRoute,false,&m_nSegmentCount);
m_graphOptimum.SetEmpty();//Set graph optimum empty
i=0;
while(i<m_nSegmentCount)
{
GenerateWord(nSegRoute,i);
//Gernerate word according the Segmentation route
i++;
}
//free the memory
for(i=0;i<MAX_SEGMENT_NUM;i++)
{
delete [] nSegRoute[i];//free the pointer memory
}
delete [] nSegRoute;//free the pointer array
return true;
}
//Generate Word according the segmentation route
bool CSegment::GenerateWord(int **nSegRoute, int nIndex)
{
unsigned int i=0,k=0;
int j,nStartVertex,nEndVertex,nPOS;
char sAtom[WORD_MAXLENGTH],sNumCandidate[100],sCurWord[100];
ELEMENT_TYPE fValue;
while(nSegRoute[nIndex][i]!=-1&&nSegRoute[nIndex][i+1]!=-1&&nSegRoute[nIndex][i]<nSegRoute[nIndex][i+1])
{
nStartVertex=nSegRoute[nIndex][i];
j=nStartVertex;//Set the start vertex
nEndVertex=nSegRoute[nIndex][i+1];//Set the end vertex
nPOS=0;
m_graphSeg.m_segGraph.GetElement(nStartVertex,nEndVertex,&fValue,&nPOS);
sAtom[0]=0;
while(j<nEndVertex)
{//Generate the word according the segmentation route
strcat(sAtom,m_graphSeg.m_sAtom[j]);
j++;
}
m_pWordSeg[nIndex][k].sWord[0]=0;//Init the result ending
strcpy(sNumCandidate,sAtom);
while(sAtom[0]!=0&&(IsAllNum((unsigned char *)sNumCandidate)||IsAllChineseNum(sNumCandidate)))
{//Merge all seperate continue num into one number
//sAtom[0]!=0: add in 2002-5-9
strcpy(m_pWordSeg[nIndex][k].sWord,sNumCandidate);
//Save them in the result segmentation
i++;//Skip to next atom now
sAtom[0]=0;
while(j<nSegRoute[nIndex][i+1])
{//Generate the word according the segmentation route
strcat(sAtom,m_graphSeg.m_sAtom[j]);
j++;
}
strcat(sNumCandidate,sAtom);
}
unsigned int nLen=strlen(m_pWordSeg[nIndex][k].sWord);
if(nLen==4&&CC_Find("第上成±—＋∶·．／",m_pWordSeg[nIndex][k].sWord)||nLen==1&&strchr("+-./",m_pWordSeg[nIndex][k].sWord[0]))
{//Only one word
strcpy(sCurWord,m_pWordSeg[nIndex][k].sWord);//Record current word
i--;
}
else if(m_pWordSeg[nIndex][k].sWord[0]==0)//Have never entering the while loop
{
strcpy(m_pWordSeg[nIndex][k].sWord,sAtom);
//Save them in the result segmentation
strcpy(sCurWord,sAtom);//Record current word
}
else
{//It is a num
if(strcmp("－－",m_pWordSeg[nIndex][k].sWord)==0||strcmp("—",m_pWordSeg[nIndex][k].sWord)==0||m_pWordSeg[nIndex][k].sWord[0]=='-'&&m_pWordSeg[nIndex][k].sWord[1]==0)//The delimiter "－－"
{
nPOS=30464;//'w'*256;Set the POS with 'w'
i--;//Not num, back to previous word
}
else
{//Adding time suffix
char sInitChar[3];
unsigned int nCharIndex=0;//Get first char
sInitChar[nCharIndex]=m_pWordSeg[nIndex][k].sWord[nCharIndex];
if(sInitChar[nCharIndex]<0)
{
nCharIndex+=1;
sInitChar[nCharIndex]=m_pWordSeg[nIndex][k].sWord[nCharIndex];
}
nCharIndex+=1;
sInitChar[nCharIndex]='\0';
if(k>0&&(abs(m_pWordSeg[nIndex][k-1].nHandle)==27904||abs(m_pWordSeg[nIndex][k-1].nHandle)==29696)&&(strcmp(sInitChar,"—")==0||sInitChar[0]=='-')&&(strlen(m_pWordSeg[nIndex][k].sWord)>nCharIndex))
{//3-4月 //27904='m'*256
//Split the sInitChar from the original word
strcpy(m_pWordSeg[nIndex][k+1].sWord,m_pWordSeg[nIndex][k].sWord+nCharIndex);
m_pWordSeg[nIndex][k+1].dValue=m_pWordSeg[nIndex][k].dValue;
m_pWordSeg[nIndex][k+1].nHandle=27904;
m_pWordSeg[nIndex][k].sWord[nCharIndex]=0;
m_pWordSeg[nIndex][k].dValue=0;
m_pWordSeg[nIndex][k].nHandle=30464;//'w'*256;
m_graphOptimum.SetElement(nStartVertex,nStartVertex+1,m_pWordSeg[nIndex][k].dValue,m_pWordSeg[nIndex][k].nHandle,m_pWordSeg[nIndex][k].sWord);
nStartVertex+=1;
k+=1;
}
nLen=strlen(m_pWordSeg[nIndex][k].sWord);
if((strlen(sAtom)==2&&CC_Find("月日时分秒",sAtom))||strcmp(sAtom,"月份")==0)
{//2001年
strcat(m_pWordSeg[nIndex][k].sWord,sAtom);
strcpy(sCurWord,"未##时");
nPOS=-29696;//'t'*256;//Set the POS with 'm'
}
else if(strcmp(sAtom,"年")==0)
{
if(IsYearTime(m_pWordSeg[nIndex][k].sWord))//strncmp(sAtom,"年",2)==0&&
{//1998年，
strcat(m_pWordSeg[nIndex][k].sWord,sAtom);
strcpy(sCurWord,"未##时");
nPOS=-29696;//Set the POS with 't'
}
else
{
strcpy(sCurWord,"未##数");
nPOS=-27904;//Set the POS with 'm'
i--;//Can not be a time word
}
}
else
{
//早晨/t 五点/t
if(strcmp(m_pWordSeg[nIndex][k].sWord+strlen(m_pWordSeg[nIndex][k].sWord)-2,"点")==0)
{
strcpy(sCurWord,"未##时");
nPOS=-29696;//Set the POS with 't'
}
else
{
if(!CC_Find("∶·．／",m_pWordSeg[nIndex][k].sWord+nLen-2)&&m_pWordSeg[nIndex][k].sWord[nLen-1]!='.'&&m_pWordSeg[nIndex][k].sWord[nLen-1]!='/')
{
strcpy(sCurWord,"未##数");
nPOS=-27904;//'m'*256;Set the POS with 'm'
}
else if(nLen>strlen(sInitChar))
{//Get rid of . example 1.
if(m_pWordSeg[nIndex][k].sWord[nLen-1]=='.'||m_pWordSeg[nIndex][k].sWord[nLen-1]=='/')
m_pWordSeg[nIndex][k].sWord[nLen-1]=0;
else
m_pWordSeg[nIndex][k].sWord[nLen-2]=0;
strcpy(sCurWord,"未##数");
nPOS=-27904;//'m'*256;Set the POS with 'm'
i--;
}
}
i--;//Not num, back to previous word
}
}
fValue=0;
nEndVertex=nSegRoute[nIndex][i+1];//Ending POS changed to latter
}
m_pWordSeg[nIndex][k].nHandle=nPOS;//Get the POS of current word
m_pWordSeg[nIndex][k].dValue=fValue;//(int)(MAX_FREQUENCE*exp(-fValue));//Return the frequency of current word
m_graphOptimum.SetElement(nStartVertex,nEndVertex,fValue,nPOS,sCurWord);
//Generate optimum segmentation graph according the segmentation result
i++;//Skip to next atom
k++;//Accept next word
}
m_pWordSeg[nIndex][k].sWord[0]=0;
m_pWordSeg[nIndex][k].nHandle=-1;//Set ending
return true;
}
//DEL bool CSegment::GetSegmentResult(int nIndex,char *sResult)
//DEL {
//DEL int i=0;
//DEL char sTempBuffer[WORD_MAXLENGTH];
//DEL sResult[0]=0;
//DEL if(nIndex<0||nIndex>=m_nSegmentCount)
//DEL return false;
//DEL while(m_WordSeg[nIndex][i].sWord[0]!=0)
//DEL {
//DEL sprintf(sTempBuffer,"%s/%c%c",m_WordSeg[nIndex][i].sWord,m_WordSeg[nIndex][i].nHandle/256,m_WordSeg[nIndex][i].nHandle%256);
//DEL strcat(sResult,sTempBuffer);
//DEL strcat(sResult," ");
//DEL i++;
//DEL }
//DEL return true;
//DEL }
//Word Segmentation based on optimum segmentation graph
//After unknown word recognition
bool CSegment::OptimumSegmet(int nResultCount)
{
int **nSegRoute;//The segmentation route
nSegRoute=new int*[MAX_SEGMENT_NUM];
for(int i=0;i<MAX_SEGMENT_NUM;i++)
{
nSegRoute[i]=new int[MAX_SENTENCE_LEN/2];
}
CNShortPath sp(&m_graphOptimum,nResultCount);
sp.ShortPath();
sp.Output((int **)nSegRoute,false,&m_nSegmentCount);
i=0;
m_graphSeg.m_segGraph=m_graphOptimum;
m_graphOptimum.SetEmpty();//Set graph optimum empty
while(i<m_nSegmentCount)
{
GenerateWord(nSegRoute,i);
//Gernerate word according the Segmentation route
i++;
}
//free the memory
for(i=0;i<MAX_SEGMENT_NUM;i++)
{
delete [] nSegRoute[i];//free the pointer memory
}
delete [] nSegRoute;//free the pointer array
return true;
}
int CSegment::GetResultCount(PWORD_RESULT pItem)
{
int nCount=0;
while(pItem[nCount].sWord[0]!=0)
{
nCount+=1;
}
return nCount;
}
bool CSegment::GetLastWord(PWORD_RESULT pItem, char *sWordRet)
{
int nCount=0;
sWordRet[0]=0;
while(pItem[nCount].sWord[0]!=0)
{
strcpy(sWordRet,pItem[nCount].sWord);
nCount+=1;
}
return !sWordRet[0];
}
bool CSegment::IsYearTime(char *sNum)
{//Judge whether the sNum is a num genearating year
unsigned int nLen=strlen(sNum);
char sTemp[3];
strncpy(sTemp,sNum,2);
sTemp[2]=0;
if(IsAllSingleByte((unsigned char *)sNum)&&(nLen==4||nLen==2&&sNum[0]>'4'))//1992年, 90年
return true;
if(IsAllNum((unsigned char *)sNum)&&(nLen>=6||nLen==4&&CC_Find("５６７８９",sTemp)))
return true;
if(GetCharCount("零○一二三四五六七八九壹贰叁肆伍陆柒捌玖",sNum)==(int)nLen/2&&nLen>=3)
return true;
if(nLen==8&&GetCharCount("千仟零○",sNum)==2)//二仟零二年
return true;
if(nLen==2&&GetCharCount("千仟",sNum)==1)
return true;
if(nLen==4&&GetCharCount("甲乙丙丁戊己庚辛壬癸",sNum)==1&&GetCharCount("子丑寅卯辰巳午未申酉戌亥",sNum+2)==1)
return true;
return false;
}
//CDynamicArray &aWord: the words array
//CDynamicArray &aWordBinaryNet:the net between words
//double dSmoothingPara: the parameter of data smoothing
//CDictionary &DictBinary: the binary dictionary
//CDictionary &DictCore: the Core dictionary
bool CSegment::BiGraphGenerate(CDynamicArray &aWord, CDynamicArray &aBinaryWordNet,double dSmoothingPara,CDictionary &DictBinary,CDictionary &DictCore)
{
PARRAY_CHAIN pTail,pCur,pNextWords;//Temp buffer
unsigned int nWordIndex=0,nTwoWordsFreq=0,nCurWordIndex,nNextWordIndex;
//nWordIndex: the index number of current word
double dCurFreqency,dValue,dTemp;
char sTwoWords[WORD_MAXLENGTH];
m_nWordCount=aWord.GetTail(&pTail);//Get tail element and return the words count
if(m_npWordPosMapTable)
{//free buffer
delete [] m_npWordPosMapTable;
m_npWordPosMapTable=0;
}
if(m_nWordCount>0)//Word count is greater than 0
m_npWordPosMapTable=new int[m_nWordCount];//Record the position of possible words
pCur=aWord.GetHead();
while(pCur!=NULL)//Set the position map of words
{
m_npWordPosMapTable[nWordIndex++]=pCur->row*MAX_SENTENCE_LEN+pCur->col;
pCur=pCur->next;
}
pCur=aWord.GetHead();
while(pCur!=NULL)//
{
if(pCur->nPOS>=0)//It's not an unknown words
dCurFreqency=pCur->value;
else//Unknown words
dCurFreqency=DictCore.GetFrequency(pCur->sWord,2);
aWord.GetElement(pCur->col,-1,pCur,&pNextWords);//Get next words which begin with pCur->col
while(pNextWords&&pNextWords->row==pCur->col)//Next words
{
//Current words frequency
strcpy(sTwoWords,pCur->sWord);
strcat(sTwoWords,WORD_SEGMENTER);
strcat(sTwoWords,pNextWords->sWord);
nTwoWordsFreq=DictBinary.GetFrequency(sTwoWords,3);
//Two linked Words frequency
dTemp=(double)1/MAX_FREQUENCE;
//Smoothing
dValue=-log(dSmoothingPara*(1+dCurFreqency)/(MAX_FREQUENCE+80000)+(1-dSmoothingPara)*((1-dTemp)*nTwoWordsFreq/(1+dCurFreqency)+dTemp));
//-log{a*P(Ci-1)+(1-a)P(Ci|Ci-1)} Note 0<a<1
if(pCur->nPOS<0)//Unknown words: P(Wi|Ci);while known words:1
dValue+=pCur->value;
//Get the position index of current word in the position map table
nCurWordIndex=BinarySearch(pCur->row*MAX_SENTENCE_LEN+pCur->col,m_npWordPosMapTable,m_nWordCount);
nNextWordIndex=BinarySearch(pNextWords->row*MAX_SENTENCE_LEN+pNextWords->col,m_npWordPosMapTable,m_nWordCount);
aBinaryWordNet.SetElement(nCurWordIndex,nNextWordIndex,dValue,pCur->nPOS);
pNextWords=pNextWords->next;//Get next word
}
pCur=pCur->next;
}
return true;
}
bool CSegment::BiSegment(char *sSentence, double dSmoothingPara, CDictionary &dictCore, CDictionary &dictBinary, unsigned int nResultCount)
{
int **nSegRoute;//The segmentation route
nSegRoute=new int*[MAX_SEGMENT_NUM];
unsigned int nLen=strlen(sSentence)+10;
for(int i=0;i<MAX_SEGMENT_NUM;i++)
{
nSegRoute[i]=new int[nLen/2];
memset(nSegRoute[i],-1,nLen/2*sizeof(int));
}
m_graphSeg.GenerateWordNet(sSentence,dictCore,true);//Generate words array
CDynamicArray aBiwordsNet;
BiGraphGenerate(m_graphSeg.m_segGraph,aBiwordsNet,dSmoothingPara,dictBinary,dictCore);
//Generate the biword link net
CNShortPath sp(&aBiwordsNet,nResultCount);
sp.ShortPath();
sp.Output(nSegRoute,false,&m_nSegmentCount);
m_graphOptimum.SetEmpty();//Set graph optimum empty
i=0;
while(i<m_nSegmentCount)
{
BiPath2UniPath(nSegRoute[i]);
//Path convert to unipath
GenerateWord(nSegRoute,i);
//Gernerate word according the Segmentation route
i++;
}
//free the memory
for(i=0;i<MAX_SEGMENT_NUM;i++)
{
delete [] nSegRoute[i];//free the pointer memory
}
delete [] nSegRoute;//free the pointer array
return true;
}
bool CSegment::BiPath2UniPath(int *npPath)
{//BiPath convert to unipath
int i=0,nTemp=-1;
if(!m_npWordPosMapTable)
return false;
while(npPath[i]!=-1&&npPath[i]<m_nWordCount)
{
nTemp=m_npWordPosMapTable[npPath[i]];
npPath[i]=nTemp/MAX_SENTENCE_LEN;
i++;
}
if(nTemp>0)
npPath[i++]=nTemp%MAX_SENTENCE_LEN;
npPath[i]=-1;
return true;
}
bool CSegment::BiOptimumSegment(unsigned int nResultCount,double dSmoothingPara, CDictionary &dictBinary, CDictionary &dictCore)
{
int **nSegRoute;//The segmentation route
nSegRoute=new int*[MAX_SEGMENT_NUM];
for(int i=0;i<MAX_SEGMENT_NUM;i++)
{
nSegRoute[i]=new int[MAX_SENTENCE_LEN/2];
memset(nSegRoute[i],-1,MAX_SENTENCE_LEN/2*sizeof(int));
}
CDynamicArray aBiwordsNet;
BiGraphGenerate(m_graphOptimum,aBiwordsNet,dSmoothingPara,dictBinary,dictCore);
//Generate the biword link net
CNShortPath sp(&aBiwordsNet,nResultCount);
sp.ShortPath();
sp.Output((int **)nSegRoute,false,&m_nSegmentCount);
i=0;
m_graphSeg.m_segGraph=m_graphOptimum;
m_graphOptimum.SetEmpty();//Set graph optimum empty
while(i<m_nSegmentCount)
{
BiPath2UniPath(nSegRoute[i]);
//Path convert to unipath
GenerateWord(nSegRoute,i);
//Gernerate word according the Segmentation route
i++;
}
//free the memory
for(i=0;i<MAX_SEGMENT_NUM;i++)
{
delete [] nSegRoute[i];//free the pointer memory
}
delete [] nSegRoute;//free the pointer array
return true;
}
| [
"joyanlj@702d1322-cd41-0410-9eed-0fefee27d168"
]
| [
[
[
1,
502
]
]
]
|
29b12f1fc1987b3751d593b293b481ec8fbd77e0 | 6c8c4728e608a4badd88de181910a294be56953a | /RexCommon/LLSDUtilities.h | 7c7a8ffa4b13925c0cd65a530805d2c8f1fed476 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | caocao/naali | 29c544e121703221fe9c90b5c20b3480442875ef | 67c5aa85fa357f7aae9869215f840af4b0e58897 | refs/heads/master | 2021-01-21T00:25:27.447991 | 2010-03-22T15:04:19 | 2010-03-22T15:04:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,405 | h | // For conditions of distribution and use, see copyright notice in license.txt
#ifndef incl_LLSDUtilities_h
#define incl_LLSDUtilities_h
#include <string>
#include <map>
namespace RexTypes
{
//! Advances to a named tag
/*! \param tag Tag to search for
\param data String data to search in
\param index Current position in data, will be modified
\return True if tag was found, false if end was reached without finding the tag
*/
bool GetNextLLSDTag(const std::string& tag, const std::string& data, std::size_t& index);
//! Advances to next tag and returns it
/*! \param data String data to search in
\param index Current position in data, will be modified
\return Tag name + its attributes, or empty string if no more tags found
*/
std::string GetNextLLSDTag(const std::string& data, std::size_t& index);
//! Gets contents of the current tag
/*! \param data String data to search in
\param index Current position in data, will be modified
\return Tag contents
*/
std::string GetLLSDTagContent(const std::string& data, std::size_t& index);
//! Parses a map of key,value pairs
/*! \param data String data to construct a map from
\return Map
*/
std::map<std::string, std::string> ParseLLSDMap(const std::string& data);
}
#endif
| [
"cadaver@5b2332b8-efa3-11de-8684-7d64432d61a3"
]
| [
[
[
1,
39
]
]
]
|
e9e9eada7e21e33a6e39e0e88c7a42348f39a0f0 | 031009bf00a8d7cd564e0f768ff3649907bd5b65 | /TorrentBuild_CPPMakeFunctions.cpp | f9e448b95f035e622016f16c36e64564128cf454 | []
| no_license | usertex/autov | 237ab3b655be2dffcb7292cd212fe2b6d95907a7 | b470a96072484afe73ab0ae6ab7096970e34d973 | refs/heads/master | 2020-04-19T02:45:34.548955 | 2006-07-03T01:37:24 | 2006-07-03T01:37:24 | 67,372,523 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,947 | cpp |
#include "SHA1.h"
#include "atom.h"
#include "bencode.h"
#include "util.h"
#include "stringsplit.h"
#include <stdio.h>
#include <stdlib.h>
#include "TorrentBuild_CPPFunctions.h"
#include "TorrentBuild_CPPDlg.h"
#include "TorrentBuild_CPP_private.h"
#include <cstdlib>
#include <iostream>
#include <fstream>
#include "src_algo/crc32.h"
void TorrentBuild_CPPDlg::MakeTorrentFromFile( string fileToMake , int pieceSize, string announceurl, CAtom *announcelist,
string comment, bool privateTorrent, bool gensha1, bool gencrc32,
bool genmd5, bool gened2k, bool gentth, bool genexternals)
{
CAtomDicti *pTorrentRoot = new CAtomDicti();
CAtomDicti *pTorrentInfo = new CAtomDicti();
pTorrentRoot->setItem( "info" , pTorrentInfo );
vector<string> sFileName;
StringUtils::SplitString( fileToMake, "\\", sFileName, false);
pTorrentInfo->setItem( "name", new CAtomString( sFileName[sFileName.size()-1] ) );
pTorrentInfo->setItem( "length", new CAtomLong( FileSize( fileToMake.c_str() ) ) );
pTorrentInfo->setItem( "piece length", new CAtomLong( pieceSize ) );
if( privateTorrent == true )
pTorrentInfo->setItem( "private", new CAtomLong( 1 ) );
if( announceurl != string() )
pTorrentRoot->setItem( "announce", new CAtomString( announceurl ) );
if( comment != string () )
pTorrentRoot->setItem( "comment", new CAtomString( comment ) );
if( announcelist && announcelist->isList() )
pTorrentRoot->setItem( "announce-list", announcelist );
// Begin Optional Hashing
int OptionalHashes = 0;
if( gensha1 == true )
{
CSHA1 *filesha1 = new CSHA1();
filesha1->HashFile( (char *)(fileToMake.c_str()) );
filesha1->Final();
char filehash[40];
memset( filehash, 0, sizeof( char ) * 40 );
filesha1->ReportHash( filehash );
pTorrentInfo->setItem( "sha1", new CAtomString( UTIL_StringToHash ( string( filehash ) ) ) );
OptionalHashes++;
OptionalHashProgress->SetValue( OptionalHashes );
Refresh();
Update();
}
if( gencrc32 == true )
{
CCRC32Hash *fileCRC32 = new CCRC32Hash();
fileCRC32->HashFile( (char *)(fileToMake.c_str()) );
fileCRC32->Final();
char fileCRChash[8];
memset( fileCRChash, 0, sizeof( char ) * 8 );
fileCRC32->ReportHash( fileCRChash );
pTorrentInfo->setItem( "crc32", new CAtomString( string( fileCRChash ) ) );
OptionalHashes++;
OptionalHashProgress->SetValue( OptionalHashes );
Refresh();
Update();
}
/* if( genmd5 == true )
{
MD5 *filemd5 = new MD5();
FILE *fIn;
fIn = fopen(fileToMake.c_str(), "rb");
//if(fIn == NULL) return false;
filemd5->update( fIn );
filemd5->finalize();
pTorrentInfo->setItem( "md5", new CAtomString( UTIL_StringToHash ( string( filemd5->hex_digest() ) ) ) );
OptionalHashes++;
OptionalHashProgress->SetValue( OptionalHashes );
}
*/
// Begin File Piece Hashing
FILE *filetoopen;
filetoopen = fopen( fileToMake.c_str() , "rb" );
string pieces = string();
int piececount = 0;
bool breaknow = false;
char * pieceobtained;
PieceHashProgress->SetValue(0);
while ( true )
{
CSHA1 *piecesha1 = new CSHA1();
piecesha1->Reset();
int newSize = pieceSize;
PieceHashProgress->SetValue( ( (pieceSize * piececount) /FileSize(fileToMake.c_str()) ) * 100 );
Refresh();
Update();
if( FileSize( fileToMake.c_str() ) - (pieceSize * piececount) < pieceSize )
{
newSize = FileSize( fileToMake.c_str() ) - (pieceSize * piececount);
breaknow = true;
}
if( FileSize( fileToMake.c_str() ) - (pieceSize * piececount) == 0) break;
UINT_8 memblock[newSize];
fread( memblock,1, newSize, filetoopen );
piecesha1->Update(memblock, newSize);
piecesha1->Final();
pieceobtained = new char[40];
memset( pieceobtained, 0, sizeof( char ) * 40 );
piecesha1->ReportHash( pieceobtained );
pieces = pieces + UTIL_StringToHash ( string( pieceobtained ) );
piececount++;
//filetoopen.seekg(piececount*pieceSize, ios::beg);
if( breaknow == true) break;
}
PieceHashProgress->SetValue(100);
fclose(filetoopen);
pTorrentRoot->setItem("created by", new CAtomString( string( FILE_DESCRIPTION ) + string(" ") + string (VER_STRING ) ) );
pTorrentInfo->setItem("pieces", new CAtomString( pieces ) );
string pathForTorrent = fileToMake + string(".torrent");
UTIL_MakeFile( pathForTorrent.c_str() , Encode( pTorrentRoot ) );
}
| [
"[email protected]"
]
| [
[
[
1,
124
]
]
]
|
f8603feb7c30d933bc4d147b722328403ac5640d | 9ad9345e116ead00be7b3bd147a0f43144a2e402 | /Integration_WAH_&_Extraction/SMDataExtraction/SEEDMinerGUIApplication/FlexCtrl.h | 1426c2f7b522986531b634adb6af062760b61266 | []
| no_license | asankaf/scalable-data-mining-framework | e46999670a2317ee8d7814a4bd21f62d8f9f5c8f | 811fddd97f52a203fdacd14c5753c3923d3a6498 | refs/heads/master | 2020-04-02T08:14:39.589079 | 2010-07-18T16:44:56 | 2010-07-18T16:44:56 | 33,870,353 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,386 | h | // FlexCtrl.h: interface for the CFlexCtrl class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_FLEXCTRL_H__F0B36538_0C68_4DD2_85F5_576F17BD14E4__INCLUDED_)
#define AFX_FLEXCTRL_H__F0B36538_0C68_4DD2_85F5_576F17BD14E4__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#pragma warning(disable : 4786)
#include "ASWork.h"
#include "FlexCallBack.h"
#include "FlexObject.h"
#include "shockwaveflash.h"
#endif // _MSC_VER > 1000
/*
* This is the Flex controlling class.
* All Callbacks from Flex are come here.
* Many support functions has implemented here.
*/
class CFlexCtrl: public CASWork
{
public:
/*
* Return the absolute path of a given relative path of some file from
* the path of the application is running.
*/
static CString GetAbsolutePath(CString relativePath);
/*
* Return String value of a CASObject.
*/
static CString GetStringValue(CASObject obj);
/*
* Return Integer value of a CASObject.
*/
static int GetIntegerValue(CASObject obj);
/*
* Return Double value of a CASObject.
*/
static double GetDoubleValue(CASObject obj);
/*
* Return Boolean value of a CASObject.
*/
static bool GetBooleanValue(CASObject obj);
/*
* Return Array value of a CASObject.
* This return std::vector<CASObject> object.
*/
static std::vector<CASObject> GetArrayValue(CASObject obj);
/*
* All event callbacks are come here from flex.
* This is the router.
*/
static void EventCallBack(CASObject& obj, CFlexBridge* pBridge);
static LRESULT OnFlexCallback(WPARAM wParam, LPARAM lParam);
static LRESULT OnFlexCallbackRet(WPARAM wParam, LPARAM lParam);
static void OnFlashCallShockwaveflash(LPCTSTR request, CShockwaveFlash* m_Flash) ;
static void FlashCallHandler(int iFlashID, LPCTSTR request);
static int RegisterDefaultCallbacks(CShockwaveFlash* m_Flash,CFlexCallBack* callBack);
CFlexCtrl(int _flashIndex,CShockwaveFlash* Flash, CFlexCallBack *callBack);
virtual ~CFlexCtrl();
virtual CASWork* Clone();
static std::map<int,CFlexCallBack*> objCallBack;
static int flashCount;
protected:
virtual void Worker();
int flashId;
int flashIndex;
CShockwaveFlash* m_Flash;
};
#endif // !defined(AFX_FLEXCTRL_H__F0B36538_0C68_4DD2_85F5_576F17BD14E4__INCLUDED_)
| [
"jaadds@c7f6ba40-6498-11de-987a-95e5a5a5d5f1"
]
| [
[
[
1,
84
]
]
]
|
bdad427b53bd615f154c65bf10fe339c78b9a7f7 | d68d288de8b1643d92af2d339f1a3a8dcfc37015 | /Poker.Equity/CardConverter.cpp | a45517f11e1f0e1590d12755c274c4cdefee26d9 | []
| no_license | tonetheman/poker-code | c8574084be9a85edfbc439fe16ace7eca9f64445 | 50e0e43b859aa23dd4d4eb5a802c7fc95c6e77d6 | refs/heads/master | 2016-09-01T22:30:58.854343 | 2009-04-20T12:25:20 | 2009-04-20T12:25:20 | 180,739 | 7 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 4,939 | cpp | ///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2009 James Devlin
//
// DISCLAIMER OF WARRANTY
//
// This source code is provided "as is" and without warranties as to performance
// or merchantability. The author and/or distributors of this source code may
// have made statements about this source code. Any such statements do not
// constitute warranties and shall not be relied on by the user in deciding
// whether to use this source code.
//
// This source code is provided without any express or implied warranties
// whatsoever. Because of the diversity of conditions and hardware under which
// this source code may be used, no warranty of fitness for a particular purpose
// is offered. The user is advised to test the source code thoroughly before
// relying on it. The user must assume the entire risk of using the source code.
//
///////////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "CardConverter.h"
StdDeck_CardMask CardConverter::PokerEvalCards[53] =
{
0,
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_2, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_3, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_4, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_5, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_6, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_7, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_8, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_9, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_TEN, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_JACK, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_QUEEN, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_KING, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_ACE, StdDeck_Suit_CLUBS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_2, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_3, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_4, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_5, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_6, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_7, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_8, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_9, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_TEN, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_JACK, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_QUEEN, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_KING, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_ACE, StdDeck_Suit_DIAMONDS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_2, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_3, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_4, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_5, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_6, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_7, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_8, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_9, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_TEN, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_JACK, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_QUEEN, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_KING, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_ACE, StdDeck_Suit_HEARTS)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_2, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_3, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_4, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_5, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_6, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_7, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_8, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_9, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_TEN, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_JACK, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_QUEEN, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_KING, StdDeck_Suit_SPADES)),
StdDeck_MASK(StdDeck_MAKE_CARD(StdDeck_Rank_ACE, StdDeck_Suit_SPADES))
};
| [
"agcc@agcc-ubuntu.(none)"
]
| [
[
[
1,
83
]
]
]
|
90804b27e26dc9550473e645c24807c598cb0c99 | d8c8667833b54cd6d1bbf0dc169400799bf1f783 | /src/drvproc.cpp | 535d383a150fb5806365cb38dfdcb0ad7695a754 | []
| no_license | max-verem/mpng | 03e63564bae7f65d7d35ca7251a1b09f205c572e | 880f851ff32e65a5db509e1b3639d3bb892a815e | refs/heads/master | 2021-07-08T08:36:50.355752 | 2009-11-11T09:49:38 | 2009-11-11T09:49:38 | 106,196,648 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,067 | cpp | /*
*
*/
#include "CodecInst.h"
#pragma comment(lib, "WinMM.Lib")
/***************************************************************************
* DriverProc - The entry point for an installable driver.
*
* PARAMETERS
* dwDriverId: For most messages, <dwDriverId> is the DWORD
* value that the driver returns in response to a <DRV_OPEN> message.
* Each time that the driver is opened, through the <DrvOpen> API,
* the driver receives a <DRV_OPEN> message and can return an
* arbitrary, non-zero value. The installable driver interface
* saves this value and returns a unique driver handle to the
* application. Whenever the application sends a message to the
* driver using the driver handle, the interface routes the message
* to this entry point and passes the corresponding <dwDriverId>.
* This mechanism allows the driver to use the same or different
* identifiers for multiple opens but ensures that driver handles
* are unique at the application interface layer.
*
* The following messages are not related to a particular open
* instance of the driver. For these messages, the dwDriverId
* will always be zero.
*
* DRV_LOAD, DRV_FREE, DRV_ENABLE, DRV_DISABLE, DRV_OPEN
*
* hDriver: This is the handle returned to the application by the
* driver interface.
*
* uiMessage: The requested action to be performed. Message
* values below <DRV_RESERVED> are used for globally defined messages.
* Message values from <DRV_RESERVED> to <DRV_USER> are used for
* defined driver protocols. Messages above <DRV_USER> are used
* for driver specific messages.
*
* lParam1: Data for this message. Defined separately for
* each message
*
* lParam2: Data for this message. Defined separately for
* each message
*
* RETURNS
* Defined separately for each message.
*
***************************************************************************/
LRESULT PASCAL DriverProc
(
DWORD_PTR dwDriverID,
HDRVR hDriver,
UINT uiMessage,
LPARAM lParam1,
LPARAM lParam2
)
{
CodecInst* pi = (CodecInst*)dwDriverID;
switch (uiMessage)
{
case DRV_LOAD:
return (LRESULT)1L;
case DRV_FREE:
return (LRESULT)1L;
case DRV_OPEN:
// GAAH! This used to return a pointer to 0xFFFF0000 when lParam==0!
return (LRESULT) /*(DWORD)(UINT)*/ Open((ICOPEN*) lParam2);
case DRV_CLOSE:
if (pi) Close(pi);
return (LRESULT)1L;
/* state messages */
// cwk
case DRV_QUERYCONFIGURE: // configuration from drivers applet
return (LRESULT)1L;
case DRV_CONFIGURE:
pi->Configure((HWND)lParam1);
return DRV_OK;
case ICM_CONFIGURE:
/*
* return ICERR_OK if you will do a configure box, error otherwise
*/
if (lParam1 == -1)
return pi->QueryConfigure() ? ICERR_OK : ICERR_UNSUPPORTED;
else
return pi->Configure((HWND)lParam1);
case ICM_ABOUT:
/*
* return ICERR_OK if you will do a about box, error otherwise
*/
if (lParam1 == -1)
return pi->QueryAbout() ? ICERR_OK : ICERR_UNSUPPORTED;
else
return pi->About((HWND)lParam1);
case ICM_GETSTATE:
return pi->GetState((LPVOID)lParam1, (DWORD)lParam2);
case ICM_SETSTATE:
return pi->SetState((LPVOID)lParam1, (DWORD)lParam2);
case ICM_GETINFO:
return pi->GetInfo((ICINFO*)lParam1, (DWORD)lParam2);
case ICM_GETDEFAULTQUALITY:
if (lParam1)
{
*((LPDWORD)lParam1) = 7500;
return ICERR_OK;
};
break;
/* compression messages */
case ICM_COMPRESS_QUERY:
return pi->CompressQuery((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_COMPRESS_BEGIN:
return pi->CompressBegin((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_COMPRESS_GET_FORMAT:
return pi->CompressGetFormat((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_COMPRESS_GET_SIZE:
return pi->CompressGetSize((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_COMPRESS:
return pi->Compress((ICCOMPRESS*)lParam1, (DWORD)lParam2);
case ICM_COMPRESS_END:
return pi->CompressEnd();
/* decompress messages */
case ICM_DECOMPRESS_QUERY:
return pi->DecompressQuery((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_DECOMPRESS_BEGIN:
return pi->DecompressBegin((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_DECOMPRESS_GET_FORMAT:
return pi->DecompressGetFormat((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_DECOMPRESS_GET_PALETTE:
return pi->DecompressGetPalette((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_DECOMPRESS:
return pi->Decompress((ICDECOMPRESS*)lParam1, (DWORD)lParam2);
case ICM_DECOMPRESS_END:
return pi->DecompressEnd();
/* standard driver messages */
case DRV_DISABLE:
case DRV_ENABLE:
return (LRESULT)1L;
case DRV_INSTALL:
case DRV_REMOVE:
return (LRESULT)DRV_OK;
}
if (uiMessage < DRV_USER)
return DefDriverProc(dwDriverID, hDriver, uiMessage, lParam1, lParam2);
else
return ICERR_UNSUPPORTED;
};
HMODULE hmoduleMPNG=0;
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD, LPVOID)
{
hmoduleMPNG = (HMODULE) hinstDLL;
return TRUE;
};
| [
"[email protected]"
]
| [
[
[
1,
185
]
]
]
|
c274ca932a3cd545b0f121327308160a0a3707ea | e7788311c515f48118df40d1fd9f72d457bebff5 | /3DLIBexample3/main.cpp | ead8332b23aee94e27cde5b527932ad37539a371 | []
| no_license | jbreslin33/dreamsock | 3af9131bd8437a2996e37b8413c6c85adfe5dbb1 | b6ee1bc1552266aef16970994493cc88fd172848 | refs/heads/master | 2021-01-02T09:31:59.704311 | 2010-12-21T05:28:21 | 2010-12-21T05:28:21 | 37,391,262 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,161 | cpp | #include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glaux.h>
#include <gl/glut.h>
#include <vector>
using namespace std;
#include <c3dlib.h>
#include <c3dmodel.h>
#include "CPlayer.h"
// APPLICATION SPECIFIC
int rect_x, rect_y; // (x, y) position
int rect_w, rect_h; // width and height
float rect_r; // red color
float rect_g; // green color
float rect_b; // blue color
C3Dlib *gfx;
// WINDOWS PROCUDURE
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_CLOSE:
{
PostQuitMessage(0);
return 0;
}
case WM_KEYDOWN:
{
gfx->keys[wParam] = TRUE;
return 0;
}
case WM_KEYUP:
{
gfx->keys[wParam] = FALSE;
return 0;
}
case WM_SIZE:
{
gfx->Resize(LOWORD(lParam),HIWORD(lParam));
return 0;
}
}
// Pass All Unhandled Messages To DefWindowProc
return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
// WINDOWS MESSAGE LOOP AND APPLICATION ENTRY POINT
int WINAPI WinMain(HINSTANCE hThisInst, HINSTANCE hPrevInst, LPSTR lpszArgs, int nWinMode)
{
MSG msg;
gfx = new C3Dlib();
C3DIMAGE2D marineSkin;
// Initialise 2DLIB
gfx->Initialize("3DLIB - Example 3: Walk About", 640, 480, 16, 0, WndProc);
gfx->LoadBitmap(&marineSkin, "marine.bmp");
C3Dmodel *myModel = C3Dmodel::loadMD2("marine.md2");
CPlayer *testPlayer = new CPlayer(myModel, marineSkin);
// Start the Windows Message Loop
while(msg.message != WM_QUIT)
{
if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
gfx->Begin();
{
// Draw the model...
gfx->SetMode(C3DMODE_3D);
glScalef(0.25, 0.25, 0.25);
testPlayer->render();
}
gfx->End();
}
// Check for Keyboard Input
if(gfx->keys[VK_UP])
{
testPlayer->move(1);
}
if(gfx->keys[VK_RIGHT])
{
testPlayer->rotate(0.02);
}
if(gfx->keys[VK_LEFT])
{
testPlayer->rotate(-0.02);
}
}
// cleanup...
gfx->Shutdown();
delete gfx;
return msg.wParam;
}
| [
"jbreslin33@localhost"
]
| [
[
[
1,
127
]
]
]
|
dee01ca645b8e48a51c2ea2733d9c99e1021a1d9 | c7120eeec717341240624c7b8a731553494ef439 | /src/cplusplus/freezone-samp/src/core/utility/strings.hpp | cba8c649c1e8471d22bfd73775221fc1900ecb87 | []
| no_license | neverm1ndo/gta-paradise-sa | d564c1ed661090336621af1dfd04879a9c7db62d | 730a89eaa6e8e4afc3395744227527748048c46d | refs/heads/master | 2020-04-27T22:00:22.221323 | 2010-09-04T19:02:28 | 2010-09-04T19:02:28 | 174,719,907 | 1 | 0 | null | 2019-03-09T16:44:43 | 2019-03-09T16:44:43 | null | WINDOWS-1251 | C++ | false | false | 1,538 | hpp | #ifndef UTILITY_STRINGS_HPP
#define UTILITY_STRINGS_HPP
#include <string>
#include <boost/format.hpp>
inline void process_starts_underline(std::string& text) {
for (std::size_t pos = 0, len = text.length(); len > pos; ++pos) {
if ('_' == text[pos]) {
text[pos] = ' ';
}
else {
break;
}
}
}
inline void process_ends_underline(std::string& text) {
if (!text.empty()) {
for (std::size_t pos = text.length() - 1; 0 <= pos; --pos) {
if ('_' == text[pos]) {
if (pos > 0 && '\\' == text[pos-1]) {
// Наше подчеркивание было экранировано
text = text.substr(0, pos - 1) + text.substr(pos);
break;
}
text[pos] = ' ';
}
else {
break;
}
}
}
}
template <int array_size, typename enum_t>
std::string get_enum_name(enum_t e, std::string const* names) {
int index = static_cast<int>(e);
if (0 > index || array_size <= index) {
return (boost::format("unknown(%1%)") % index).str();
}
return names[index];
}
inline std::string str_clip(std::string const str, int max_len) {
if (static_cast<int>(str.length()) > max_len) {
std::string endind = "...";
return str.substr(0, max_len - endind.length()) + endind;
}
return str;
}
#endif // UTILITY_STRINGS_HPP
| [
"dimonml@19848965-7475-ded4-60a4-26152d85fbc5"
]
| [
[
[
1,
52
]
]
]
|
a47009b2651240797629a2ee05e04b13310ba985 | 5324f03896092ccfd3d773155123d686941e01f4 | /src/renderingcontrol/hchannel.cpp | 751a3d9673be192869174409c962dc1467b097f1 | []
| no_license | Kangda/Upnp-AV-Demo | 93bfad060fc8eb60a1e9e63c4edb5823d37fcef4 | 3013b0dee85a367af40a3383e6cbb5b6e7b0d928 | refs/heads/master | 2021-01-10T19:38:41.399817 | 2011-12-11T01:26:17 | 2011-12-11T01:26:17 | 2,770,068 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,972 | cpp | /*
* Copyright (C) 2011 Tuomo Penttinen, all rights reserved.
*
* Author: Tuomo Penttinen <[email protected]>
*
* This file is part of Herqq UPnP Av (HUPnPAv) library.
*
* Herqq UPnP Av is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Herqq UPnP Av is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Herqq UPnP Av. If not, see <http://www.gnu.org/licenses/>.
*/
#include "hchannel.h"
#include <HUpnpCore/private/hmisc_utils_p.h>
#include <QtCore/QSet>
namespace Herqq
{
namespace Upnp
{
namespace Av
{
/*******************************************************************************
* HChannel
******************************************************************************/
HChannel::HChannel() :
m_type(), m_typeAsString()
{
}
HChannel::HChannel(Type type) :
m_type(type), m_typeAsString(toString(type))
{
}
HChannel::HChannel(const QString& arg) :
m_type(), m_typeAsString()
{
QString trimmed = arg.trimmed();
m_type = fromString(trimmed);
m_typeAsString = trimmed;
}
QString HChannel::toString(Type type)
{
QString retVal;
switch(type)
{
case Master:
retVal = "Master";
break;
case LeftFront:
retVal = "LF";
break;
case RightFront:
retVal = "RF";
break;
case CenterFront:
retVal = "CF";
break;
case LFE:
retVal = "LFE";
break;
case LeftSurround:
retVal = "LS";
break;
case RightSurround:
retVal = "RS";
break;
case LeftOfCenter:
retVal = "LFC";
break;
case RightOfCenter:
retVal = "RFC";
break;
case Surround:
retVal = "SD";
break;
case SideLeft:
retVal = "SL";
break;
case SideRight:
retVal = "SR";
break;
case Top:
retVal = "T";
break;
case Bottom:
retVal = "B";
break;
default:
break;
}
return retVal;
}
HChannel::Type HChannel::fromString(const QString& type)
{
Type retVal = Undefined;
if (type.compare("MASTER", Qt::CaseInsensitive) == 0)
{
retVal = Master;
}
else if (type.compare("LF", Qt::CaseInsensitive) == 0)
{
retVal = LeftFront;
}
else if (type.compare("RF", Qt::CaseInsensitive) == 0)
{
retVal = RightFront;
}
else if (type.compare("CF", Qt::CaseInsensitive) == 0)
{
retVal = CenterFront;
}
else if (type.compare("LFE", Qt::CaseInsensitive) == 0)
{
retVal = LFE;
}
else if (type.compare("LS", Qt::CaseInsensitive) == 0)
{
retVal = LeftSurround;
}
else if (type.compare("RS", Qt::CaseInsensitive) == 0)
{
retVal = RightSurround;
}
else if (type.compare("LFC", Qt::CaseInsensitive) == 0)
{
retVal = LeftOfCenter;
}
else if (type.compare("RFC", Qt::CaseInsensitive) == 0)
{
retVal = RightOfCenter;
}
else if (type.compare("SD", Qt::CaseInsensitive) == 0)
{
retVal = Surround;
}
else if (type.compare("SL", Qt::CaseInsensitive) == 0)
{
retVal = SideLeft;
}
else if (type.compare("SR", Qt::CaseInsensitive) == 0)
{
retVal = SideRight;
}
else if (type.compare("T", Qt::CaseInsensitive) == 0)
{
retVal = Top;
}
else if (type.compare("B", Qt::CaseInsensitive) == 0)
{
retVal = Bottom;
}
else if (!type.isEmpty())
{
retVal = VendorDefined;
}
return retVal;
}
QSet<HChannel> HChannel::allChannels()
{
QSet<HChannel> retVal;
retVal.insert(Master);
retVal.insert(LeftFront);
retVal.insert(RightFront);
retVal.insert(CenterFront);
retVal.insert(LFE);
retVal.insert(LeftSurround);
retVal.insert(RightSurround);
retVal.insert(LeftOfCenter);
retVal.insert(RightOfCenter);
retVal.insert(Surround);
retVal.insert(SideLeft);
retVal.insert(SideRight);
retVal.insert(Top);
retVal.insert(Bottom);
return retVal;
}
bool operator==(const HChannel& obj1, const HChannel& obj2)
{
return obj1.toString() == obj2.toString();
}
quint32 qHash(const HChannel& key)
{
QByteArray data = key.toString().toLocal8Bit();
return hash(data.constData(), data.size());
}
}
}
}
| [
"[email protected]"
]
| [
[
[
1,
209
]
]
]
|
86afdc0edfbc11608d79c577665605e9976100b5 | 478570cde911b8e8e39046de62d3b5966b850384 | /apicompatanamdw/bcdrivers/mw/classicui/uifw/apps/S60_SDK3.0/bctestmenu/src/bctestmenuview.cpp | 4c49c279e66e3f27d8cc19054f7138922a53e01f | []
| no_license | SymbianSource/oss.FCL.sftools.ana.compatanamdw | a6a8abf9ef7ad71021d43b7f2b2076b504d4445e | 1169475bbf82ebb763de36686d144336fcf9d93b | refs/heads/master | 2020-12-24T12:29:44.646072 | 2010-11-11T14:03:20 | 2010-11-11T14:03:20 | 72,994,432 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,919 | cpp | /*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: view class
*
*/
#include <aknviewappui.h>
#include "bctestmenu.hrh"
#include <bctestmenu.rsg>
#include "bctestmenuview.h"
#include "bctestmenucontainer.h"
#include "bctestutil.h"
#include "bctestmenucase.h"
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// Symbian 2nd static Constructor
// ---------------------------------------------------------------------------
//
CBCTestMenuView* CBCTestMenuView::NewL()
{
CBCTestMenuView* self = new( ELeave ) CBCTestMenuView();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// C++ default Constructor
// ---------------------------------------------------------------------------
//
CBCTestMenuView::CBCTestMenuView()
{
}
// ---------------------------------------------------------------------------
// Symbian 2nd Constructor
// ---------------------------------------------------------------------------
//
void CBCTestMenuView::ConstructL()
{
BaseConstructL( R_BCTESTMENU_VIEW );
iContainer = new( ELeave ) CBCTestMenuContainer();
iContainer->SetMopParent( this );
iContainer->ConstructL( ClientRect() );
AppUi()->AddToStackL( *this, iContainer );
iContainer->MakeVisible( ETrue );
iTestUtil = CBCTestUtil::NewL();
_LIT( KMenuTestCase, "Menu test case");
// Add test case here.
iTestUtil->AddTestCaseL( CBCTestMenuCase::NewL( iContainer ),
KMenuTestCase );
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CBCTestMenuView::~CBCTestMenuView()
{
if ( iContainer )
{
AppUi()->RemoveFromStack( iContainer );
}
delete iContainer;
delete iTestUtil;
}
// ---------------------------------------------------------------------------
// CBCTestMenuView::Id
// ---------------------------------------------------------------------------
//
TUid CBCTestMenuView::Id() const
{
return KBCTestMenuViewId;
}
// ---------------------------------------------------------------------------
// CBCTestMenuView::DoActivateL
// ---------------------------------------------------------------------------
//
void CBCTestMenuView::DoActivateL( const TVwsViewId&, TUid, const TDesC8& )
{
}
// ---------------------------------------------------------------------------
// CBCTestMenuView::DoDeactivate
// ---------------------------------------------------------------------------
//
void CBCTestMenuView::DoDeactivate()
{
}
// ---------------------------------------------------------------------------
// CBCTestMenuView::HandleCommandL
// ---------------------------------------------------------------------------
//
void CBCTestMenuView::HandleCommandL( TInt aCommand )
{
switch ( aCommand )
{
case EProgCmdAutoTest:
iTestUtil->RunL();
break;
default:
if ( aCommand > EBCTestCmdEmptyOutline &&
aCommand < EBCTestCmdMaxOutline )
{
iTestUtil->RunL( aCommand );
}
break;
}
}
| [
"none@none"
]
| [
[
[
1,
131
]
]
]
|
3b7d2532a8df6caea8c48a1f0f91b609895a2369 | 989aa92c9dab9a90373c8f28aa996c7714a758eb | /HydraIRC/ChannelPropertiesDlg.h | 674d046e2756907a5f51bdd67f32453533242097 | []
| no_license | john-peterson/hydrairc | 5139ce002e2537d4bd8fbdcebfec6853168f23bc | f04b7f4abf0de0d2536aef93bd32bea5c4764445 | refs/heads/master | 2021-01-16T20:14:03.793977 | 2010-04-03T02:10:39 | 2010-04-03T02:10:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,494 | h | /*
HydraIRC
Copyright (C) 2002-2006 Dominic Clifton aka Hydra
HydraIRC limited-use source license
1) You can:
1.1) Use the source to create improvements and bug-fixes to send to the
author to be incorporated in the main program.
1.2) Use it for review/educational purposes.
2) You can NOT:
2.1) Use the source to create derivative works. (That is, you can't release
your own version of HydraIRC with your changes in it)
2.2) Compile your own version and sell it.
2.3) Distribute unmodified, modified source or compiled versions of HydraIRC
without first obtaining permission from the author. (I want one place
for people to come to get HydraIRC from)
2.4) Use any of the code or other part of HydraIRC in anything other than
HydraIRC.
3) All code submitted to the project:
3.1) Must not be covered by any license that conflicts with this license
(e.g. GPL code)
3.2) Will become the property of the author.
*/
// Connectdlg.h : interface of the CConnectDlg class
//
/////////////////////////////////////////////////////////////////////////////
#pragma once
//#include "GUIControls.h"
class CChannelProperties; // forward define
class CChannelPropertiesDlg :
public CDialogImpl<CChannelPropertiesDlg>,
public CDialogResize<CChannelPropertiesDlg>
{
private:
//CUsefulEdit m_TopicCtrl;
CEdit m_TopicCtrl;
CEdit m_KeyStringCtrl;
CEdit m_LimitStringCtrl;
CButton m_LimitCtrl;
CButton m_KeyCtrl;
CButton m_InviteCtrl;
IRCChannel *m_pChannel;
CChannelProperties *m_pProperties; // this stores the data that we change..
public:
enum { IDD = IDD_CHANNELPROPERTIES };
void OnOK( void );
CChannelPropertiesDlg( IRCChannel *pChannel, CChannelProperties *pProperties);
~CChannelPropertiesDlg( void );
BEGIN_MSG_MAP(CChannelPropertiesDlg)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
COMMAND_ID_HANDLER(IDOK, OnOKCmd)
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd)
CHAIN_MSG_MAP(CDialogResize<CChannelPropertiesDlg>)
END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CChannelPropertiesDlg)
DLGRESIZE_CONTROL(IDC_CHANNELPROPERTIES_SETTINGSFRAME ,DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_CHANNELPROPERTIES_TOPIC ,DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_CHANNELPROPERTIES_KEYSTRING ,DLSZ_SIZE_X | DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_CHANNELPROPERTIES_KEY ,DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_CHANNELPROPERTIES_LIMIT ,DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_CHANNELPROPERTIES_LIMITSTRING ,DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_CHANNELPROPERTIES_INVITE ,DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDOK ,DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDCANCEL ,DLSZ_MOVE_Y)
END_DLGRESIZE_MAP()
// Handler prototypes (uncomment arguments if needed):
// LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
// LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
// LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
LRESULT OnOKCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
};
| [
"hydra@b2473a34-e2c4-0310-847b-bd686bddb4b0"
]
| [
[
[
1,
93
]
]
]
|
143401ee1a06cd213043f1406904724db3230b43 | 3e69b159d352a57a48bc483cb8ca802b49679d65 | /tags/release-2006-04-24/pcbnew/dialog_initpcb.cpp | 1c1e663c58979eb304f966ff78f133993b153a8b | []
| no_license | BackupTheBerlios/kicad-svn | 4b79bc0af39d6e5cb0f07556eb781a83e8a464b9 | 4c97bbde4b1b12ec5616a57c17298c77a9790398 | refs/heads/master | 2021-01-01T19:38:40.000652 | 2006-06-19T20:01:24 | 2006-06-19T20:01:24 | 40,799,911 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,903 | cpp | /////////////////////////////////////////////////////////////////////////////
// Name: dialog_initpcb.cpp
// Purpose:
// Author: jean-pierre Charras
// Modified by:
// Created: 15/02/2006 21:42:41
// RCS-ID:
// Copyright: License GNU
// Licence:
/////////////////////////////////////////////////////////////////////////////
// Generated by DialogBlocks (unregistered), 15/02/2006 21:42:41
////@begin includes
////@end includes
#include "dialog_initpcb.h"
////@begin XPM images
////@end XPM images
/*!
* WinEDA_PcbGlobalDeleteFrame type definition
*/
IMPLEMENT_DYNAMIC_CLASS( WinEDA_PcbGlobalDeleteFrame, wxDialog )
/*!
* WinEDA_PcbGlobalDeleteFrame event table definition
*/
BEGIN_EVENT_TABLE( WinEDA_PcbGlobalDeleteFrame, wxDialog )
////@begin WinEDA_PcbGlobalDeleteFrame event table entries
EVT_BUTTON( wxID_OK, WinEDA_PcbGlobalDeleteFrame::OnOkClick )
EVT_BUTTON( wxID_CANCEL, WinEDA_PcbGlobalDeleteFrame::OnCancelClick )
////@end WinEDA_PcbGlobalDeleteFrame event table entries
END_EVENT_TABLE()
/*!
* WinEDA_PcbGlobalDeleteFrame constructors
*/
WinEDA_PcbGlobalDeleteFrame::WinEDA_PcbGlobalDeleteFrame( )
{
}
WinEDA_PcbGlobalDeleteFrame::WinEDA_PcbGlobalDeleteFrame( WinEDA_PcbFrame* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
m_Parent = parent;
Create(parent, id, caption, pos, size, style);
}
/*!
* WinEDA_PcbGlobalDeleteFrame creator
*/
bool WinEDA_PcbGlobalDeleteFrame::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
////@begin WinEDA_PcbGlobalDeleteFrame member initialisation
m_DelZones = NULL;
m_DelTexts = NULL;
m_DelEdges = NULL;
m_DelDrawings = NULL;
m_DelModules = NULL;
m_DelTracks = NULL;
m_DelMarkers = NULL;
m_DelAlls = NULL;
m_TrackFilterAR = NULL;
m_TrackFilterLocked = NULL;
////@end WinEDA_PcbGlobalDeleteFrame member initialisation
////@begin WinEDA_PcbGlobalDeleteFrame creation
SetExtraStyle(GetExtraStyle()|wxWS_EX_BLOCK_EVENTS);
wxDialog::Create( parent, id, caption, pos, size, style );
CreateControls();
GetSizer()->Fit(this);
GetSizer()->SetSizeHints(this);
Centre();
////@end WinEDA_PcbGlobalDeleteFrame creation
return true;
}
/*!
* Control creation for WinEDA_PcbGlobalDeleteFrame
*/
void WinEDA_PcbGlobalDeleteFrame::CreateControls()
{
SetFont(*g_DialogFont);
////@begin WinEDA_PcbGlobalDeleteFrame content construction
// Generated by DialogBlocks, 15/02/2006 22:10:20 (unregistered)
WinEDA_PcbGlobalDeleteFrame* itemDialog1 = this;
wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxHORIZONTAL);
itemDialog1->SetSizer(itemBoxSizer2);
wxStaticBox* itemStaticBoxSizer3Static = new wxStaticBox(itemDialog1, wxID_ANY, _("Items to delete"));
wxStaticBoxSizer* itemStaticBoxSizer3 = new wxStaticBoxSizer(itemStaticBoxSizer3Static, wxVERTICAL);
itemBoxSizer2->Add(itemStaticBoxSizer3, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
m_DelZones = new wxCheckBox( itemDialog1, ID_CHECKBOX, _("Delete Zones"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_DelZones->SetValue(false);
itemStaticBoxSizer3->Add(m_DelZones, 0, wxALIGN_LEFT|wxALL, 5);
m_DelTexts = new wxCheckBox( itemDialog1, ID_CHECKBOX1, _("Delete Texts"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_DelTexts->SetValue(false);
itemStaticBoxSizer3->Add(m_DelTexts, 0, wxALIGN_LEFT|wxALL, 5);
m_DelEdges = new wxCheckBox( itemDialog1, ID_CHECKBOX2, _("Delete Edges"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_DelEdges->SetValue(false);
itemStaticBoxSizer3->Add(m_DelEdges, 0, wxALIGN_LEFT|wxALL, 5);
m_DelDrawings = new wxCheckBox( itemDialog1, ID_CHECKBOX3, _("Delete Drawings"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_DelDrawings->SetValue(false);
itemStaticBoxSizer3->Add(m_DelDrawings, 0, wxALIGN_LEFT|wxALL, 5);
m_DelModules = new wxCheckBox( itemDialog1, ID_CHECKBOX4, _("Delete Modules"), wxDefaultPosition, wxDefaultSize, 0 );
m_DelModules->SetValue(false);
itemStaticBoxSizer3->Add(m_DelModules, 0, wxALIGN_LEFT|wxALL, 5);
m_DelTracks = new wxCheckBox( itemDialog1, ID_CHECKBOX5, _("Delete Tracks"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_DelTracks->SetValue(false);
itemStaticBoxSizer3->Add(m_DelTracks, 0, wxALIGN_LEFT|wxALL, 5);
m_DelMarkers = new wxCheckBox( itemDialog1, ID_CHECKBOX6, _("Delete Markers"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_DelMarkers->SetValue(false);
itemStaticBoxSizer3->Add(m_DelMarkers, 0, wxALIGN_LEFT|wxALL, 5);
m_DelAlls = new wxCheckBox( itemDialog1, ID_CHECKBOX7, _("Clear Board"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_DelAlls->SetValue(false);
itemStaticBoxSizer3->Add(m_DelAlls, 0, wxALIGN_LEFT|wxALL, 5);
wxBoxSizer* itemBoxSizer12 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer2->Add(itemBoxSizer12, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxStaticBox* itemStaticBoxSizer13Static = new wxStaticBox(itemDialog1, wxID_ANY, _("Track Filter"));
wxStaticBoxSizer* itemStaticBoxSizer13 = new wxStaticBoxSizer(itemStaticBoxSizer13Static, wxVERTICAL);
itemBoxSizer12->Add(itemStaticBoxSizer13, 0, wxGROW|wxALL, 5);
m_TrackFilterAR = new wxCheckBox( itemDialog1, ID_CHECKBOX8, _("Include AutoRouted Tracks"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_TrackFilterAR->SetValue(false);
itemStaticBoxSizer13->Add(m_TrackFilterAR, 0, wxALIGN_LEFT|wxALL, 5);
m_TrackFilterLocked = new wxCheckBox( itemDialog1, ID_CHECKBOX9, _("Include Locked Tracks"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_TrackFilterLocked->SetValue(false);
itemStaticBoxSizer13->Add(m_TrackFilterLocked, 0, wxALIGN_LEFT|wxALL, 5);
itemBoxSizer12->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
wxBoxSizer* itemBoxSizer17 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer12->Add(itemBoxSizer17, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
wxButton* itemButton18 = new wxButton( itemDialog1, wxID_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer17->Add(itemButton18, 0, wxGROW|wxALL, 5);
wxButton* itemButton19 = new wxButton( itemDialog1, wxID_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer17->Add(itemButton19, 0, wxGROW|wxALL, 5);
////@end WinEDA_PcbGlobalDeleteFrame content construction
}
/*!
* Should we show tooltips?
*/
bool WinEDA_PcbGlobalDeleteFrame::ShowToolTips()
{
return true;
}
/*!
* Get bitmap resources
*/
wxBitmap WinEDA_PcbGlobalDeleteFrame::GetBitmapResource( const wxString& name )
{
// Bitmap retrieval
////@begin WinEDA_PcbGlobalDeleteFrame bitmap retrieval
wxUnusedVar(name);
return wxNullBitmap;
////@end WinEDA_PcbGlobalDeleteFrame bitmap retrieval
}
/*!
* Get icon resources
*/
wxIcon WinEDA_PcbGlobalDeleteFrame::GetIconResource( const wxString& name )
{
// Icon retrieval
////@begin WinEDA_PcbGlobalDeleteFrame icon retrieval
wxUnusedVar(name);
return wxNullIcon;
////@end WinEDA_PcbGlobalDeleteFrame icon retrieval
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_OK
*/
void WinEDA_PcbGlobalDeleteFrame::OnOkClick( wxCommandEvent& event )
{
AcceptPcbDelete(event);
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL
*/
void WinEDA_PcbGlobalDeleteFrame::OnCancelClick( wxCommandEvent& event )
{
////@begin wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL in WinEDA_PcbGlobalDeleteFrame.
// Before editing this code, remove the block markers.
event.Skip();
////@end wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL in WinEDA_PcbGlobalDeleteFrame.
}
| [
"fcoiffie@244deca0-f506-0410-ab94-f4f3571dea26"
]
| [
[
[
1,
225
]
]
]
|
2029587fb69f8319c739f761c06fb3451e3a76a5 | 6712f8313dd77ae820aaf400a5836a36af003075 | /timerTest.cpp | 137af0d3ad25b9b085d3d54775e0cf19295c0ffc | []
| no_license | AdamTT1/bdScript | d83c7c63c2c992e516dca118cfeb34af65955c14 | 5483f239935ec02ad082666021077cbc74d1790c | refs/heads/master | 2021-12-02T22:57:35.846198 | 2010-08-08T22:32:02 | 2010-08-08T22:32:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,210 | cpp | #include <time.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/ioctl.h>
#include <linux/gen-timer.h>
#include <poll.h>
int main( void )
{
printf( "Hello, timerTest\n" );
int fd = open( "/dev/timer", O_RDONLY );
if( 0 <= fd )
{
printf( "timer device opened\n" );
long long arg = 0 ;
int result = ioctl( fd, GET_TSTAMP, &arg );
if( 0 == result )
{
printf( "EXP: %lld\n", arg );
arg = tickMs()+1000 ;
result = ioctl( fd, SET_TSTAMP, &arg );
if( 0 == result )
{
printf( "set timestamp to %lld successfully\n", arg );
long long when ;
result = read( fd, &when, sizeof( when ) );
if( sizeof(when) == result )
{
printf( "read %u bytes, %lld, now %lld\n", result, when, tickMs() );
pollfd filedes ;
filedes.fd = fd ;
filedes.events = POLLIN ;
result = poll( &filedes, 1, 1000 );
if( 0 < result )
{
printf( "poll() ready at %lld\n", tickMs() );
arg = tickMs()+1000 ;
ioctl( fd, SET_TSTAMP, &arg );
result = poll( &filedes, 1, 1000 );
if( 0 < result )
{
printf( "poll() ready again at %lld\n", tickMs() );
}
else if( 0 == result )
fprintf( stderr, "poll() timeout\n" );
else
perror( "poll()" );
}
else if( 0 == result )
fprintf( stderr, "poll() timeout\n" );
else
perror( "poll()" );
}
else
perror( "read()" );
}
else
perror( "ioctl(SET_TSTAMP)" );
}
else
perror( "ioctl(GET_TSTAMP)" );
close( fd );
}
else
perror( "/dev/timer" );
return 0 ;
}
| [
"ericn"
]
| [
[
[
1,
76
]
]
]
|
20e7d6fd3cc04965018748d7eae140a7014f6696 | 6629f18d84dc8d5a310b95fedbf5be178b00da92 | /SDK-2008-05-27/pfc/string_conv.cpp | c638b9814ff012dac9c8c8edc9f0b137baf4d1bc | []
| no_license | thenfour/WMircP | 317f7b36526ebf8061753469b10f164838a0a045 | ad6f4d1599fade2ae4e25656a95211e1ca70db31 | refs/heads/master | 2021-01-01T17:42:20.670266 | 2008-07-11T03:10:48 | 2008-07-11T03:10:48 | 16,931,152 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,166 | cpp | #include "pfc.h"
#ifdef _WINDOWS
namespace {
template<typename t_char, bool isChecked = true>
class string_writer_t {
public:
string_writer_t(t_char * p_buffer,t_size p_size) : m_buffer(p_buffer), m_size(p_size), m_writeptr(0) {}
void write(t_char p_char) {
if (isChecked) {
if (m_writeptr < m_size) {
m_buffer[m_writeptr++] = p_char;
}
} else {
m_buffer[m_writeptr++] = p_char;
}
}
void write_multi(const t_char * p_buffer,t_size p_count) {
if (isChecked) {
const t_size delta = pfc::min_t<t_size>(p_count,m_size-m_writeptr);
for(t_size n=0;n<delta;n++) {
m_buffer[m_writeptr++] = p_buffer[n];
}
} else {
for(t_size n = 0; n < p_count; ++n) {
m_buffer[m_writeptr++] = p_buffer[n];
}
}
}
void write_as_utf8(unsigned p_char) {
if (isChecked) {
char temp[6];
t_size n = pfc::utf8_encode_char(p_char,temp);
write_multi(temp,n);
} else {
m_writeptr += pfc::utf8_encode_char(p_char, m_buffer + m_writeptr);
}
}
void write_as_wide(unsigned p_char) {
if (isChecked) {
wchar_t temp[2];
t_size n = pfc::utf16_encode_char(p_char,temp);
write_multi(temp,n);
} else {
m_writeptr += pfc::utf16_encode_char(p_char, m_buffer + m_writeptr);
}
}
t_size finalize() {
if (isChecked) {
if (m_size == 0) return 0;
t_size terminator = pfc::min_t<t_size>(m_writeptr,m_size-1);
m_buffer[terminator] = 0;
return terminator;
} else {
m_buffer[m_writeptr] = 0;
return m_writeptr;
}
}
bool is_overrun() const {
return m_writeptr >= m_size;
}
private:
t_char * m_buffer;
t_size m_size;
t_size m_writeptr;
};
};
namespace pfc {
namespace stringcvt {
t_size convert_utf8_to_wide(wchar_t * p_out,t_size p_out_size,const char * p_in,t_size p_in_size) {
const t_size insize = p_in_size;
t_size inptr = 0;
string_writer_t<wchar_t> writer(p_out,p_out_size);
while(inptr < insize && !writer.is_overrun()) {
unsigned newchar = 0;
t_size delta = utf8_decode_char(p_in + inptr,newchar,insize - inptr);
if (delta == 0 || newchar == 0) break;
PFC_ASSERT(inptr + delta <= insize);
inptr += delta;
writer.write_as_wide(newchar);
}
return writer.finalize();
}
t_size convert_utf8_to_wide_unchecked(wchar_t * p_out,const char * p_in) {
t_size inptr = 0;
string_writer_t<wchar_t,false> writer(p_out,~0);
while(!writer.is_overrun()) {
unsigned newchar = 0;
t_size delta = utf8_decode_char(p_in + inptr,newchar);
if (delta == 0 || newchar == 0) break;
inptr += delta;
writer.write_as_wide(newchar);
}
return writer.finalize();
}
t_size convert_wide_to_utf8(char * p_out,t_size p_out_size,const wchar_t * p_in,t_size p_in_size) {
const t_size insize = p_in_size;
t_size inptr = 0;
string_writer_t<char> writer(p_out,p_out_size);
while(inptr < insize && !writer.is_overrun()) {
unsigned newchar = 0;
t_size delta = utf16_decode_char(p_in + inptr,&newchar,insize - inptr);
if (delta == 0 || newchar == 0) break;
PFC_ASSERT(inptr + delta <= insize);
inptr += delta;
writer.write_as_utf8(newchar);
}
return writer.finalize();
}
t_size estimate_utf8_to_wide(const char * p_in) {
t_size inptr = 0;
t_size retval = 1;//1 for null terminator
for(;;) {
unsigned newchar = 0;
t_size delta = utf8_decode_char(p_in + inptr,newchar);
if (delta == 0 || newchar == 0) break;
inptr += delta;
{
wchar_t temp[2];
delta = utf16_encode_char(newchar,temp);
if (delta == 0) break;
retval += delta;
}
}
return retval;
}
t_size estimate_utf8_to_wide(const char * p_in,t_size p_in_size) {
const t_size insize = p_in_size;
t_size inptr = 0;
t_size retval = 1;//1 for null terminator
while(inptr < insize) {
unsigned newchar = 0;
t_size delta = utf8_decode_char(p_in + inptr,newchar,insize - inptr);
if (delta == 0 || newchar == 0) break;
PFC_ASSERT(inptr + delta <= insize);
inptr += delta;
{
wchar_t temp[2];
delta = utf16_encode_char(newchar,temp);
if (delta == 0) break;
retval += delta;
}
}
return retval;
}
t_size estimate_wide_to_utf8(const wchar_t * p_in,t_size p_in_size) {
const t_size insize = p_in_size;
t_size inptr = 0;
t_size retval = 1;//1 for null terminator
while(inptr < insize) {
unsigned newchar = 0;
t_size delta = utf16_decode_char(p_in + inptr,&newchar,insize - inptr);
if (delta == 0 || newchar == 0) break;
PFC_ASSERT(inptr + delta <= insize);
inptr += delta;
{
char temp[6];
delta = utf8_encode_char(newchar,temp);
if (delta == 0) break;
retval += delta;
}
}
return retval;
}
t_size convert_codepage_to_wide(unsigned p_codepage,wchar_t * p_out,t_size p_out_size,const char * p_source,t_size p_source_size) {
if (p_out_size == 0) return 0;
memset(p_out,0,p_out_size * sizeof(*p_out));
MultiByteToWideChar(p_codepage,0,p_source,p_source_size,p_out,p_out_size);
p_out[p_out_size-1] = 0;
return wcslen(p_out);
}
t_size convert_wide_to_codepage(unsigned p_codepage,char * p_out,t_size p_out_size,const wchar_t * p_source,t_size p_source_size) {
if (p_out_size == 0) return 0;
memset(p_out,0,p_out_size * sizeof(*p_out));
WideCharToMultiByte(p_codepage,0,p_source,p_source_size,p_out,p_out_size,0,FALSE);
p_out[p_out_size-1] = 0;
return strlen(p_out);
}
t_size estimate_codepage_to_wide(unsigned p_codepage,const char * p_source,t_size p_source_size) {
return MultiByteToWideChar(p_codepage,0,p_source,strlen_max(p_source,p_source_size),0,0) + 1;
}
t_size estimate_wide_to_codepage(unsigned p_codepage,const wchar_t * p_source,t_size p_source_size) {
return WideCharToMultiByte(p_codepage,0,p_source,wcslen_max(p_source,p_source_size),0,0,0,FALSE) + 1;
}
}
}
#endif //_WINDOWS
| [
"carl@72871cd9-16e1-0310-933f-800000000000"
]
| [
[
[
1,
220
]
]
]
|
be850809619e49780941d92cc6e596f7b66f3247 | 6ee200c9dba87a5d622c2bd525b50680e92b8dab | /Autumn/Core/Math/Vector1.h | 3dc903fa157c2849cb86d313c65b6318d039b4d9 | []
| no_license | Ishoa/bizon | 4dbcbbe94d1b380f213115251e1caac5e3139f4d | d7820563ab6831d19e973a9ded259d9649e20e27 | refs/heads/master | 2016-09-05T11:44:00.831438 | 2010-03-10T23:14:22 | 2010-03-10T23:14:22 | 32,632,823 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 247 | h | #ifndef _VECTOR1_
#define _VECTOR1_
class Vector1
{
public:
float x;
public:
Vector1();
Vector1(float _x);
Vector1(const Vector1 & v);
virtual ~Vector1();
inline virtual float & X() { return x; }
};
#endif // _VECTOR1_ | [
"edouard.roge@ab19582e-f48f-11de-8f43-4547254af6c6"
]
| [
[
[
1,
19
]
]
]
|
38bf407f97a7ea877c45b28ad916bf282b20d0a5 | 9c62af23e0a1faea5aaa8dd328ba1d82688823a5 | /rl/tags/v0-1/engine/ui/src/InGameMenuWindow.cpp | aac1f5d265a624e776641cda4acdf2fe81a822e9 | [
"ClArtistic",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-public-domain"
]
| permissive | jacmoe/dsa-hl-svn | 55b05b6f28b0b8b216eac7b0f9eedf650d116f85 | 97798e1f54df9d5785fb206c7165cd011c611560 | refs/heads/master | 2021-04-22T12:07:43.389214 | 2009-11-27T22:01:03 | 2009-11-27T22:01:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,066 | cpp | /* This source file is part of Rastullahs Lockenpracht.
* Copyright (C) 2003-2005 Team Pantheon. http://www.team-pantheon.de
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the Clarified Artistic License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* Clarified Artistic License for more details.
*
* You should have received a copy of the Clarified Artistic License
* along with this program; if not you can get it here
* http://www.jpaulmorrison.com/fbp/artistic2.htm.
*/
#include <boost/bind.hpp>
#include "UiPrerequisites.h"
#include "UiSubsystem.h"
#include "CoreSubsystem.h"
#include "InGameMenuWindow.h"
#include "Action.h"
#include "ActionManager.h"
#include <map>
using namespace CEGUI;
using namespace Ogre;
using std::map;
namespace rl {
InGameMenuWindow::InGameMenuWindow()
: CeGuiWindow("ingamemenuwindow.xml", WND_MOUSE_INPUT)
{
update();
}
InGameMenuWindow::~InGameMenuWindow()
{
}
void InGameMenuWindow::createMenu(MenuBase* menu)
{
CEGUI::WindowManager* windowMan = CEGUI::WindowManager::getSingletonPtr();
const ActionVector actions = ActionManager::getSingleton().getInGameGlobalActions();
map<CeGuiString, PopupMenu*> menuGroups;
for (ActionVector::const_iterator actIter = actions.begin(); actIter != actions.end(); actIter++)
{
Action* action = *actIter;
ActionGroup* group = action->getGroup();
if (group != NULL)
{
PopupMenu* menuGrp;
map<CeGuiString, PopupMenu*>::iterator grpIter = menuGroups.find(group->getName());
if (grpIter != menuGroups.end())
{
menuGrp = (*grpIter).second;
}
else
{
MenuItem* grpItem = static_cast<MenuItem*>(windowMan->createWindow("RastullahLook/MenuItem", getNamePrefix()+"IngameMenu/"+group->getName()));
grpItem->setText(group->getName());
menu->addChildWindow(grpItem);
menuGrp = static_cast<PopupMenu*>(windowMan->createWindow("RastullahLook/PopupMenu", getNamePrefix()+"IngameMenu/Menu"+group->getName()));
grpItem->addChildWindow(menuGrp);
menuGroups[group->getName()] = menuGrp;
}
MenuItem* item = static_cast<MenuItem*>(windowMan->createWindow("RastullahLook/MenuItem", getNamePrefix()+"IngameMenu/"+group->getName()+"/"+action->getName()));
item->setText(action->getDescription());
menuGrp->addChildWindow(item);
setAction(item, action);
}
}
}
void InGameMenuWindow::setAction(MenuItem* item, Action* action)
{
item->subscribeEvent(
MenuItem::EventClicked,
boost::bind(
&InGameMenuWindow::handleAction,
this,
action));
}
bool InGameMenuWindow::handleAction(Action* action)
{
action->doAction(NULL, NULL, NULL);
setVisible(false);
return true;
}
void InGameMenuWindow::update()
{
createMenu(getMenu("InGameMenu/Menubar"));
}
}
| [
"blakharaz@4c79e8ff-cfd4-0310-af45-a38c79f83013"
]
| [
[
[
1,
109
]
]
]
|
17d7550f21ceaca9b530a912944698af691101fb | 14a00dfaf0619eb57f1f04bb784edd3126e10658 | /lab6/TrilinearInterpolator.h | fa94a43f01b5d3342d67b743714c7e3dd554d274 | []
| no_license | SHINOTECH/modanimation | 89f842262b1f552f1044d4aafb3d5a2ce4b587bd | 43d0fde55cf75df9d9a28a7681eddeb77460f97c | refs/heads/master | 2021-01-21T09:34:18.032922 | 2010-04-07T12:23:13 | 2010-04-07T12:23:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 445 | h | #ifndef __TRILINEAR_INTERPOLATOR_H__
#define __TRILINEAR_INTERPOLATOR_H__
#include "Interpolator.h"
class TrilinearInterpolator : public Interpolator
{
public:
TrilinearInterpolator();
~TrilinearInterpolator();
virtual Vector3<float> interpolate(float x, float y, float z, const Volume<Vector3<float> >& grid);
virtual float interpolate(float x, float y, float z, const Volume<float >& grid);
protected:
};
#endif
| [
"onnepoika@da195381-492e-0410-b4d9-ef7979db4686"
]
| [
[
[
1,
18
]
]
]
|
306aa513bb195e7db00561fe5e6612a2e3aeb203 | 7fa7330c8279b22db538c27a027cf40efad1092f | /ExeParser.cpp | 377aeb5b46e5a5703b1d8f3de85dad2927b376c4 | []
| no_license | andrewrk/Secure-WordVault | 1483626ffe622c7f98865daac4fa9fd6e3dd4c88 | 408de2c1ec7e119d253336c5ebd07f4a60793d7f | refs/heads/master | 2023-03-13T07:13:14.609768 | 2010-04-29T00:12:55 | 2010-04-29T00:18:06 | 605,539 | 2 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 2,630 | cpp | #include "ExeParser.h"
#include <QApplication>
#include <cassert>
// generated from http://www.guidgenerator.com/online-guid-generator.aspx
const unsigned char guid[] = {0x7c, 0x7a, 0x64, 0x0e, 0x9b, 0x4f, 0x42, 0x58, 0xa8, 0xb4, 0xd8, 0x4b, 0xd5, 0x8a, 0x05, 0x14};
void ExeParser::parse(QFile & openFile, qint64 & contentStart, qint64 & contentEnd) {
// check the size
qint64 fileSize = openFile.size();
qint64 footerSize = sizeof(guid) + sizeof(qint64);
assert(fileSize >= footerSize);
// read the footer
openFile.seek(fileSize - footerSize);
qint64 contentSize;
openFile.read((char *)&contentSize, sizeof(qint64));
unsigned char guidBuffer[sizeof(guid)];
openFile.read((char *)guidBuffer, sizeof(guid));
// check the guid
if (memcmp(guidBuffer, guid, sizeof(guid)) != 0) {
// guid doesn't match. no content.
contentStart = fileSize;
contentEnd = fileSize;
return;
}
// check the size (make sure it's in the file)
assert(fileSize >= contentSize + footerSize);
// output
contentEnd = fileSize - footerSize;
contentStart = contentEnd - contentSize;
}
void ExeParser::copyOnlyExe(QString exeFileSource, QString exeFileDest)
{
// read source
QFile in(exeFileSource);
in.open(QIODevice::ReadOnly);
qint64 contentStart, contentEnd;
parse(in, contentStart, contentEnd);
// open out file
QFile out(exeFileDest);
out.open(QIODevice::WriteOnly);
// copy exe code to out file
in.seek(0);
out.write(in.read(contentStart));
// close
in.close();
out.close();
}
QByteArray ExeParser::read(QString exeFile)
{
QFile in(exeFile);
in.open(QIODevice::ReadOnly);
qint64 contentStart, contentEnd;
parse(in, contentStart, contentEnd);
in.seek(contentStart);
QByteArray doc = in.read(contentEnd - contentStart);
in.close();
return doc;
}
void ExeParser::write(QString exeFile, QByteArray document)
{
// if the file doesn't exist, copy this exe to it
QFile out(exeFile);
if (! out.exists())
copyOnlyExe(QApplication::applicationFilePath(), exeFile);
// overwrite the document
out.open(QIODevice::ReadWrite);
qint64 contentStart, contentEnd;
parse(out, contentStart, contentEnd);
out.seek(contentStart);
out.write(document);
// write footer
qint64 size = document.size();
out.write((const char *) &size, sizeof(qint64));
out.write((const char *) guid, sizeof(guid));
out.close();
}
| [
"[email protected]",
"[email protected]"
]
| [
[
[
1,
2
],
[
6,
12
],
[
14,
30
],
[
32,
37
]
],
[
[
3,
5
],
[
13,
13
],
[
31,
31
],
[
38,
95
]
]
]
|
5159f37f2133b153b60e50591efdb8ee8cb77299 | 8fcf3f01e46f8933b356f763c61938ab11061a38 | /Parser/ParserMessage.h | 04a11a076a09be8ba405783d2a22169ca154a86c | []
| no_license | jonesbusy/parser-effex | 9facab7e0ff865d226460a729f6cb1584e8798da | c8c00e7f9cf360c0f70d86d1929ad5b44c5521be | refs/heads/master | 2021-01-01T16:50:16.254785 | 2011-02-26T22:27:05 | 2011-02-26T22:27:05 | 33,957,768 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,512 | h | #ifndef PARSERMESSAGE_H_INCLUDED
#define PARSERMESSAGE_H_INCLUDED
/**
* \file ParserMessage.h
* \author Valentin Delaye
* \version 1.0
* \date 04.04.2010
*
* Les differents messages d'erreur du parseur. Il est possible de changer
* la langue moyennant une recompilation. La langue peut-etre changee en
* modifiant la constante language.
*/
#include <string>
/*! Language en cours */
const int language = 1;
/*! Caractere inconnu */
const char* const UNKNOWN_CHAR[] = {"Illegal character found", "Caractere inconnu trouve"};
/*! Nombre attendu */
const char* const DIGIT_EXPECTED[] = {"Digit expected", "Nombre attendu"};
/*! Operande attendu */
const char* const MISSING_OPERAND[] = {"Missing operand", "Operande attendu"};
/*! Operateur attendu */
const std::string OPERATOR_EXPECTED[] = {"Operator expected", "Operateur attendu"};
/*! Parenthese droite attendu */
const std::string RIGHT_PAREN_EXPECTED[] = {"Right parenthesis expected", "Parenthese droite attendue"};
/*! Parenthese gauche attendue */
const std::string LEFT_PAREN_EXPECTED[] = {"Left parenthesis expected", "Parenthese gauche attendue"};
/*! Trop de parenthese(s) droite */
const std::string TOO_MANY_RIGHT_PARENT[] = {"Too many right parenthesis", "Trop de parenthese(s) droite"};
/*! Nom de fonction inconnu */
const std::string UNKNOWN_FUNCTION[] = {"Unknow name function", "Nom de fonction inconnu"};
#endif // PARSERMESSAGE_H_INCLUDED
| [
"jonesbusy@fa255007-c97c-c9ae-ff28-e9f0558300b6"
]
| [
[
[
1,
38
]
]
]
|
476879fefd7f4e596bb978b9d65487b3a53d8fec | c3531ade6396e9ea9c7c9a85f7da538149df2d09 | /Param/include/hj_3rd/hjlib/sparse_old/sparse.h | 11f8388e8c93e4bfbe1f49d1147f04b4975cd452 | []
| no_license | feengg/MultiChart-Parameterization | ddbd680f3e1c2100e04c042f8f842256f82c5088 | 764824b7ebab9a3a5e8fa67e767785d2aec6ad0a | refs/heads/master | 2020-03-28T16:43:51.242114 | 2011-04-19T17:18:44 | 2011-04-19T17:18:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,788 | h | #ifndef HJ_SPARSE_H_
#define HJ_SPARSE_H_
#include "config.h"
#include <hj_3rd/zjucad/matrix/matrix.h>
#include <vector>
#include <map>
namespace hj { namespace sparse {
#ifdef __GNUG__
#define DEPRECATED __attribute__((deprecated))
#endif
#ifdef _MSC_VER
#define DEPRECATED __declspec(deprecated)
#endif
template <typename T>
class spm_csc // sparse matrix csc format
{
public:
spm_csc(){}
spm_csc(int rows, int cols, int nnz = 0) {
resize(rows, cols, nnz);
}
void resize(int rows, int cols, int nnz = 0) {
assert(rows >= 0 && cols >= 0 && nnz >= 0);
rows_ = rows;
ptr_.resize(cols+1);
ptr_[0] = 0;
idx_.resize(nnz);
val_.resize(nnz);
}
int size(int dim) const {
return (dim == 1)?rows_:(ptr_.size()-1);
}
zjucad::matrix::matrix<int> ptr_, idx_;
zjucad::matrix::matrix<T> val_;
int rows_;
};
template <typename T>
inline int nnz(const spm_csc<T> &A) {
return A.idx_.size();
}
/// convert
template <typename E, typename T>
spm_csc<T> &convert(const zjucad::matrix::matrix_expression<E> &A, spm_csc<T> &B, T eps = 0)
{
B.resize(A().size(1), A().size(2), zjucad::matrix::sum<int>(fabs(A) >= eps));
int ci = 0, ri = 0, pi = 0, vi = 0, ai = 0;
for(; ci < A().size(2); ++ci) { // for each column
B.ptr_[ci+1] = B.ptr_[ci];
for(ri = 0; ri < A().size(1); ++ri, ++ai) {
if(fabs(A()[ai]) < eps) continue;
++B.ptr_[ci+1];
B.idx_[vi] = ri;
B.val_[vi]= A()[ai];
++vi;
}
}
assert(vi == nnz(B));
return B;
}
template <typename E, typename T>
zjucad::matrix::matrix_expression<E> &
convert(const spm_csc<T> &A, zjucad::matrix::matrix_expression<E> &B)
{
B() = zeros(A.size(1), A.size(2));
int ci = 0, ri = 0, pi = 0, vi = 0, ai = 0;
for(; ci < A.size(2); ++ci) { // for each column
B()(zjucad::matrix::colon(), ci)
(A.idx_(zjucad::matrix::colon(A.ptr_[ci], A.ptr_[ci+1]-1)))
= A.val_(zjucad::matrix::colon(A.ptr_[ci], A.ptr_[ci+1]-1));
}
return B;
}
template <typename T1, typename T2>
spm_csc<T2> &convert(const std::vector<std::map<int, T1> > &vmM, spm_csc<T2> &cscM, int rows)
{
cscM.rows_ = rows;
const int cols = static_cast<int>(vmM.size());
cscM.ptr_.resize(cols+1);
cscM.ptr_[0] = 0;
int i, row_i;
for(i = 0; i < cols; ++i) // for each column
cscM.ptr_[i+1] = cscM.ptr_[i]+static_cast<int>(vmM[i].size());
cscM.idx_.resize(cscM.ptr_[cols]);
cscM.val_.resize(cscM.ptr_[cols]);
std::map<int, double>::const_iterator mi;
for(i = 0; i < cols; ++i) { // for each column
const std::map<int, double> &col = vmM[i];
for(row_i = cscM.ptr_[i], mi = col.begin(); row_i < cscM.ptr_[i+1]; ++row_i, ++mi) {
cscM.idx_[row_i] = mi->first;
cscM.val_[row_i] = mi->second;
}
}
return cscM;
}
/// operation
// NOTICE: C = A+B
template <typename T1, typename T2, typename T3>
spm_csc<T3> &spm_mpm(const spm_csc<T1> &A, const spm_csc<T2> &B, spm_csc<T3> &C)
{
assert(A.size(1) == B.size(1) && A.size(2) == B.size(2));
const int rows = A.size(1), cols = A.size(2);
std::vector<std::map<int, double> > mapC(cols);
int i, j;
for(i = 0; i < cols; ++i) {
std::map<int, double> &col = mapC[i];
for(j = A.ptr_[i]; j < A.ptr_[i+1]; ++j)
col[A.idx_[j]] += A.val_[j];
for(j = B.ptr_[i]; j < B.ptr_[i+1]; ++j)
col[B.idx_[j]] += B.val_[j];
}
return convert(mapC, C, rows);
}
// NOTICE: C += A*B
template <typename T, typename M1, typename M2>
M2 &spm_mm(bool transA, const spm_csc<T> &A,
bool transB, const zjucad::matrix::matrix_expression<M1> &B,
bool transC, zjucad::matrix::matrix_expression<M2> &C)
{
using namespace zjucad::matrix;
#define spm_mm_MULT(op) \
for(int ci = 0; ci < A.size(2); ++ci) { for(; vi < A.ptr_[ci+1]; ++vi) { \
op;\
}}
int vi = A.ptr_[0];
if(transA) {
if(transB) {
if(transC) {
spm_mm_MULT(C()(colon(), ci) += A.val_[vi]*B()(colon(), A.idx_[vi]));
}
else {
spm_mm_MULT(C()(ci, colon()) += A.val_[vi]*trans(B()(colon(), A.idx_[vi])));
}
}
else {
if(transC) {
spm_mm_MULT(C()(colon(), ci) += A.val_[vi]*trans(B()(A.idx_[vi], colon())));
}
else {
spm_mm_MULT(C()(ci, colon()) += A.val_[vi]*B()(A.idx_[vi], colon()));
}
}
}
else {
if(transB) {
if(transC) {
spm_mm_MULT(C()(colon(), A.idx_[vi]) += A.val_[vi]*B()(colon(), ci));
}
else {
spm_mm_MULT(C()(A.idx_[vi], colon()) += A.val_[vi]*trans(B()(colon(), ci)));
}
}
else {
if(transC) {
spm_mm_MULT(C()(colon(), A.idx_[vi]) += A.val_[vi]*trans(B()(ci, colon())));
}
else {
spm_mm_MULT(C()(A.idx_[vi], colon()) += A.val_[vi]*B()(ci, colon()));
}
}
}
#undef spm_mm_MULT
return C();
}
template <typename T, typename V1, typename V2>
V2 &spm_mxv(const spm_csc<T> &A, const V1 &b, V2 &c)
{
int vi = A.ptr_[0];
for(int ci = 0; ci < A.size(2); ++ci) {
for(; vi < A.ptr_[ci+1]; ++vi) {
c[A.idx_[vi]] += A.val_[vi]*b[ci];
}
}
return c;
}
template <typename T, typename V1, typename V2>
V2 &spm_mTxv(const spm_csc<T> &A, const V1 &b, V2 &c)
{
int vi = A.ptr_[0];
for(int ci = 0; ci < A.size(2); ++ci) {
for(; vi < A.ptr_[ci+1]; ++vi) {
c[ci] += A.val_[vi]*b[A.idx_[vi]];
}
}
return c;
}
template <typename T1, typename T2>
hj::sparse::spm_csc<T2> &AAT(const hj::sparse::spm_csc<T1> &A, hj::sparse::spm_csc<T2> &AAT)
{
const int m = A.size(1), n = A.size(2);
std::vector<std::map<int, T2> > mapAAT(m); // [column][row]
int i, col_i = 0, row_i = 0;
for(i = 0; i < n; ++i) { // vector outer product: vvT(i, j) = vi*vj, for each v
for(col_i = A.ptr_[i]; col_i < A.ptr_[i+1]; ++col_i) { // for each nz column
if(A.val_[col_i] == 0) continue;
std::map<int, T2> &col = mapAAT[A.idx_[col_i]];
for(row_i = A.ptr_[i]; row_i < A.ptr_[i+1]; ++row_i) // scalar * sparse, for each nz row
col[A.idx_[row_i]] += A.val_[col_i]*A.val_[row_i];
}
}
return convert(mapAAT, AAT, m);
}
int inline get_idx_from_row_col(const zjucad::matrix::matrix<int> &ptr, const zjucad::matrix::matrix<int> &row_idx,
int row, int col)
{
int rtn = -1;
for(rtn = ptr[col]; rtn < ptr[col+1]; ++rtn)
if(row_idx[rtn] == row) break;
if(rtn == ptr[col+1])
return -1;
return rtn;
}
// assume that AAT have the same patten
template <typename T1, typename T2>
hj::sparse::spm_csc<T2> &fast_AAT(const hj::sparse::spm_csc<T1> &A, hj::sparse::spm_csc<T2> &AAT)
{
const int m = A.size(1), n = A.size(2);
fill(AAT.val_.begin(), AAT.val_.end(), 0);
int i, col_i = 0, row_i = 0;
for(i = 0; i < n; ++i) { // vector outer product: vvT(i, j) = vi*vj, for each v
for(col_i = A.ptr_[i]; col_i < A.ptr_[i+1]; ++col_i) { // for each nz column
if(A.val_[col_i] == 0) continue;
for(row_i = A.ptr_[i]; row_i < A.ptr_[i+1]; ++row_i) { // scalar * sparse, for each nz row
//mapAAT[A.idx_[col_i]][A.idx_[row_i]] += A.val_[col_i]*A.val_[row_i];
int pos = get_idx_from_row_col(AAT.ptr_, AAT.idx_, A.idx_[row_i], A.idx_[col_i]);
assert(pos >= 0);
AAT.val_[pos] += A.val_[col_i]*A.val_[row_i];
}
}
}
return AAT;
}
class HJ_SPARSE_API solver
{
public:
virtual ~solver();
/**
@param id "umfpack" or "cholmod", default 0 is current best
implementation
*/
DEPRECATED static solver *create(const spm_csc<double> &A, const char *id = 0);
virtual bool set_patten(int rows, const zjucad::matrix::matrix<int> &ptr, const zjucad::matrix::matrix<int> &idx) = 0;
virtual bool set_value (const zjucad::matrix::matrix<double> &val) = 0;
virtual bool solve(const double *b, double *x, int nrhs = 1) = 0;
protected:
virtual bool init(const hj::sparse::spm_csc<double> &A) = 0;
};
#undef DEPRECATED
}}
#endif
| [
"[email protected]"
]
| [
[
[
1,
277
]
]
]
|
d69a4852a4c072ebb81a614b563bf761c30319d2 | 78fb44a7f01825c19d61e9eaaa3e558ce80dcdf5 | /guidriverMyGUIOgre/src/guceMyGUIOgre_CButtonImp.cpp | f5545b1b672a7e1693fbc5adefdf641dc4da1890 | []
| no_license | LiberatorUSA/GUCE | a2d193e78d91657ccc4eab50fab06de31bc38021 | a4d6aa5421f8799cedc7c9f7dc496df4327ac37f | refs/heads/master | 2021-01-02T08:14:08.541536 | 2011-09-08T03:00:46 | 2011-09-08T03:00:46 | 41,840,441 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,905 | cpp | /*
* guceMyGUIOgre: glue module for the MyGUI+Ogre GUI backend
* Copyright (C) 2002 - 2007. Dinand Vanvelzen
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*-------------------------------------------------------------------------//
// //
// INCLUDES //
// //
//-------------------------------------------------------------------------*/
#ifndef GUCEF_CORE_CTRACER_H
#include "CTracer.h"
#define GUCEF_CORE_CTRACER_H
#endif /* GUCEF_CORE_CTRACER_H ? */
#include "guceMyGUIOgre_CButtonImp.h"
/*-------------------------------------------------------------------------//
// //
// NAMESPACE //
// //
//-------------------------------------------------------------------------*/
namespace GUCE {
namespace MYGUIOGRE {
/*-------------------------------------------------------------------------//
// //
// UTILITIES //
// //
//-------------------------------------------------------------------------*/
CButtonImp::CButtonImp( void )
: CWidgetImp< GUCEF::GUI::CButton >() ,
m_button( NULL )
{GUCE_TRACE;
}
/*-------------------------------------------------------------------------*/
CButtonImp::~CButtonImp()
{GUCE_TRACE;
m_button = NULL;
}
/*-------------------------------------------------------------------------*/
bool
CButtonImp::SetButtonText( const CString& newText )
{GUCE_TRACE;
if ( NULL != m_button )
{
m_button->setCaption( newText.C_String() );
}
return true;
}
/*-------------------------------------------------------------------------*/
bool
CButtonImp::GetButtonText( CString& text ) const
{GUCE_TRACE;
if ( NULL != m_button )
{
text = m_button->getCaption().asUTF8();
}
return true;
}
/*-------------------------------------------------------------------------*/
void
CButtonImp::Hook( MyGUI::Button* button )
{GUCE_TRACE;
m_button = button;
CWidgetImp< GUCEF::GUI::CButton >::Hook( button );
}
/*-------------------------------------------------------------------------*/
void
CButtonImp::OnMouseClick( MyGUI::Widget* sender )
{GUCE_TRACE;
GUCEF_USER_LOG( GUCEF::CORE::LOGLEVEL_NORMAL, "MyGUIOgre: User clicked button \"" + GetName() + "\"" );
CWidgetImp< GUCEF::GUI::CButton >::OnMouseClick( sender );
NotifyObservers( ButtonClickedEvent );
}
/*-------------------------------------------------------------------------*/
void
CButtonImp::OnMouseButtonPressed( MyGUI::Widget* sender ,
int left ,
int top ,
MyGUI::MouseButton button )
{GUCE_TRACE;
GUCEF_USER_LOG( GUCEF::CORE::LOGLEVEL_NORMAL, "MyGUIOgre: User pressed button \"" + GetName() + "\"" );
CWidgetImp< GUCEF::GUI::CButton >::OnMouseButtonPressed( sender ,
left ,
top ,
button );
NotifyObservers( ButtonDownEvent );
}
/*-------------------------------------------------------------------------*/
void
CButtonImp::OnMouseButtonReleased( MyGUI::Widget* sender ,
int left ,
int top ,
MyGUI::MouseButton button )
{GUCE_TRACE;
GUCEF_USER_LOG( GUCEF::CORE::LOGLEVEL_NORMAL, "MyGUIOgre: User released button \"" + GetName() + "\"" );
CWidgetImp< GUCEF::GUI::CButton >::OnMouseButtonReleased( sender ,
left ,
top ,
button );
NotifyObservers( ButtonUpEvent );
}
/*-------------------------------------------------------------------------//
// //
// NAMESPACE //
// //
//-------------------------------------------------------------------------*/
}; /* namespace MYGUIOGRE */
}; /* namespace GUCE */
/*-------------------------------------------------------------------------*/
| [
"[email protected]"
]
| [
[
[
1,
156
]
]
]
|
e0bf88182bdc5349c8138b6c4d7c2c245408dded | 0bce46a5dd859d82824f4b74c4adecd7b4bc2387 | /sourcecode/tower.cpp | cfd7f010e0383155f1c5a2667710a797d149b97f | []
| no_license | xflash/moon-invaders | a08e00ddb590fa3bd395e65bb793a67166a27eb1 | 8124f4787a8b1b201e85c17010620488f51827a4 | refs/heads/master | 2021-01-25T08:38:05.896106 | 2009-02-19T09:41:38 | 2009-02-19T09:41:38 | 32,315,985 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,335 | cpp | #include "tower.h"
#include "sprites.h"
#include "bullet.h"
#include "invader.h"
#include "input.h"
#include "player.h"
#include "sound.h"
#include "systemstub.h"
tower_t tower[MAX_TOWERS];
byte towerPrice[TWR_TYPES]={0,3,4,5,6,10,7};
void ClearTowers(void)
{
int i;
for(i=0;i<MAX_TOWERS;i++)
tower[i].type=0;
}
void PlaceTower(float x,byte type)
{
int i,j;
for(i=0;i<MAX_TOWERS;i++)
{
if(tower[i].type==0)
{
tower[i].type=type;
tower[i].x=x;
tower[i].charge=0;
tower[i].chargeAmt=0;
for(j=0;j<10;j++)
tower[i].upg[j]=0;
switch(type)
{
case TWR_GUN:
tower[i].dmg=2;
tower[i].maxReload=30;
break;
case TWR_ACID:
tower[i].dmg=4;
tower[i].maxReload=30*2;
tower[i].range=SPR_SIZE/2;
tower[i].freeze=30;
break;
case TWR_MINE:
tower[i].maxReload=30*20;
break;
case TWR_MISSILE:
tower[i].dmg=7;
tower[i].maxReload=30*5;
tower[i].range=SPR_SIZE;
tower[i].freeze=0;
break;
case TWR_CRYO:
tower[i].dmg=1;
tower[i].maxReload=30*3;
tower[i].range=SPR_SIZE;
tower[i].freeze=30;
break;
case TWR_POWER:
tower[i].dmg=1;
tower[i].maxReload=30*5;
tower[i].range=SPR_SIZE;
tower[i].freeze=30;
break;
}
tower[i].upgCost=1;
tower[i].reload=tower[i].maxReload;
return;
}
}
}
void PowerTowers(float x,float range,word duration,byte dmg)
{
int i;
for(i=0;i<MAX_TOWERS;i++)
{
if(tower[i].x+SPR_SIZE>=x-range && tower[i].x<=x+range)
{
if(tower[i].chargeAmt+dmg<=10)
tower[i].chargeAmt+=dmg;
else
tower[i].chargeAmt=10;
if(tower[i].charge<duration)
tower[i].charge=duration;
}
}
}
void UpdateTower(tower_t *me)
{
word w;
if(me->reload==0)
{
switch(me->type)
{
case TWR_GUN:
FireBullet(me,0);
Sound(SND_GUN);
me->reload=me->maxReload;
break;
case TWR_MINE:
if(player.money<160)
{
player.money++;
if(me->chargeAmt && player.money<160)
player.money++;
me->reload=me->maxReload;
Sound(SND_MINE);
}
break;
case TWR_MISSILE:
FireBullet(me,0);
Sound(SND_MISSILE);
me->reload=me->maxReload;
break;
case TWR_CRYO:
w=FindTarget(me->x+SPR_SIZE/2,me->range,0);
if(w)
{
FireBullet(me,w-1);
Sound(SND_LASER);
me->reload=me->maxReload;
}
break;
case TWR_POWER:
PowerTowers(me->x+SPR_SIZE/2,me->range,me->freeze,me->dmg);
me->reload=me->maxReload;
Sound(SND_POWER);
FireBullet(me,0);
break;
case TWR_ACID:
FireBullet(me,0);
Sound(SND_GUN);
me->reload=me->maxReload;
break;
}
}
else
{
me->reload--;
}
if(me->charge)
me->charge--;
else
me->chargeAmt=0;
}
void UpdateTowers(void)
{
int i;
for(i=0;i<MAX_TOWERS;i++)
{
if(tower[i].type)
UpdateTower(&tower[i]);
}
}
byte RoomForYou(float x)
{
int i;
for(i=0;i<MAX_TOWERS;i++)
{
if(tower[i].type && tower[i].x>x-SPR_SIZE && tower[i].x<x+SPR_SIZE)
return 0;
}
return 1;
}
byte TowerPic(byte type)
{
switch(type)
{
case TWR_GUN:
return SPR_GUNTOWER;
break;
case TWR_MINE:
return SPR_MINE;
break;
case TWR_CRYO:
return SPR_TANK;
break;
case TWR_MISSILE:
return SPR_LAUNCHER;
break;
case TWR_POWER:
return SPR_POWER;
break;
case TWR_ACID:
return SPR_ACID;
break;
}
return 0;
}
void RenderTowers(void)
{
int i,h;
for(i=0;i<MAX_TOWERS;i++)
{
if(player.mode==PM_UPGRADE && i==player.upTower)
{
systemStub->drawSpriteColored(TowerPic(tower[i].type),tower[i].x-2,TOWER_Y-SPR_SIZE-2,0,1,1,0.5f);
systemStub->drawSpriteColored(TowerPic(tower[i].type),tower[i].x-2,TOWER_Y-SPR_SIZE+2,0,1,1,0.5f);
systemStub->drawSpriteColored(TowerPic(tower[i].type),tower[i].x+2,TOWER_Y-SPR_SIZE+2,0,1,1,0.5f);
systemStub->drawSpriteColored(TowerPic(tower[i].type),tower[i].x+2,TOWER_Y-SPR_SIZE-2,0,1,1,0.5f);
if(tower[i].type==TWR_CRYO)
systemStub->drawRect(tower[i].x+SPR_SIZE/2-tower[i].range,0,tower[i].x+SPR_SIZE/2+tower[i].range,TOWER_Y,0,1,1,0.3f);
if(tower[i].type==TWR_POWER)
systemStub->drawRect(tower[i].x+SPR_SIZE/2-tower[i].range,0,tower[i].x+SPR_SIZE/2+tower[i].range,TOWER_Y,1,1,0,0.3f);
}
if(tower[i].type==TWR_MINE)
{
h=(int)(18.5f-18.5f*(float)tower[i].reload/(float)tower[i].maxReload);
systemStub->drawRect((float)(tower[i].x+10),(float)(TOWER_Y-h),tower[i].x+22,TOWER_Y,0,1,0,1);
}
if(tower[i].type)
{
if(tower[i].charge)
systemStub->drawSpriteColored(TowerPic(tower[i].type),tower[i].x,TOWER_Y-SPR_SIZE,1,1,0,1);
else
systemStub->drawSprite(TowerPic(tower[i].type),tower[i].x,TOWER_Y-SPR_SIZE);
}
}
}
byte OnTower(void)
{
int i;
for(i=0;i<MAX_TOWERS;i++)
{
if(tower[i].type && MouseIsIn(tower[i].x,TOWER_Y-SPR_SIZE,tower[i].x+SPR_SIZE,TOWER_Y))
{
return (byte)(i+1);
}
}
return 0;
}
void SellTower(void)
{
int i;
byte c;
c=towerPrice[tower[player.upTower].type];
for(i=0;i<10;i++)
if(tower[player.upTower].upg[i])
c+=(i+1);
if(player.money+(c/2)<=160)
player.money+=(c/2);
else
player.money=160;
tower[player.upTower].type=0;
}
void UpgradeTower(byte upType)
{
int i,amt;
if(player.money<tower[player.upTower].upgCost)
{
Sound(SND_NOMONEY);
return; // can't afford
}
for(i=0;i<10;i++)
if(!tower[player.upTower].upg[i])
{
tower[player.upTower].upg[i]=upType;
player.money-=tower[player.upTower].upgCost;
if(tower[player.upTower].upgCost<10)
tower[player.upTower].upgCost++;
switch(upType)
{
case UG_DMG:
tower[player.upTower].dmg++;
if(tower[player.upTower].type==TWR_MISSILE)
tower[player.upTower].dmg++;
break;
case UG_RELOAD:
if(tower[player.upTower].type==TWR_GUN || tower[player.upTower].type==TWR_ACID)
amt=6;
else
amt=10;
if(tower[player.upTower].maxReload>amt)
tower[player.upTower].maxReload-=amt;
if(tower[player.upTower].reload>tower[player.upTower].maxReload)
tower[player.upTower].reload=tower[player.upTower].maxReload;
break;
case UG_DRILL:
if(tower[player.upTower].maxReload>30)
tower[player.upTower].maxReload-=30;
if(tower[player.upTower].reload>tower[player.upTower].maxReload)
tower[player.upTower].reload=tower[player.upTower].maxReload;
break;
case UG_FREEZE:
tower[player.upTower].freeze+=30;
break;
case UG_TIME:
tower[player.upTower].freeze+=15;
break;
case UG_RADIUS:
tower[player.upTower].range+=10.0f;
break;
case UG_RANGE:
tower[player.upTower].range+=SPR_SIZE/2.0f;
break;
case UG_BUNKER:
// nothing
break;
}
Sound(SND_UPGRADE);
return;
}
Sound(SND_NOMONEY);
return; // no room for upgrades
}
byte SaveLife(void)
{
int i,j;
for(i=0;i<MAX_TOWERS;i++)
{
if(tower[i].type==TWR_MINE)
{
for(j=0;j<10;j++)
{
if(tower[i].upg[j]==UG_BUNKER)
{
tower[i].upg[j]=0;
return 1;
}
}
}
}
return 0;
} | [
"rcoqueugniot@19f3d9c2-fe69-11dd-a3ef-1f8437fb274a"
]
| [
[
[
1,
350
]
]
]
|
eb6661e3d0806cd8ff7755f36286eb74e3ed3bb4 | 5ac13fa1746046451f1989b5b8734f40d6445322 | /minimangalore/Nebula2/code/contrib/nxsi/inc/nxsi/nxsioptions.h | 036812e73b0c00c67dc53d66bdae1a8f3e0c28b8 | []
| no_license | moltenguy1/minimangalore | 9f2edf7901e7392490cc22486a7cf13c1790008d | 4d849672a6f25d8e441245d374b6bde4b59cbd48 | refs/heads/master | 2020-04-23T08:57:16.492734 | 2009-08-01T09:13:33 | 2009-08-01T09:13:33 | 35,933,330 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,490 | h | //-----------------------------------------------------------------------------
// Copyright (c) Ville Ruusutie, 2004. All Rights Reserved.
//-----------------------------------------------------------------------------
// See the file "nxsi_license.txt" for information on usage and redistribution
// of this file, and for a DISCLAIMER OF ALL WARRANTIES.
//-----------------------------------------------------------------------------
#ifndef N_XSI_OPTIONS_H
#define N_XSI_OPTIONS_H
//-----------------------------------------------------------------------------
#include <cassert>
//-----------------------------------------------------------------------------
class nXSIOptions
{
public:
enum OutputFlags {
OUTPUT_MESH = (1<<1),
OUTPUT_ANIM = (1<<2),
OUTPUT_SCRIPT = (1<<3),
OUTPUT_AUTO = (1<<4),
OUTPUT_MERGEALL = (1<<5),
OUTPUT_BINARY = (1<<6),
};
~nXSIOptions();
nXSIOptions();
void Parse(int argc, char* argv[]);
void Usage() const;
inline const nString& GetXSIFilename() const;
inline const nString& GetMeshFilename() const;
inline const nString& GetAnimFilename() const;
inline const nString& GetScriptFilename() const;
inline const nString& GetScriptServerName() const;
inline int GetOutputFlags() const;
private:
nString xsiFilename; ///< .xsi
nString meshFilename; ///< .n3d2 or .nvx2
nString animFilename; ///< .nanim2 or .nax2
nString scriptFilename; ///< main script (.n2) filename
nString scriptServerName; ///< script server name (default: ntclserver)
int outputFlags;
};
//-----------------------------------------------------------------------------
inline const nString& nXSIOptions::GetXSIFilename() const
{
return this->xsiFilename;
}
inline const nString& nXSIOptions::GetMeshFilename() const
{
return this->meshFilename;
}
inline const nString& nXSIOptions::GetAnimFilename() const
{
return this->animFilename;
}
inline const nString& nXSIOptions::GetScriptFilename() const
{
return this->scriptFilename;
}
inline const nString& nXSIOptions::GetScriptServerName() const
{
return this->scriptServerName;
}
inline int nXSIOptions::GetOutputFlags() const
{
return this->outputFlags;
}
//-----------------------------------------------------------------------------
#endif // Eof | [
"BawooiT@d1c0eb94-fc07-11dd-a7be-4b3ef3b0700c"
]
| [
[
[
1,
82
]
]
]
|
1008526bbd25ea887e28e760f716495b5d0ff905 | 26706a661c23f5c2c1f97847ba09f44b7b425cf6 | /TaskManager/SortHeaderCtrl.cpp | 7df565621796ef672a78be3d0a2537e0304d93d5 | []
| no_license | 124327288/nativetaskmanager | 96a54dbe150f855422d7fd813d3631eaac76fadd | e75b3d9d27c902baddbb1bef975c746451b1b8bb | refs/heads/master | 2021-05-29T05:18:26.779900 | 2009-02-10T13:23:28 | 2009-02-10T13:23:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,562 | cpp | /*----------------------------------------------------------------------
Copyright (C)2001 MJSoft. All Rights Reserved.
This source may be used freely as long as it is not sold for
profit and this copyright information is not altered or removed.
Visit the web-site at www.mjsoft.co.uk
e-mail comments to [email protected]
The code for drawing the arrow in the header control was
written by Zafir Anjum
File: SortHeaderCtrl.cpp
Purpose: Provides the header control, with drawing of the arrows, for
the list control.
----------------------------------------------------------------------*/
#include "stdafx.h"
#include "SortHeaderCtrl.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
CSortHeaderCtrl::CSortHeaderCtrl()
: m_iSortColumn( -1 )
, m_bSortAscending( TRUE )
{
}
CSortHeaderCtrl::~CSortHeaderCtrl()
{
}
BEGIN_MESSAGE_MAP(CSortHeaderCtrl, CHeaderCtrl)
//{{AFX_MSG_MAP(CSortHeaderCtrl)
// NOTE - the ClassWizard will add and remove mapping macros here.
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CSortHeaderCtrl message handlers
void CSortHeaderCtrl::SetSortArrow( const int iSortColumn, const BOOL bSortAscending )
{
m_iSortColumn = iSortColumn;
m_bSortAscending = bSortAscending;
// change the item to owner drawn.
HD_ITEM hditem;
hditem.mask = HDI_FORMAT;
VERIFY( GetItem( iSortColumn, &hditem ) );
hditem.fmt |= HDF_OWNERDRAW;
VERIFY( SetItem( iSortColumn, &hditem ) );
// invalidate the header control so it gets redrawn
//Invalidate();
RedrawWindow();
}
void CSortHeaderCtrl::DrawItem( LPDRAWITEMSTRUCT lpDrawItemStruct )
{
// attath to the device context.
CDC dc;
VERIFY( dc.Attach( lpDrawItemStruct->hDC ) );
// save the device context.
const int iSavedDC = dc.SaveDC();
// get the column rect.
CRect rc( lpDrawItemStruct->rcItem );
// set the clipping region to limit drawing within the column.
CRgn rgn;
VERIFY( rgn.CreateRectRgnIndirect( &rc ) );
(void)dc.SelectObject( &rgn );
VERIFY( rgn.DeleteObject() );
// draw the background,
CBrush brush( GetSysColor( COLOR_3DFACE ) );
dc.FillRect( rc, &brush );
// get the column text and format.
TCHAR szText[ 256 ]={0};
HD_ITEM hditem;
hditem.mask = HDI_TEXT | HDI_FORMAT;
hditem.pszText = szText;
hditem.cchTextMax = 255;
VERIFY( GetItem( lpDrawItemStruct->itemID, &hditem ) );
// determine the format for drawing the column label.
UINT uFormat = DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP | DT_VCENTER | DT_END_ELLIPSIS ;
if( hditem.fmt & HDF_CENTER)
uFormat |= DT_CENTER;
else if( hditem.fmt & HDF_RIGHT)
uFormat |= DT_RIGHT;
else
uFormat |= DT_LEFT;
// adjust the rect if the mouse button is pressed on it.
if( lpDrawItemStruct->itemState == ODS_SELECTED )
{
rc.left++;
rc.top += 2;
rc.right++;
}
CRect rcIcon( lpDrawItemStruct->rcItem );
const int iOffset = ( rcIcon.bottom - rcIcon.top ) / 4;
// adjust the rect further if the sort arrow is to be displayed.
if( lpDrawItemStruct->itemID == (UINT)m_iSortColumn )
rc.right -= 3 * iOffset;
rc.left += iOffset;
rc.right -= iOffset;
// draw the column label.
if( rc.left < rc.right )
(void)dc.DrawText( szText, -1, rc, uFormat );
// draw the sort arrow.
if( lpDrawItemStruct->itemID == (UINT)m_iSortColumn )
{
// set up the pens to use for drawing the arrow.
CPen penLight( PS_SOLID, 1, GetSysColor( COLOR_3DHILIGHT ) );
CPen penShadow( PS_SOLID, 1, GetSysColor( COLOR_3DSHADOW ) );
CPen* pOldPen = dc.SelectObject( &penLight );
if( m_bSortAscending )
{
// draw the arrow pointing upwards.
dc.MoveTo( rcIcon.right - 2 * iOffset, iOffset);
dc.LineTo( rcIcon.right - iOffset, rcIcon.bottom - iOffset - 1 );
dc.LineTo( rcIcon.right - 3 * iOffset - 2, rcIcon.bottom - iOffset - 1 );
(void)dc.SelectObject( &penShadow );
dc.MoveTo( rcIcon.right - 3 * iOffset - 1, rcIcon.bottom - iOffset - 1 );
dc.LineTo( rcIcon.right - 2 * iOffset, iOffset - 1);
}
else
{
// draw the arrow pointing downwards.
dc.MoveTo( rcIcon.right - iOffset - 1, iOffset );
dc.LineTo( rcIcon.right - 2 * iOffset - 1, rcIcon.bottom - iOffset );
(void)dc.SelectObject( &penShadow );
dc.MoveTo( rcIcon.right - 2 * iOffset - 2, rcIcon.bottom - iOffset );
dc.LineTo( rcIcon.right - 3 * iOffset - 1, iOffset );
dc.LineTo( rcIcon.right - iOffset - 1, iOffset );
}
// restore the pen.
(void)dc.SelectObject( pOldPen );
}
// restore the previous device context.
VERIFY( dc.RestoreDC( iSavedDC ) );
// detach the device context before returning.
(void)dc.Detach();
}
void CSortHeaderCtrl::Serialize( CArchive& ar )
{
if( ar.IsStoring() )
{
const int iItemCount = GetItemCount();
if( iItemCount != -1 )
{
ar << iItemCount;
HD_ITEM hdItem = { 0 };
hdItem.mask = HDI_WIDTH;
for( int i = 0; i < iItemCount; i++ )
{
VERIFY( GetItem( i, &hdItem ) );
ar << hdItem.cxy;
}
}
}
else
{
int iItemCount;
ar >> iItemCount;
if( GetItemCount() != iItemCount )
TRACE0( "Different number of columns in registry." );
else
{
HD_ITEM hdItem = { 0 };
hdItem.mask = HDI_WIDTH;
for( int i = 0; i < iItemCount; i++ )
{
ar >> hdItem.cxy;
VERIFY( SetItem( i, &hdItem ) );
}
}
}
}
| [
"[email protected]@97a26042-f463-11dd-a7be-4b3ef3b0700c"
]
| [
[
[
1,
205
]
]
]
|
3e068d416e73d845076ec66323362368f542191f | 94d9e8ec108a2f79068da09cb6ac903c16b77730 | /sociarium/module/graph_creation_read_pajek.cpp | ba9e1f7e0383affeab83a4e2bb47c3b2a6b80c20 | []
| no_license | kiyoya/sociarium | d375c0e5abcce11ae4b087930677483d74864d09 | b26c2c9cbd23c2f8ef219d0059e42370294865d1 | refs/heads/master | 2021-01-25T07:28:25.862346 | 2009-10-22T05:57:42 | 2009-10-22T05:57:42 | 318,115 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,163 | cpp | // s.o.c.i.a.r.i.u.m: module/graph_creation_read_pajek.cpp
// HASHIMOTO, Yasuhiro (E-mail: hy @ sys.t.u-tokyo.ac.jp)
/* Copyright (c) 2005-2009, HASHIMOTO, Yasuhiro, All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - Neither the name of the University of Tokyo nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <cassert>
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
#ifdef _MSC_VER
#include <unordered_map>
#include <windows.h>
#else
#include <tr1/unordered_map>
#endif
#include "graph_creation.h"
#include "../menu_and_message.h"
#include "../../shared/thread.h"
#include "../../shared/util.h"
#include "../../graph/graph.h"
#ifdef _MSC_VER
BOOL WINAPI DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved) {
return TRUE;
}
#endif
namespace hashimoto_ut {
using std::vector;
using std::deque;
using std::string;
using std::wstring;
using std::pair;
using std::make_pair;
using std::tr1::shared_ptr;
using std::tr1::unordered_map;
using namespace sociarium_project_menu_and_message;
using namespace sociarium_project_module_graph_creation;
#ifdef _MSC_VER
extern "C" __declspec(dllexport)
void __cdecl create_graph_time_series(
#else
extern "C" void create_graph_time_series(
#endif
Thread& parent,
deque<wstring>& status,
Message const& message,
vector<shared_ptr<Graph> >& graph,
vector<vector<NodeProperty> >& node_property,
vector<vector<EdgeProperty> >& edge_property,
vector<wstring>& layer_name,
unordered_map<wstring, pair<wstring, int> > const& params,
vector<pair<wstring, int> > const& data,
wstring const& filename) {
assert(graph.empty());
assert(node_property.empty());
assert(edge_property.empty());
assert(layer_name.empty());
assert(status.size()==2);
////////////////////////////////////////////////////////////////////////////////
// Read parameters.
bool directed = false;
wstring title;
unordered_map<wstring, pair<wstring, int> >::const_iterator pos;
if ((pos=params.find(L"directed"))!=params.end())
directed = true;
if ((pos=params.find(L"title"))!=params.end() && !pos->second.first.empty())
title = pos->second.first;
////////////////////////////////////////////////////////////////////////////////
// Make a graph and set properties.
vector<shared_ptr<Graph> >(1, Graph::create(directed)).swap(graph);
shared_ptr<Graph>& g = graph[0];
node_property.resize(1);
edge_property.resize(1);
unordered_map<wstring, Node*> identifier2node;
unordered_map<wstring, Edge*> identifier2edge;
int mode = -1;
for (size_t count=0; count<data.size(); ++count) {
// ********** Catch a termination signal **********
if (parent.cancel_check()) {
graph.clear();
return;
}
status[0]
= (boost::wformat(L"%s: %d%%")
%message.get(Message::MAKING_GRAPH_SNAPSHOT)
%int(100.0*(count+1)/data.size())).str();
wstring const line = data[count].first;
if (line.find(L"*Vertices")==0
|| line.find(L"*vertices")==0
|| line.find(L"*VERTICES")==0)
mode = 0;
else if (line.find(L"*Arcs")==0
|| line.find(L"*arcs")==0
|| line.find(L"*ARCS")==0)
mode = 1;
else if (mode==0) {
// Make nodes.
size_t head = line.find_first_of(L'\"');
size_t const tail = line.find_last_of(L'\"');
wstring id = line.substr(0, head);
trim(id);
if (identifier2node.find(id)!=identifier2node.end())
throw (boost::wformat(L"bad data: line=%d\n%s")
%data[count].second%filename.c_str()).str();
++head;
wstring const identifier = line.substr(head, tail-head);
Node* n = g->add_node();
identifier2node.insert(make_pair(id, n));
NodeProperty np;
np.identifier = identifier;
np.name = np.identifier;
np.weight = 0.0f;
node_property[0].push_back(np);
}
else if (mode==1) {
// Make edges.
vector<wstring> tok = tokenize(line, ' ');
if (tok.size()<2)
throw (boost::wformat(L"bad data: line=%d\n%s")
%data[count].second%filename.c_str()).str();
trim(tok[0]);
trim(tok[1]);
float weight = 1.0f;
if (tok.size()>2) {
trim(tok[2]);
try {
weight = boost::lexical_cast<float>(tok[2]);
} catch (...) {
weight = 1.0f;
}
}
unordered_map<wstring, Node*>::const_iterator m0
= identifier2node.find(tok[0]);
unordered_map<wstring, Node*>::const_iterator m1
= identifier2node.find(tok[1]);
if (m0==identifier2node.end() || m1==identifier2node.end())
throw (boost::wformat(L"bad data: line=%d\n%s")
%data[count].second%filename.c_str()).str();
Node* n0 = m0->second;
Node* n1 = m1->second;
if (!directed) {
n0 = m0->first<m1->first?m0->second:m1->second;
n1 = m0->first<m1->first?m1->second:m0->second;
}
wstring const& node_name0 = node_property[0][n0->index()].name;
wstring const& node_name1 = node_property[0][n1->index()].name;
wstring const identifier = L'\"'+node_name0+L"\"~"+node_name1+L'\"';
unordered_map<wstring, Edge*>::const_iterator m
= identifier2edge.find(identifier);
if (m==identifier2edge.end()) {
Edge* e = g->add_edge(n0, n1);
identifier2edge.insert(make_pair(identifier, e));
EdgeProperty ep;
ep.identifier = identifier;
ep.name = node_name0+L'~'+node_name1;
ep.weight = weight;
edge_property[0].push_back(ep);
} else
edge_property[0][m->second->index()].weight += weight;
node_property[0][n0->index()].weight += weight;
node_property[0][n1->index()].weight += weight;
}
else assert(0 && "never reach");
}
////////////////////////////////////////////////////////////////////////////////
// Set a layer name.
layer_name.push_back(title);
}
} // The end of the namespace "hashimoto_ut"
| [
"[email protected]"
]
| [
[
[
1,
232
]
]
]
|
aec5c3e0d3204c578b0142fb5b7f3c1107ccf502 | adb2ebb4b7f74f62228c7dd9ca1441ee95297243 | /UI/FeedbackForm.cpp | 9d5ad9e1f91c4ed448c3d57bbafdd5f5fe71d4a1 | []
| no_license | BackupTheBerlios/blazefilesearch-svn | 5984480677ad0a7ae64c082e16dde4e7b2394c2c | b910de6af6f1ae8e018f06a484a8b6d9c4c2f280 | refs/heads/master | 2021-01-22T17:53:29.216195 | 2005-03-05T05:17:38 | 2005-03-05T05:17:38 | 40,608,509 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 29 | cpp | #include "FeedbackForm.h"
| [
"hyperfusion@8d202536-25f0-0310-b7fd-af1e855a3320"
]
| [
[
[
1,
2
]
]
]
|
e316fac40f462b856b7cdff90ba026bacf50a11e | 1e976ee65d326c2d9ed11c3235a9f4e2693557cf | /CommonSources/ReEntryLock.h | 4633b14fd46549708157e6f178a211a907eb3c17 | []
| no_license | outcast1000/Jaangle | 062c7d8d06e058186cb65bdade68a2ad8d5e7e65 | 18feb537068f1f3be6ecaa8a4b663b917c429e3d | refs/heads/master | 2020-04-08T20:04:56.875651 | 2010-12-25T10:44:38 | 2010-12-25T10:44:38 | 19,334,292 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,736 | h | // /*
// *
// * Copyright (C) 2003-2010 Alexandros Economou
// *
// * This file is part of Jaangle (http://www.jaangle.com)
// *
// * This Program is free software; you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation; either version 2, or (at your option)
// * any later version.
// *
// * This Program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with GNU Make; see the file COPYING. If not, write to
// * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
// * http://www.gnu.org/copyleft/gpl.html
// *
// */
#ifndef _ReEntryLock_h_
#define _ReEntryLock_h_
//USAGE:
//1. Add a BOOL member variable (eg m_bLockFunction)
//2. Initialize this variable to FALSE in the class's Costructor
//3. Use it in the function you want to protect like this
// ReEntryLock lock(m_bLockFunction);
// if (lock.WasAlreadyLocked())
// {
// TRACE(_T("..."));
// return;
// }
class ReEntryLock
{
public:
ReEntryLock(BOOL& memberVar):
m_WasAlreadyLocked(FALSE),
m_memberVar(memberVar)
{
if (m_memberVar == TRUE)
m_WasAlreadyLocked = TRUE;
else
m_memberVar = TRUE;
}
~ReEntryLock()
{
if (!WasAlreadyLocked())
m_memberVar = FALSE;
}
BOOL WasAlreadyLocked(){return m_WasAlreadyLocked;}
private:
BOOL& m_memberVar;
BOOL m_WasAlreadyLocked;
};
#endif
| [
"outcast1000@dc1b949e-fa36-4f9e-8e5c-de004ec35678"
]
| [
[
[
1,
62
]
]
]
|
cd02dcd077f8b85f68ab54de2d25e2272fdb81dd | e6960d26699857b7eb203ab7847ad1f385fc99f9 | /src/BITFONT.H | c1738caab567e506f597a5250c8956b995f11ff8 | []
| no_license | tomekc/raycaster3d | 7d74990379969cc0b328728df1b4b83637bcb893 | 4a0935458e4b180eb016a3631fa1bdf5a45ced42 | refs/heads/master | 2020-05-29T11:16:06.157909 | 2011-08-19T11:48:47 | 2011-08-19T11:48:47 | 2,233,237 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 608 | h | /*
*
*
*/
#include <allegro.h>
class BitFont
{
char *header;
char *body;
int fnt_height;
int maxwidth;
int ofstab[256];
int fgcolor;
int bgcolor;
BITMAP *out_bmp;
void newcolor (const char *);
void draw_char (BITMAP *bmp, int x, int y, int ch);
public:
BitFont (void *dat);
int width (const char *text);
void print (int x, int y, char *text);
void printf (int x,int y,char *format,...);
// funkcje innline
void output (BITMAP *bm)
{
out_bmp = bm;
}
void color (int fg, int bg=0)
{
fgcolor = fg;
bgcolor = bg;
}
};
| [
"[email protected]"
]
| [
[
[
1,
35
]
]
]
|
51f812a55787259bf7b433c6be8b37262a6e83b5 | 6613641e04e8ca78862938d6d5ce2b6ec93ee161 | / qlink-up --username [email protected]/PicMosaic/debug/moc_picmosaic.cpp | ab58558b60d239feddef28d2a8788c3b9a10afad | []
| no_license | reyoung/qlink-up | 46a117e91b1097de9ed763aaf48c473532278fb9 | 21df00e453db552378166181f520fe0d6ae24bbc | refs/heads/master | 2021-01-23T03:08:03.232791 | 2010-03-12T01:05:46 | 2010-03-12T01:05:46 | 33,867,970 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,736 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'picmosaic.h'
**
** Created: Thu Jan 21 23:29:36 2010
** by: The Qt Meta Object Compiler version 62 (Qt 4.6.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../picmosaic.h"
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'picmosaic.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 62
#error "This file was generated using the moc from 4.6.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
static const uint qt_meta_data_PicMosaic[] = {
// content:
4, // revision
0, // classname
0, 0, // classinfo
4, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
0, // signalCount
// slots: signature, parameters, type, tag, flags
11, 10, 10, 10, 0x08,
33, 10, 10, 10, 0x08,
54, 52, 10, 10, 0x08,
73, 10, 10, 10, 0x08,
0 // eod
};
static const char qt_meta_stringdata_PicMosaic[] = {
"PicMosaic\0\0on_loadFile_clicked()\0"
"on_reset_clicked()\0a\0handleBlock(Block)\0"
"finishSlot()\0"
};
const QMetaObject PicMosaic::staticMetaObject = {
{ &QWidget::staticMetaObject, qt_meta_stringdata_PicMosaic,
qt_meta_data_PicMosaic, 0 }
};
#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &PicMosaic::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION
const QMetaObject *PicMosaic::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
}
void *PicMosaic::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_PicMosaic))
return static_cast<void*>(const_cast< PicMosaic*>(this));
return QWidget::qt_metacast(_clname);
}
int PicMosaic::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: on_loadFile_clicked(); break;
case 1: on_reset_clicked(); break;
case 2: handleBlock((*reinterpret_cast< Block(*)>(_a[1]))); break;
case 3: finishSlot(); break;
default: ;
}
_id -= 4;
}
return _id;
}
QT_END_MOC_NAMESPACE
| [
"[email protected]@703ea0ba-0006-11df-9748-a16e6a44286a"
]
| [
[
[
1,
87
]
]
]
|
65db5236ee6996978ce64bf9eb57a3d40456fee4 | 1493997bb11718d3c18c6632b6dd010535f742f5 | /direct_ui/App/Views.h | 3b23c44b82fddf3ba67e27ea91ba109710323788 | []
| no_license | kovrov/scrap | cd0cf2c98a62d5af6e4206a2cab7bb8e4560b168 | b0f38d95dd4acd89c832188265dece4d91383bbb | refs/heads/master | 2021-01-20T12:21:34.742007 | 2010-01-12T19:53:23 | 2010-01-12T19:53:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,642 | h | #if !defined(AFX_VIEWS_H__20050510_6D37_02C3_39BC_0080AD509054__INCLUDED_)
#define AFX_VIEWS_H__20050510_6D37_02C3_39BC_0080AD509054__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CStandardPageWnd : public CWindowWnd, public INotifyUI
{
public:
UINT GetClassStyle() const;
void OnFinalMessage(HWND hWnd);
LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
virtual void Init();
virtual void OnPrepareAnimation();
virtual void Notify(TNotifyUI& msg);
virtual LPCTSTR GetDialogResource() const = 0;
public:
CPaintManagerUI m_pm;
};
class CStartPageWnd : public CStandardPageWnd
{
public:
LPCTSTR GetWindowClassName() const;
LPCTSTR GetDialogResource() const;
void OnPrepareAnimation();
void Init();
};
class CConfigurePageWnd : public CStandardPageWnd
{
public:
LPCTSTR GetWindowClassName() const;
LPCTSTR GetDialogResource() const;
void OnPrepareAnimation();
};
class CRegistersPageWnd : public CStandardPageWnd, public IListCallbackUI
{
public:
LPCTSTR GetWindowClassName() const;
LPCTSTR GetDialogResource() const;
void OnPrepareAnimation();
// IListCallbackUI
LPCTSTR GetItemText(CControlUI* pControl, int iIndex, int iSubItem);
int CompareItem(CControlUI* pList, CControlUI* pItem1, CControlUI* pItem2);
};
class CReportsPageWnd : public CStandardPageWnd
{
public:
LPCTSTR GetWindowClassName() const;
LPCTSTR GetDialogResource() const;
void OnPrepareAnimation();
};
class CSystemsPageWnd : public CStandardPageWnd, public IListCallbackUI
{
public:
LPCTSTR GetWindowClassName() const;
LPCTSTR GetDialogResource() const;
void Notify(TNotifyUI& msg);
void OnPrepareAnimation();
void OnExpandItem(CControlUI* pControl);
// IListCallbackUI
LPCTSTR GetItemText(CControlUI* pControl, int iIndex, int iSubItem);
int CompareItem(CControlUI* pList, CControlUI* pItem1, CControlUI* pItem2);
};
class CSearchPageWnd : public CStandardPageWnd
{
public:
LPCTSTR GetWindowClassName() const;
LPCTSTR GetDialogResource() const;
void Notify(TNotifyUI& msg);
void Init();
};
class CEditPageWnd : public CStandardPageWnd
{
public:
LPCTSTR GetWindowClassName() const;
LPCTSTR GetDialogResource() const;
void Notify(TNotifyUI& msg);
void OnPrepareAnimation();
void Init();
};
class CPopupWnd : public CStandardPageWnd
{
public:
UINT GetClassStyle() const;
LPCTSTR GetWindowClassName() const;
LPCTSTR GetDialogResource() const;
void Notify(TNotifyUI& msg);
void Init();
};
#endif // !defined(AFX_VIEWS_H__20050510_6D37_02C3_39BC_0080AD509054__INCLUDED_)
| [
"[email protected]"
]
| [
[
[
1,
105
]
]
]
|
d87c0e33b1b9eda0432b34eeb92b7a98b1634bab | 906e87b1936397339734770be45317f06fe66e6e | /src/TGConsole.cpp | 851dd5cf1f7509d5e159c9c5764732bbf9a3043e | []
| no_license | kcmohanprasad/tgui | 03c1ab47e9058bc763b7e6ffc21a37b4358369bf | 9f9cf391fa86b99c7d606c4d196e512a7b06be95 | refs/heads/master | 2021-01-10T08:52:18.629088 | 2007-05-17T04:42:58 | 2007-05-17T04:42:58 | 52,069,498 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,278 | cpp | //-----------------------------------------------------------------------------
// This source file is part of TGUI (Tiny GUI)
//
// Copyright (c) 2006-2007 Tubras Software, Ltd
// Also see acknowledgements in Readme.html
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
// of the Software, and to permit persons to whom the Software is furnished to
// do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//-----------------------------------------------------------------------------
#include <tgui.h>
namespace TGUI
{
//-----------------------------------------------------------------------
// T G C o n s o l e
//-----------------------------------------------------------------------
TGConsole::TGConsole(TGString caption) : TGWindow(NULL,"",caption)
{
m_list = new TGListBox(this,"commandHistory");
m_list->setPos(5,5);
m_list->resize(485,205);
m_input = new TGEditBox(this,"commandLine");
m_input->setPos(5,220);
m_input->resize(485,25);
m_input->addEventHandler(TGEvent::AcceptText,new TGEventHandler(&TGConsole::acceptText,this));
m_input->addEventHandler(TGEvent::EscapeText,new TGEventHandler(&TGConsole::escapeText,this));
resize(500, 275);
center();
m_input->focus();
}
//-----------------------------------------------------------------------
// ~ T G C o n s o l e
//-----------------------------------------------------------------------
TGConsole::~TGConsole()
{
}
//-----------------------------------------------------------------------
// e s c a p e T e x t
//-----------------------------------------------------------------------
bool TGConsole::escapeText(const TGEventArgs& args)
{
toggle();
return true;
}
//-----------------------------------------------------------------------
// a c c e p t T e x t
//-----------------------------------------------------------------------
bool TGConsole::acceptText(const TGEventArgs& args)
{
TGString command;
command = m_input->getText();
if(command.empty())
return true;
TGConsoleEventArgs ea(this);
ea.m_command = command;
addItem(m_input->getText());
fireEvent(TGEvent::ConsoleCommand,ea);
m_input->setText("");
m_list->setVScrollPos(m_list->getVScrollMax());
return true;
}
//-----------------------------------------------------------------------
// s e t B o u n d s
//-----------------------------------------------------------------------
void TGConsole::setBounds(int x1, int y1, int x2, int y2)
{
int ox1,oy1,ox2,oy2;
getBounds(ox1,oy1,ox2,oy2);
TGControl::setBounds(x1,y1,x2,y2);
if( ((ox2-ox1) == (x2-x1)) &&
((oy2-oy1) == (y2-y1)) )
return;
}
//-----------------------------------------------------------------------
// a d d I t e m
//-----------------------------------------------------------------------
void TGConsole::addItem(TGString item)
{
m_list->addItem(item);
}
//-----------------------------------------------------------------------
// t o g g l e
//-----------------------------------------------------------------------
void TGConsole::toggle()
{
if(isVisible())
{
makeExclusive(false);
hide();
setKeyboardFocusControl(NULL);
}
else
{
TGScreen* activeScreen = TGSystem::getSingleton().getActiveScreen();
if(activeScreen)
{
if(activeScreen != m_parent)
reParent(activeScreen);
activeScreen->setFocusedChild(this);
makeExclusive();
setKeyboardFocusControl(m_input);
m_input->focus();
show();
}
}
fireEvent(TGEvent::ConsoleToggled,TGEventArgs(this));
}
} | [
"pc0der@a5263bde-0223-0410-8bbb-1954fdd97a2f"
]
| [
[
[
1,
144
]
]
]
|
5565bb2e92172afc51322e711c3e6dd7f2c6c95a | 6b3e852f273f0255875815d1a90f35b93891e7f9 | /src/boxAlign.cpp | cd26828fe63fddbd8eeaf0f66c5ca962ed458ce8 | []
| no_license | serman/cityfireflies | aaa3165a50b9ceae04a791c73a2a0e6e2174dfe9 | 5d17e1d1e0f9aefdc36b9b5e20190d06447bd0d6 | refs/heads/master | 2021-01-18T04:05:46.000584 | 2011-10-01T15:24:10 | 2011-10-01T15:24:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,246 | cpp | #include "boxAlign.h"
CBoxAligner::CBoxAligner()
{
}
//--------------------------------------------------------------
CBoxAligner::~CBoxAligner()
{
}
//--------------------------------------------------------------
void CBoxAligner::setup()
{
for(int i = 0; i < 4; i++)
{
fHandles[i].x = 0.0f;
fHandles[i].y = 0.0f;
}
fDrawOffset.x = 0.0f;
fDrawOffset.y = 0.0f;
}
//--------------------------------------------------------------
void CBoxAligner::setup( int x, int y, float w, float h)
{
// sets up the handles to be a box from 0,0 to the width and height of the image
fHandles[0].x = 0.0f;
fHandles[0].y = h;
fHandles[1].x = w;
fHandles[1].y = h;
fHandles[2].x = w;
fHandles[2].y = 0.0f;
fHandles[3].x = 0.0f;
fHandles[3].y = 0.0f;
// this indicates the offset from 0,0 that the image is draw to the screen
fDrawOffset.x = x;
fDrawOffset.y = y;
imageWidth = w;
imageHeight = h;
}
//--------------------------------------------------------------
float CBoxAligner::adjustHandle(float mouseX, float mouseY)
{
// find out which handle is closest to mouse and adjust that one
int iHandle = findClosestHandle( mouseX, mouseY);
if(iHandle==-1)
return false;
// account for the offset in mouse position based on where the handles are drawn
fHandles[iHandle].x = mouseX - fDrawOffset.x;
fHandles[iHandle].y = mouseY - fDrawOffset.y;
fHandles[iHandle].x = ofMap(fHandles[iHandle].x, 0, 320, 0, imageWidth);
fHandles[iHandle].y = ofMap(fHandles[iHandle].y, 0, 240, 0, imageHeight);
return true;
}
//--------------------------------------------------------------
float CBoxAligner::findSelectionDistance(float mouseX, float mouseY)
{
// subtract the draw position so that mouse input makes sense
mouseX -= fDrawOffset.x;
mouseY -= fDrawOffset.y;
mouseX = ofMap(mouseX, 0, 320, 0, imageWidth);
mouseY = ofMap(mouseY, 0, 240, 0, imageHeight);
float closeDist = sqrt( (fHandles[0].x-mouseX)*(fHandles[0].x-mouseX) + (fHandles[0].y-mouseY)*(fHandles[0].y-mouseY) );
for( int i = 1; i < 4; i++)
{
float d = sqrt( (fHandles[i].x-mouseX)*(fHandles[i].x-mouseX) + (fHandles[i].y-mouseY)*(fHandles[i].y-mouseY) );
if( d < closeDist )
{
closeDist = d;
}
}
return closeDist;
}
//--------------------------------------------------------------
int CBoxAligner::findClosestHandle(float mouseX, float mouseY)
{
// subtract the draw position so that mouse input makes sense
mouseX -= fDrawOffset.x;
mouseY -= fDrawOffset.y;
mouseX = ofMap(mouseX, 0, 320, 0, imageWidth);
mouseY = ofMap(mouseY, 0, 240, 0, imageHeight);
// start with the first handle
int iCloseId = -1;
float fCloseDist = sqrt( (fHandles[0].x-mouseX)*(fHandles[0].x-mouseX) + (fHandles[0].y-mouseY)*(fHandles[0].y-mouseY) );
// loop to see which is closest
for( int i = 0; i < 4; i++)
{
float fDist = sqrt( (fHandles[i].x-mouseX)*(fHandles[i].x-mouseX) + (fHandles[i].y-mouseY)*(fHandles[i].y-mouseY) );
if( fDist <= fCloseDist && fDist < 90 )
{
fCloseDist = fDist;
iCloseId = i;
}
}
// return id of closest
return iCloseId;
}
//--------------------------------------------------------------
void CBoxAligner::draw( int x, int y, float radius )
{
glPushMatrix();
glTranslatef(fDrawOffset.x,fDrawOffset.y,0.0f);
ofSetColor(0x89ff41);
ofScale(1, 1, 1);
// draw box
glBegin( GL_LINE_STRIP );
glVertex2f(fHandles[0].x, fHandles[0].y);
glVertex2f(fHandles[1].x, fHandles[1].y);
glVertex2f(fHandles[2].x, fHandles[2].y);
glVertex2f(fHandles[3].x, fHandles[3].y);
glVertex2f(fHandles[0].x, fHandles[0].y);
glEnd();
// draw handles
for( int i = 0; i < 4; i++)
{
ofRect( fHandles[i].x - radius / 2, fHandles[i].y - radius / 2, radius, radius);
}
glPopMatrix();
}
| [
"[email protected]"
]
| [
[
[
1,
149
]
]
]
|
1199715f5be242d79ffe5823632ca4a5f9df261a | 38664d844d9fad34e88160f6ebf86c043db9f1c5 | /branches/initialize/skin/examples/mfc/mfc42_sr/mfc42_sr.cpp | 5b4e2c0e0a56c41f2281a020c317250fd53c128b | []
| no_license | cnsuhao/jezzitest | 84074b938b3e06ae820842dac62dae116d5fdaba | 9b5f6cf40750511350e5456349ead8346cabb56e | refs/heads/master | 2021-05-28T23:08:59.663581 | 2010-11-25T13:44:57 | 2010-11-25T13:44:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,245 | cpp | // mfc42_sr.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "mfc42_sr.h"
#include "MainFrm.h"
#include "mfc42_srDoc.h"
#include "mfc42_srView.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CMfc42_srApp
BEGIN_MESSAGE_MAP(CMfc42_srApp, CWinApp)
//{{AFX_MSG_MAP(CMfc42_srApp)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG_MAP
// Standard file based document commands
ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
// Standard print setup command
ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMfc42_srApp construction
CMfc42_srApp::CMfc42_srApp()
{
// TODO: add construction code here,
// Place all significant initialization in InitInstance
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CMfc42_srApp object
CMfc42_srApp theApp;
/////////////////////////////////////////////////////////////////////////////
// CMfc42_srApp initialization
BOOL CMfc42_srApp::InitInstance()
{
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
// Change the registry key under which our settings are stored.
// TODO: You should modify this string to be something appropriate
// such as the name of your company or organization.
SetRegistryKey(_T("Local AppWizard-Generated Applications"));
LoadStdProfileSettings(); // Load standard INI file options (including MRU)
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CMfc42_srDoc),
RUNTIME_CLASS(CMainFrame), // main SDI frame window
RUNTIME_CLASS(CMfc42_srView));
AddDocTemplate(pDocTemplate);
// Parse command line for standard shell commands, DDE, file open
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
// Dispatch commands specified on the command line
if (!ProcessShellCommand(cmdInfo))
return FALSE;
// The one and only window has been initialized, so show and update it.
m_pMainWnd->ShowWindow(SW_SHOW);
m_pMainWnd->UpdateWindow();
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
// No message handlers
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
// App command to run the dialog
void CMfc42_srApp::OnAppAbout()
{
CAboutDlg aboutDlg;
aboutDlg.DoModal();
}
/////////////////////////////////////////////////////////////////////////////
// CMfc42_srApp message handlers
| [
"ken.shao@ba8f1dc9-3c1c-0410-9eed-0f8a660c14bd"
]
| [
[
[
1,
154
]
]
]
|
20f1489f9a83f421bed1af7074d20653a512fc8d | 9b3403551e250529d7e6f04500d99f7c61669503 | /WifiLoc/WifiLocView.h | 4a691f7dcc14c7dc1634fdfcf1c678564fe717d9 | []
| no_license | ashrafs/allhandstothepump | 847f1cfe60927c76ba7a8c09092deb23327d42df | 42abaf3e0478e0cca7374ee57a914895eddebc3f | refs/heads/master | 2021-01-10T14:02:42.001763 | 2009-05-20T02:37:28 | 2009-05-20T02:37:28 | 44,780,671 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,479 | h | // WifiLocView.h : interface of the CWifiLocView class
//
#pragma once
#define PATH_INIT 0
#define PATH_DOING 1
#define PATH_END 2
class CWifiLocView : public CView
{
protected: // create from serialization only
CWifiLocView();
DECLARE_DYNCREATE(CWifiLocView)
// Attributes
public:
CWifiLocDoc* GetDocument() const;
int m_nPathStep;
int m_bInitDC;
int m_bBgDC;
CDC m_memDC,m_BgDC;
CBitmap m_Bitmap , *m_pOldBitmap ,m_BgBitmap;
HBITMAP m_hBitmap;
LPVOID m_pBitmap;
// Operations
public:
// Overrides
public:
virtual void OnDraw(CDC* pDC); // overridden to draw this view
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
protected:
virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);
virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);
virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);
// Implementation
public:
virtual ~CWifiLocView();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
protected:
DECLARE_MESSAGE_MAP()
public:
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
public:
afx_msg void OnTimer(UINT_PTR nIDEvent);
public:
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
public:
afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
public:
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
public:
afx_msg void OnDestroy();
public:
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
public:
afx_msg void OnSize(UINT nType, int cx, int cy);
public:
afx_msg void OnMButtonUp(UINT nFlags, CPoint point);
public:
// afx_msg BOOL OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct);
public:
afx_msg BOOL OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct);
public:
afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
public:
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
public:
void UpdateCursorRSSI();
public:
afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
public:
void CompareRSSI(RSSIINFO *r1 , RSSIINFO *r2);
public:
afx_msg void OnRButtonDblClk(UINT nFlags, CPoint point);
public:
void DrawArrow(CDC* pDC, int nWidth, COLORREF nColorIn, COLORREF nColorOut, int X1, int Y1, int X2, int Y2);
};
#ifndef _DEBUG // debug version in WifiLocView.cpp
inline CWifiLocDoc* CWifiLocView::GetDocument() const
{ return reinterpret_cast<CWifiLocDoc*>(m_pDocument); }
#endif
| [
"steampack99@fbba777c-2a28-11de-b896-015b45f1b0e6"
]
| [
[
[
1,
95
]
]
]
|
18271223085051c8702d34ff7b0c16622a2eb42f | e23043ccdd94075885800a4143630af7f2f01d4d | /lookupwin.cpp | 0cb2dd90d082ce4269f2d5c48b90b54085e6c979 | []
| no_license | daniel-kun/jisho | 4f47e0492d080d0da34e7a14cf350384ea1de56f | b230a3e7c7f93f348bf4a9f9d8bbc73ad618cac2 | refs/heads/master | 2016-09-05T20:41:20.410020 | 2010-04-24T18:58:50 | 2010-04-24T18:58:50 | 627,086 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,132 | cpp | #include "lookupwin.h"
#include <QPaintEvent>
#include <QPainter>
#include <QFile>
#include "lookup.h"
JishoLookupWin::JishoLookupWin():
m_glMain(this)
{
int row = 0;
m_glMain.addWidget(&m_edLookup, row, 0, 1, 5);
m_glMain.addWidget(&m_btnGo, row++, 5);
/* m_glMain.addWidget(&m_btnAutomatic, row, 0);
m_glMain.addWidget(&m_btnEnglish, row, 1);
m_glMain.addWidget(&m_btnRomaji, row, 2);
m_glMain.addWidget(&m_btnJapanese, row++, 3);*/
m_glMain.addWidget(&m_htmlResults, row, 0, 1, 6);
m_glMain.setColumnStretch(4, 1);
m_glMain.setRowStretch(row++, 1);
m_btnGo.setIcon(QPixmap(":/resources/icon-go.png"));
m_btnAutomatic.setIcon(QPixmap(":/resources/icon-automatic.png"));
m_btnEnglish.setIcon(QPixmap(":/resources/icon-abc.png"));
m_btnRomaji.setIcon(QPixmap(":/resources/icon-romaji.png"));
m_btnJapanese.setIcon(QPixmap(":/resources/icon-kanji.png"));
m_btnGo.setAutoRaise(true);
m_htmlResults.setFrameShape(QFrame::Box);
m_htmlResults.setAutoFillBackground(true);
m_htmlResults.setReadOnly(true);
m_htmlResults.setHtml(defaultText());
retranslateUi();
connect(&m_edLookup, SIGNAL(returnPressed()), SLOT(executeLookup()));
connect(&m_btnGo, SIGNAL(clicked()), SLOT(executeLookup()));
}
void JishoLookupWin::setJishoStyle(const JishoStyle &style)
{
m_htmlResults.setStyleSheet(QString("background-color: %1;").arg(style.fillHighlight.name()));
m_btnAutomatic.setJishoStyle(style);
m_btnEnglish.setJishoStyle(style);
m_btnRomaji.setJishoStyle(style);
m_btnJapanese.setJishoStyle(style);
}
void JishoLookupWin::retranslateUi()
{
m_btnAutomatic.setText(tr("&Auto"));
m_btnEnglish.setText(tr("&English"));
m_btnRomaji.setText(tr("&Romaji"));
m_btnJapanese.setText(tr("&Japanese"));
}
void JishoLookupWin::focusLookupEdit()
{
m_edLookup.setFocus(Qt::ShortcutFocusReason);
}
QString JishoLookupWin::defaultText() const
{
QFile f(":/resources/default-text.html");
f.open(QFile::ReadOnly);
QByteArray defaultText(f.readAll());
return QString::fromUtf8(defaultText.constData(), defaultText.size());
}
void JishoLookupWin::executeLookup()
{
QString text = m_edLookup.text().trimmed();
QString html;
if (text.isEmpty())
{
html = defaultText();
}
else
{
QVector<JishoLookupResult> result = jishoLookup(m_edLookup.text(), jishoGuessLookupMode(m_edLookup.text()));
if (!result.isEmpty())
{
foreach (JishoLookupResult entry, result)
{
html += "<h1>" + entry.kanji + "</h1>";
html += "<ol>";
foreach (QString meaning, entry.meanings)
{
html += "<li>" + meaning + "</li>";
}
html += "</ol>\n";
}
}
else
{
QFile f(":/resources/no-result.html");
f.open(QFile::ReadOnly);
QByteArray ba = f.readAll();
html = QString::fromUtf8(ba.constData(), ba.size());
}
}
m_htmlResults.setHtml(html);
}
| [
"[email protected]"
]
| [
[
[
1,
106
]
]
]
|
03f06f5f00da604396b4c58800f1c5c305a4afd6 | 335783c9e5837a1b626073d1288b492f9f6b057f | /source/fbxcmd/daocmd/Commands/DumpSkeleton.cpp | d381fb9ebcb46a62ef41359582d59270b815bab5 | [
"BSD-3-Clause",
"LicenseRef-scancode-warranty-disclaimer",
"BSD-2-Clause"
]
| permissive | code-google-com/fbx4eclipse | 110766ee9760029d5017536847e9f3dc09e6ebd2 | cc494db4261d7d636f8c4d0313db3953b781e295 | refs/heads/master | 2016-09-08T01:55:57.195874 | 2009-12-03T20:35:48 | 2009-12-03T20:35:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,762 | cpp | #include "stdafx.h"
#include "program.h"
#include <sys/stat.h>
#include <io.h>
#include <shellapi.h>
using namespace std;
#include "GFFFormat.h"
#include "MMHFormat.h"
using namespace DAO;
using namespace DAO::GFF;
using namespace DAO::MMH;
//////////////////////////////////////////////////////////////////////////
void ImportBones( DAODumpStream& log, Matrix44 pm, NODERef node)
{
int indent = log.IncreaseIndent();
try
{
Text name = !node.isNull() ? node->get_name() : Text();
GFFListRef childList = node->get_children();
Vector4f trans = node->GetLocalTranslation();
Quaternion quat = node->GetLocalRotation();
float scale = node->GetLocalScale();
Matrix44 tm(trans, quat, scale);
float len = trans.Length();
Matrix44 im = pm * tm;
//[-0.161288,0.000001,0.986907]
//[-0.000001,-1.000000,0.000001]
//[0.986907,-0.000001,0.161288]
//[-0.002451,0.000000,0.371050]
Matrix44& dm = im;
Text txtPos, txtRot, txtYpr, txtScale, txtFormat, txtMatrix;
txtPos.Format("(%7.4f, %7.4f, %7.4f)", trans[0], trans[1], trans[2]);
txtRot.Format("(%7.4f, %7.4f, %7.4f, %7.4f)", quat.w, quat.x, quat.y, quat.z);
txtFormat.Format("%%-%ds | %%-24s | %%-32s\n", max(60 - indent*2, 1) );
//log.Indent();
//log.PrintF(txtFormat, name.c_str(), txtPos.c_str(), txtRot.c_str());
Text txtPos0, txtPos1, txtPos2, txtPos3;
Vector4f r0 = dm.GetRow(0);
Vector4f r1 = dm.GetRow(1);
Vector4f r2 = dm.GetRow(2);
Vector4f r3 = dm.GetRow(3);
txtPos0.Format("[%7.4f,%7.4f,%7.4f]", r0.x, r0.y, r0.z);
txtPos1.Format("[%7.4f,%7.4f,%7.4f]", r1.x, r1.y, r1.z);
txtPos2.Format("[%7.4f,%7.4f,%7.4f]", r2.x, r2.y, r2.z);
txtPos3.Format("[%7.4f,%7.4f,%7.4f]", r3.x, r3.y, r3.z);
txtFormat.Format("%%-%ds | %%s %%s %%s %%s\n", max(60 - indent*2, 1) );
log.Indent();
log.PrintF(txtFormat, name.c_str(), txtPos0.c_str(), txtPos1.c_str(), txtPos2.c_str(), txtPos3.c_str());
DAOArray< NODEPtr > children;
if ( DynamicCast(childList, children) ) {
for (size_t i=0, n=children.size(); i<n; ++i)
ImportBones(log, im, NODERef(children[i]));
}
}
catch( std::exception & )
{
}
catch( ... )
{
}
log.DecreaseIndent();
}
void ImportSkeleton(MDLHRef root)
{
DAODumpStream out(NULL, false);
GFFListRef list = root->get_children();
DAOArray< NODEPtr > bones;
if ( DynamicCast(list, bones) )
{
//Matrix44 wtm(true);
Matrix44 wtm(
Vector4f( 0.000000,1.000000,0.000000,0.00000),
Vector4f(-1.000000,0.000000,0.000000,0.00000),
Vector4f( 0.000000,0.000000,1.000000,0.00000),
Vector4f( 0.000000,0.000000,0.000000,1.00000));
for (size_t i=0, n=bones.size(); i<n; ++i)
{
ImportBones(out, wtm, bones[i]);
}
}
}
//////////////////////////////////////////////////////////////////////////
static void HelpString(Cmd::HelpType type){
switch (type)
{
case Cmd::htShort: cout << "DumpSkeleton - Dump MMH Skeleton information to console"; break;
case Cmd::htLong:
{
TCHAR fullName[MAX_PATH], exeName[MAX_PATH];
GetModuleFileName(NULL, fullName, MAX_PATH);
_tsplitpath(fullName, NULL, NULL, exeName, NULL);
cout << "Usage: " << exeName << " erf [-opts[modifiers]] <erf file>" << endl
<< " Simple skeleton dump help for DA:O MMH files." << endl
<< endl
<< " If input argument is a file then the program unpack the erf file." << endl
<< " If input argument is a path then the program packs an erf file from that path." << endl
<< endl
<< "<Switches>" << endl
<< " v Verbose Help (Lists specific versions)" << endl
<< endl
;
}
break;
}
}
static bool ExecuteCmd(Program &prog)
{
TCHAR infile[MAX_PATH], fullpath[MAX_PATH];
int argc = prog.argc;
TCHAR **argv = prog.argv;
bool verboseHelp = false;
TCHAR path[MAX_PATH];
if (argc == 0)
return false;
infile[0] = 0;
path[0] = 0;
for (int i = 0; i < argc; i++)
{
TCHAR *arg = argv[i];
if (arg == NULL)
continue;
if (arg[0] == '-' || arg[0] == '/')
{
switch (arg[1])
{
case 'v':
verboseHelp = true;
break;
default:
_fputts( _T("ERROR: Unknown argument specified \""), stderr );
_fputts( arg, stderr );
_fputts( _T("\".\n"), stderr );
return false;
}
}
else if (infile[0] == 0)
{
_tcscpy(infile, arg);
}
}
if (infile[0] == 0)
{
_ftprintf( stderr, _T("File not specified.\n") );
return false;
}
TCHAR drive[MAX_PATH], dir[MAX_PATH], fname[MAX_PATH], ext[MAX_PATH];
GetFullPathName(infile, _countof(fullpath), fullpath, NULL);
_tsplitpath(fullpath, drive, dir, fname, ext);
if (path[0] == 0) {
_tmakepath(path, drive, dir, fname, NULL);
}
struct _stat64 fstats;
if ( -1 == _tstat64(fullpath, &fstats) ){
_ftprintf( stderr, _T("Path is not a valid file or directory.\n") );
return false;
}
if ( (fstats.st_mode & _S_IFDIR) != _S_IFDIR ) // file not directory
{
MMHFile file;
file.open(fullpath);
MDLHPtr root = file.get_Root();
ImportSkeleton( MDLHRef(root) );
//DAODumpStream out(NULL, false);
//const DAO::GFF::GFFInfo& info = gfffile.get_FileInfo();
//for (int i=0; i<info.Structs.size(); ++i) {
// DAO::GFF::GFFStructDef &sval = *info.Structs[i];
// Text fmt = "| %-64s| %-11s | %-18s | %-5s |\n";
// out.PrintF("%s\n", sval.StructType.data());
// out.PrintF("--------------------------------------------------------------------------------------------------------------\n");
// out.PrintF(fmt, "Label", "TypeID", "Flags", "Index");
// out.PrintF("--------------------------------------------------------------------------------------------------------------\n");
// for (int i=0; i<sval.Fields.count(); ++i)
// {
// DAO::GFF::GFFFieldDefRef field ( sval.Fields[i] );
// Text label, typeID, flags, index;
// label = EnumToText(field->Label);
// typeID = EnumToText(field->TypeID);
// flags = EnumToText(field->Flags);
// index.Format("%d", field->Index);
// out.PrintF(fmt.c_str(), label.c_str(), typeID.c_str(), flags.c_str(), index.c_str());
// }
// out.PrintF("--------------------------------------------------------------------------------------------------------------\n");
// out.Print("\n\n");
//}
//gfffile.dump();
//DAOStream in(fullpath, true);
//DAO::GFFInfo info;
//if (!Recall(in, info)) {
// throw runtime_error(FormatStringA("Invalid File Header for file: %s", fullpath));
//}
//DAODumpStream out(NULL, false);
//Dump(out, PathFindFileName(fullpath), info);
}
return false;
}
REGISTER_COMMAND(DumpSkeleton, HelpString, ExecuteCmd);
| [
"tazpn314@ccf8930c-dfc1-11de-9043-17b7bd24f792"
]
| [
[
[
1,
236
]
]
]
|
bbcb7d35e3e6009aeae527c8e5695f850281636b | 2f72d621e6ec03b9ea243a96e8dd947a952da087 | /lol4edit/gui/DataHoldingListWidgetItem.h | 083dedca2d350daaaa9283dc141ead27d58cb7b7 | []
| no_license | gspu/lol4fg | 752358c3c3431026ed025e8cb8777e4807eed7a0 | 12a08f3ef1126ce679ea05293fe35525065ab253 | refs/heads/master | 2023-04-30T05:32:03.826238 | 2011-07-23T23:35:14 | 2011-07-23T23:35:14 | 364,193,504 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 830 | h | #ifndef __DataHoldingListWidgetItem
#define __DataHoldingListWidgetItem
#include <QDialog>
#include <QListWidget>
class DataHoldingListWidgetItem: public QListWidgetItem
{
public:
DataHoldingListWidgetItem ( QListWidget * parent = 0, int type = Type ):
QListWidgetItem(parent,type)
{
customData = NULL;
customType = 0;
}
DataHoldingListWidgetItem ( const QString & text, QListWidget * parent = 0, int type = Type ):
QListWidgetItem(text,parent,type)
{
customData = NULL;
customType = 0;
}
void setCustomData(void *data)
{
customData = data;
}
void setCustomType(int type)
{
customType = type;
}
void *getCustomData()
{
return customData;
}
int getCustomType()
{
return customType;
}
private:
void *customData;
int customType;
};
#endif | [
"praecipitator@bd7a9385-7eed-4fd6-88b1-0096df50a1ac"
]
| [
[
[
1,
48
]
]
]
|
ec8366ea77ce58af37722ff252078ee1fe917def | 9773c3304eecc308671bcfa16b5390c81ef3b23a | /MDI AIPI V.6.92 2003 ( Correct Save Fired Rules, AM =-1, g_currentLine)/AIPI/ScriptObject/ScriptObject.cpp | a9ddb44cd8093c8fb28e1b7d463562857cf599f0 | []
| no_license | 15831944/AiPI-1 | 2d09d6e6bd3fa104d0175cf562bb7826e1ac5ec4 | 9350aea6ac4c7870b43d0a9f992a1908a3c1c4a8 | refs/heads/master | 2021-12-02T20:34:03.136125 | 2011-10-27T00:07:54 | 2011-10-27T00:07:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,207 | cpp | ///////////////////////////////////////////////////////////////////////////////
// File: ScriptObject.cpp
// Version: 1.0
//
// Author: Ernest Laurentin
// E-mail: [email protected]
//
// This class implements MSScript control
// It can interface script from resource file or text file
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is
// not sold for profit without the authors written consent, and
// providing that this notice and the authors name and all copyright
// notices remains intact.
//
// An email letting me know how you are using it would be nice as well.
//
// This file is provided "as is" with no expressed or implied warranty.
// The author accepts no liability for any damage/loss of business that
// this c++ class may cause.
//
// Version history
//
// 1.0 - Initial release.
// 1.1 - Bug fixes for VC7 and Unicode
///////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <comutil.h>
#include "ScriptObject.h"
///////////////////////////////////////////////////////////////////////////////
// Construction
CScriptObject::CScriptObject()
{
CommonConstruct(); // will throw exception if failed
}
CScriptObject::~CScriptObject()
{
// Destroy object- and release
m_pScript = NULL;
}
///////////////////////////////////////////////////////////////////////////////
// Members
///////////////////////////////////////////////////////////////////////////////
// CommonConstruct
void CScriptObject::CommonConstruct()
{
HRESULT hr = m_pScript.CreateInstance(__uuidof(ScriptControl));
_com_util::CheckError( hr ); // will throw an exception if failed
// will not come here if exception
_tcscpy(m_szLanguage, LANGUAGE_DEFAULT);
m_pScript->PutAllowUI( VARIANT_TRUE );
m_pScript->PutLanguage( _bstr_t(m_szLanguage ) );
}
///////////////////////////////////////////////////////////////////////////////
// GetLanguage : Get current script language
LPCTSTR CScriptObject::GetLanguage()
{
return m_szLanguage;
}
///////////////////////////////////////////////////////////////////////////////
// SetLanguage : Set current script language
void CScriptObject::SetLanguage(LPCTSTR szLanguage)
{
_tcscpy(m_szLanguage, szLanguage);
if (m_pScript != NULL)
{
m_pScript->PutLanguage( _bstr_t( szLanguage ) );
m_pScript->Reset();
m_FunctionList.clear();
}
}
///////////////////////////////////////////////////////////////////////////////
// GetMethodsCount
int CScriptObject::GetMethodsCount() const
{
return m_FunctionList.size();
}
///////////////////////////////////////////////////////////////////////////////
// GetNameAt : Get method name at specified index
LPCTSTR CScriptObject::GetNameAt(unsigned int index)
{
if( index >= 0 && index < m_FunctionList.size())
{
stl_string_list::iterator iter = m_FunctionList.begin();
while( index > 0)
{
iter++;
index--;
}
return (*iter).c_str();
}
return TEXT("");
}
///////////////////////////////////////////////////////////////////////////////
// Reset : Reset script control object
void CScriptObject::Reset()
{
if (m_pScript != NULL)
{
m_pScript->Reset();
// empty list...
m_FunctionList.clear();
}
}
///////////////////////////////////////////////////////////////////////////////
// GetErrorString : Get Script error string
LPCTSTR CScriptObject::GetErrorString()
{
m_szError[0] = 0;
if (m_pScript != NULL)
{
try{
IScriptErrorPtr pError = m_pScript->GetError();
if (pError != NULL)
{
_bstr_t str = _bstr_t("ScriptError: ") + pError->GetDescription() + _bstr_t(".");
str += pError->GetText() + _bstr_t(", in line ");
str += _bstr_t(pError->GetLine());
int count = __min(str.length(), ERROR_DESC_LEN); // string may be truncated...
_tcsncpy(m_szError, (LPCTSTR) str, count);
m_szError[count] = 0;
pError->Clear();
}
}
catch(_com_error& e)
{
TRACE( (LPTSTR)e.Description() );
TRACE( (LPTSTR)"\n" );
}
}
return m_szError;
}
// GetErrorLineNumber : Get Script error line number
LPCTSTR CScriptObject::GetErrorLineNumber()
{
m_szErrorLineNumber[0] = 0;
if (m_pScript != NULL)
{
try{
IScriptErrorPtr pError = m_pScript->GetError();
if (pError != NULL)
{
_bstr_t line = _bstr_t(pError->GetLine());
int count = __min(line.length(), ERROR_NUM_LEN); // string may be truncated...
_tcsncpy(m_szErrorLineNumber, (LPCTSTR) line, count);
m_szErrorLineNumber[count] = 0;
//pError->Clear();
}
}
catch(_com_error& e)
{
TRACE( (LPTSTR)e.Description() );
TRACE( (LPTSTR)"\n" );
}
}
return m_szErrorLineNumber;
}
// GetErrorColumnNumber : Get Script error line number
LPCTSTR CScriptObject::GetErrorColumn()
{
m_szErrorColNumber[0] = 0;
if (m_pScript != NULL)
{
try{
IScriptErrorPtr pError = m_pScript->GetError();
if (pError != NULL)
{
_bstr_t col = _bstr_t(pError->GetColumn());
int count = __min(col.length(), ERROR_COL_LEN); // string may be truncated...
_tcsncpy(m_szErrorColNumber, (LPCTSTR) col, count);
m_szErrorColNumber[count] = 0;
//pError->Clear();
}
}
catch(_com_error& e)
{
TRACE( (LPTSTR)e.Description() );
TRACE( (LPTSTR)"\n" );
}
}
return m_szErrorColNumber;
}
// GetErrorHelpFile : Get Script error help file
LPCTSTR CScriptObject::GetErrorHelpFile()
{
m_szErrorHelpFile[0] = 0;
if (m_pScript != NULL)
{
try{
IScriptErrorPtr pError = m_pScript->GetError();
if (pError != NULL)
{
_bstr_t helpfile = _bstr_t(pError->GetHelpFile());
int count = __min(helpfile.length(), ERROR_HELPFILE_LEN); // string may be truncated...
_tcsncpy(m_szErrorHelpFile, (LPCTSTR) helpfile, count);
m_szErrorHelpFile[count] = 0;
//pError->Clear();
}
}
catch(_com_error& e)
{
TRACE( (LPTSTR)e.Description() );
TRACE( (LPTSTR)"\n" );
}
}
return m_szErrorHelpFile;
}
// GetErrorNumber : Get Script error number
LPCTSTR CScriptObject::GetErrorNumber()
{
m_szErrorNumber[0] = 0;
if (m_pScript != NULL)
{
try{
IScriptErrorPtr pError = m_pScript->GetError();
if (pError != NULL)
{
_bstr_t num = _bstr_t(pError->GetNumber());
int count = __min(num.length(), ERROR_NUM_LEN); // string may be truncated...
_tcsncpy(m_szErrorNumber, (LPCTSTR) num, count);
m_szErrorNumber[count] = 0;
//pError->Clear();
}
}
catch(_com_error& e)
{
TRACE( (LPTSTR)e.Description() );
TRACE( (LPTSTR)"\n" );
}
}
return m_szErrorNumber;
}
// GetErrorDescription : Get Script error description
LPCTSTR CScriptObject::GetErrorDescription()
{
m_szErrorDescription[0] = 0;
if (m_pScript != NULL)
{
try{
IScriptErrorPtr pError = m_pScript->GetError();
if (pError != NULL)
{
_bstr_t desc = _bstr_t("ScriptError: ") + pError->GetDescription() + _bstr_t(".");
int count = __min(desc.length(), ERROR_DESC_LEN); // string may be truncated...
_tcsncpy(m_szErrorDescription, (LPCTSTR) desc, count);
m_szErrorDescription[count] = 0;
//pError->Clear();
}
}
catch(_com_error& e)
{
TRACE( (LPTSTR)e.Description() );
TRACE( (LPTSTR)"\n" );
}
}
return m_szErrorDescription;
}
// GetErrorDescription : Get Script error description
void CScriptObject::ClearError()
{
if (m_pScript != NULL)
{
try{
IScriptErrorPtr pError = m_pScript->GetError();
if (pError != NULL)
{
pError->Clear();
}
}
catch(_com_error& e)
{
TRACE( (LPTSTR)e.Description() );
TRACE( (LPTSTR)"\n" );
}
}
}
///////////////////////////////////////////////////////////////////////////////
// GetMethodsName: Get methods name list
bool CScriptObject::GetMethodsName()
{
bool bResult = false;
if (m_pScript != NULL)
{
IScriptProcedureCollectionPtr pIProcedures = m_pScript->GetProcedures();
// empty list...
m_FunctionList.clear();
try{
long count = pIProcedures->GetCount();
for(long index=1; index <= count; index++)
{
IScriptProcedurePtr pIProcPtr = pIProcedures->GetItem( _variant_t(index) );
_bstr_t name = pIProcPtr->GetName();
m_FunctionList.insert(m_FunctionList.end(), (LPCTSTR) name );
pIProcPtr = NULL;
}
bResult = true;
}
catch(...)
{
// Just catch the exception, call GetErrorString()
// to retreive last error
}
pIProcedures = NULL;
}
return bResult;
}
///////////////////////////////////////////////////////////////////////////////
// GetScriptFunction
// Get Script function name, this is useful for script with case sensitive
// function name.
LPCTSTR CScriptObject::GetScriptFunction(LPCTSTR szName)
{
stl_string_list::iterator iter = m_FunctionList.begin();
while( iter != m_FunctionList.end() )
{
if ((*iter).compare(szName) == 0)
return (*iter).c_str();
iter++;
}
return TEXT("");
}
//////////////////////////////////////////////////////////////////////////
// LoadScriptResource:
// Load a Script resource. This function loads and insert all functions
// and procedures to the component. The script resource may contain comments
// as well. Global variables may also be defined. You may want to see the
// script resource as a Module file in Visual Basic.
//////////////////////////////////////////////////////////////////////////
bool CScriptObject::LoadScriptResource(LPCTSTR lpName, LPCTSTR lpType, HINSTANCE hInstance )
{
try{
if (m_pScript)
{
HRSRC res = ::FindResource(hInstance, lpName, lpType);
ASSERT( res != NULL);
BYTE* pbytes = (BYTE*) LockResource(LoadResource(hInstance, res ));
ASSERT( pbytes != NULL);
_bstr_t strCode = (LPCSTR) (pbytes);
m_pScript->AddCode( strCode );
GetMethodsName();
return true;
}
}
catch(...)
{
// Just catch the exception, call GetErrorString()
// to retreive last error
}
return false;
}
///////////////////////////////////////////////////////////////////////////////
// LoadScript
// Load a Script File. This function loads and insert all functions and
// procedures to the component. The script file may contain comments as well.
// Global variables may also be define. You may want to see the script file
// as a Module file in Visual Basic.
// The script file is probably a simple text file (ASCII format)
///////////////////////////////////////////////////////////////////////////////
bool CScriptObject::LoadScript(LPCTSTR szFilename)
{
HANDLE hFile = CreateFile(szFilename, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
DWORD dwSize = GetFileSize(hFile, NULL);
if (0xFFFFFFFF != dwSize)
{
BYTE* pbytes = (BYTE*) GlobalAlloc(GPTR, dwSize+1);
if (pbytes != NULL)
{
DWORD dwRead = 0;
bool bResult = false;
if (ReadFile(hFile, pbytes, dwSize, &dwRead, NULL))
{
try{
if (m_pScript)
{
_bstr_t strCode = (LPCSTR) (pbytes);
m_pScript->AddCode( strCode );
GetMethodsName();
bResult = true;
}
}
catch(...)
{
// Just catch the exception, call GetErrorString()
// to retreive last error
}
GlobalFree( (HGLOBAL) pbytes);
CloseHandle(hFile);
return bResult;
}
GlobalFree( (HGLOBAL) pbytes);
}
}
CloseHandle(hFile);
return false;
}
return false;
}
///////////////////////////////////////////////////////////////////////////////
// AddScript
// Use this function to add a script function, useful for internal use
// not global script (resource file).
///////////////////////////////////////////////////////////////////////////////
bool CScriptObject::AddScript(LPCTSTR szCode)
{
try {
if (m_pScript != NULL)
{
ULONG ref = m_pScript->AddRef();
_bstr_t strCode = szCode;
m_pScript->AddCode( strCode );
GetMethodsName();
ref = m_pScript->Release();
return true;
}
}
catch(...)
{
// Just catch the exception, call GetErrorString()
// to retreive last error
ULONG ref = m_pScript->Release();
}
return false;
}
///////////////////////////////////////////////////////////////////////////////
// ExecuteStatement
// Use this function to execute a "Sub routine" - no arguments
///////////////////////////////////////////////////////////////////////////////
bool CScriptObject::ExecuteStatement(LPCTSTR szStatement)
{
try {
if (m_pScript != NULL)
{
ULONG ref = m_pScript->AddRef();
m_pScript->ExecuteStatement( _bstr_t(szStatement) );
ref = m_pScript->Release();
return true;
}
}
catch(...)
{
// Just catch the exception, call GetErrorString()
// to retreive last error
ULONG ref = m_pScript->Release();
}
return false;
}
///////////////////////////////////////////////////////////////////////////////
// RunProcedure
// Use this function to run a "Procedure" or "Function" - with arguments
///////////////////////////////////////////////////////////////////////////////
bool CScriptObject::RunProcedure(LPCTSTR szProcName, SAFEARRAY** saParameters, VARIANT* varRet)
{
// required argument
ASSERT( saParameters != NULL);
ASSERT( varRet != NULL);
try {
if (m_pScript != NULL)
{
ULONG ref = m_pScript->AddRef();
bool bResult = false;
_bstr_t szFunc = GetScriptFunction(szProcName);
if (szFunc.length() > 0)
{
*varRet = m_pScript->Run(szFunc, saParameters);
bResult = true;
}
ref = m_pScript->Release();
return bResult;
}
}
catch(...)
{
// Just catch the exception, call GetErrorString()
// to retreive last error
ULONG ref = m_pScript->Release();
}
return false;
}
| [
"[email protected]"
]
| [
[
[
1,
560
]
]
]
|
7da3d848f101201ed5598312bf0cfbd008096f49 | 96e96a73920734376fd5c90eb8979509a2da25c0 | /C3DE/RendererListener.h | 58f10f5abe2956acb1f948ff92cdbc65ebfc5924 | []
| no_license | lianlab/c3de | 9be416cfbf44f106e2393f60a32c1bcd22aa852d | a2a6625549552806562901a9fdc083c2cacc19de | refs/heads/master | 2020-04-29T18:07:16.973449 | 2009-11-15T10:49:36 | 2009-11-15T10:49:36 | 32,124,547 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 232 | h | #ifndef RENDERER_LISTENER_H
#define RENDERER_LISTENER_H
class RendererListener
{
public:
RendererListener();
virtual ~RendererListener();
virtual void OnLostDevice() = 0;
virtual void OnResetDevice() = 0;
};
#endif | [
"caiocsabino@7e2be596-0d54-0410-9f9d-cf4183935158"
]
| [
[
[
1,
13
]
]
]
|
5842e6893450e01b25d2b3fd245b3c1646e2547d | daa67e21cc615348ba166d31eb25ced40fba9dc7 | /GameCode/Frustum.cpp | cb0b93ddd0b3e5e39331ea0d6cd6cc326eb279a1 | []
| no_license | gearsin/geartesttroject | 443d48b7211f706ab2c5104204bad7228458c3f2 | f86f255f5e9d1d34a00a4095f601a8235e39aa5a | refs/heads/master | 2020-05-19T14:27:35.821340 | 2008-09-02T19:51:16 | 2008-09-02T19:51:16 | 32,342,555 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,494 | cpp | //----------------------------------------------------------------------------------------------------------
#include "StdAfx.h"
#include "MathUtils.h"
#include "Frustum.h"
//----------------------------------------------------------------------------------------------------------
cFrustum::cFrustum( float pFov, float pNearDist, float pFarDist, float pRatio )
{
m_Fov = pFov;
m_NearDist = pNearDist;
m_FarDist = pFarDist;
m_Ratio = pRatio;
m_TanVal = tan( pFov / 2.0f );
m_HalfNearHeight = m_TanVal * m_NearDist;
m_HalfNearWidth = m_HalfNearHeight * m_Ratio;
m_HalfFarHeight = m_TanVal * m_FarDist;
m_HalfFarWidth = m_HalfFarHeight * m_Ratio;
}
//----------------------------------------------------------------------------------------------------------
cFrustum::~cFrustum()
{
}
//----------------------------------------------------------------------------------------------------------
void cFrustum::UpdateFrustum( CFirstPersonCamera * pCam )
{
//http://www.lighthouse3d.com/opengl/viewfrustum/index.php?gaplanes
//An optimization can be performed using this approach to extract the near and far planes.
//A plane can be defined with a normal and a point, and for those planes these are known based on the camera
//definition. The near plane can be defined with d as a normal, and nc as a point on the plane.
//As for the far plane the normal is -d and the point is fc. The other planes can also be computed in a
//more efficient manner, namely by using a normal vector and a point to define a plane. The following code
//provides the normal for the right plane. As for the point, the camera position, p is a point in all top,
//bottom, left and right planes (considering a perspective projection).
// nc = p + d * nearDist
// fc = p + d * farDist
// a = (nc + right * Wnear / 2) - p
// a.normalize();
// normalRight = up * a
//Both up and a are vectors that belong to the right plane, so their cross product will provide a
//normal for the plane.
cVector camPos = D3DXVecToVector( *( pCam->GetEyePt() ) );
cVector lookAt = D3DXVecToVector( *( pCam->GetLookAtPt() ) );
cVector upVec = D3DXVecToVector( *( pCam->GetWorldUp() ) );
cVector dirVec = camPos - lookAt;
dirVec.Normalize();
cVector rightVec = upVec.Cross( dirVec );
rightVec.Normalize();
upVec = dirVec.Cross( rightVec );
cVector nearPlaneCenter = camPos - dirVec * m_NearDist;
cVector farPlaneCenter = camPos - dirVec * m_FarDist;
cVector nearTop = upVec * m_HalfNearHeight;
cVector nearRight = rightVec * m_HalfNearWidth;
cVector farTop = upVec * m_HalfFarHeight;
cVector farRight = rightVec * m_HalfFarWidth;
//get the near plane corner pts
m_NearTopLeftSide = nearPlaneCenter + nearTop - nearRight;
m_NearTopRightSide = nearPlaneCenter + nearTop + nearRight;
m_NearBottomLeftSide = nearPlaneCenter - nearTop - nearRight;
m_NearBottomRightSide = nearPlaneCenter - nearTop + nearRight;
//get the near plane corner pts
m_FarTopLeftSide = farPlaneCenter + farTop - farRight;
m_FarTopRightSide = farPlaneCenter + farTop + farRight;
m_FarBottomLeftSide = farPlaneCenter - farTop - farRight;
m_FarBottomRightSide = farPlaneCenter - farTop + farRight;
// compute the six planes
// the function set3Points assumes that the points
// are given in counter clockwise order
m_FrustumPlanes[ePlane_Top].Set3Points( m_NearTopRightSide, m_NearTopLeftSide, m_FarTopLeftSide );
m_FrustumPlanes[ePlane_Bottom].Set3Points( m_NearBottomLeftSide, m_NearBottomRightSide, m_FarBottomRightSide );
m_FrustumPlanes[ePlane_Left].Set3Points( m_NearTopLeftSide, m_NearBottomLeftSide, m_FarBottomLeftSide );
m_FrustumPlanes[ePlane_Right].Set3Points( m_NearBottomRightSide, m_NearTopRightSide, m_FarBottomRightSide );
m_FrustumPlanes[ePlane_Near].Set3Points( m_NearTopLeftSide, m_NearTopRightSide, m_NearBottomRightSide );
m_FrustumPlanes[ePlane_Far].Set3Points( m_FarTopRightSide, m_FarTopLeftSide, m_FarBottomLeftSide );
}
//----------------------------------------------------------------------------------------------------------
int cFrustum::SphereInFrusutm( const cSphere * pSphere )
{
float distance = 0.0f;
int result = eInside_Frustum;
//const char *strClipPlane[] =
//{
// "Top",
// "Bottom",
// "Left",
// "Right",
// "Near",
// "Far"
//};
for( int idx = 0; idx < ePlane_Max; ++idx )
{
distance = m_FrustumPlanes[idx].ComputeDistance( pSphere->m_Center );
if ( distance < -pSphere->m_Radius )
{
// Log( " InterSect @ %s", strClipPlane[idx] );
return eOutside_Frustum;
}
else if (distance < pSphere->m_Radius )
{
result = eIntersect_Frustum;
}
}
return( result );
}
//----------------------------------------------------------------------------------------------------------
void cFrustum::DrawFrustum( IDirect3DDevice9 * pDevice, D3DXMATRIX & pMat )
{
return ;
//obsolute
ID3DXLine * frustumLine;
HRESULT hr = D3DXCreateLine( pDevice, &frustumLine );
cVector lineStart, lineEnd;
//near Plane Normal
lineStart = ( m_NearTopLeftSide + m_NearTopRightSide + m_NearBottomLeftSide + m_NearBottomRightSide ) * 0.25f;
lineEnd = lineStart + m_FrustumPlanes[ePlane_Near].m_PlaneNormal;
D3DXVECTOR3 nearPlaneNormal [] =
{
VectorToD3DXVec( lineStart ),
VectorToD3DXVec( lineEnd )
};
//far Plane Normal
lineStart = ( m_FarTopLeftSide + m_FarTopRightSide + m_FarBottomLeftSide + m_FarBottomRightSide ) * 0.25f;
lineEnd = lineStart + m_FrustumPlanes[ePlane_Far].m_PlaneNormal;
D3DXVECTOR3 farPlaneNormal [] =
{
VectorToD3DXVec( lineStart ),
VectorToD3DXVec( lineEnd )
};
//left Plane Normal
lineStart = ( m_NearTopLeftSide + m_NearBottomLeftSide + m_FarTopLeftSide + m_FarBottomLeftSide ) * 0.25f;
lineEnd = lineStart + m_FrustumPlanes[ePlane_Left].m_PlaneNormal + cVector( 12.0f, 0.0f, 0.0f );
D3DXVECTOR3 leftPlaneNormal [] =
{
VectorToD3DXVec( lineStart ),
VectorToD3DXVec( lineEnd )
};
assert( frustumLine->Begin() == S_OK );
assert( frustumLine->DrawTransform( nearPlaneNormal, 2, &pMat, D3DCOLOR_RGBA( 255, 0, 0, 255 ) ) == S_OK );
assert( frustumLine->DrawTransform( farPlaneNormal, 2, &pMat, D3DCOLOR_RGBA( 0, 255, 0, 255 ) ) == S_OK );
assert( frustumLine->DrawTransform( leftPlaneNormal, 2, &pMat, D3DCOLOR_RGBA( 0, 0, 255, 255 ) ) == S_OK );
assert( frustumLine->End() == S_OK );
SAFE_RELEASE( frustumLine );
} | [
"sunil.ssingh@592c7993-d951-0410-8115-35849596357c"
]
| [
[
[
1,
174
]
]
]
|
e9a1836e1a9b3fa32c62036d64590662e2ac3ee7 | 478570cde911b8e8e39046de62d3b5966b850384 | /apicompatanamdw/bcdrivers/os/devicesrv/SystemSW/central_repository_notification_handler_api/inc/CenRepNotifyHandlerTest.h | 636bc5949e794b52001d7931e82db179c7d594e2 | []
| no_license | SymbianSource/oss.FCL.sftools.ana.compatanamdw | a6a8abf9ef7ad71021d43b7f2b2076b504d4445e | 1169475bbf82ebb763de36686d144336fcf9d93b | refs/heads/master | 2020-12-24T12:29:44.646072 | 2010-11-11T14:03:20 | 2010-11-11T14:03:20 | 72,994,432 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,332 | h | /*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: CenRepNotifyHandlerTest test module.
*
*/
#ifndef CENREPNOTIFYHANDLERTEST_H
#define CENREPNOTIFYHANDLERTEST_H
// INCLUDES
#include "StifTestModule.h"
#include <StifLogger.h>
#include <CentralRepository.h>
#include <cenrepnotifyhandler.h>
#include "TestScheduler.h"
// CONSTANTS
//const ?type ?constant_var = ?constant;
// MACROS
//#define ?macro ?macro_def
#define TEST_MODULE_VERSION_MAJOR 31
#define TEST_MODULE_VERSION_MINOR 9
#define TEST_MODULE_VERSION_BUILD 40
// Logging path
_LIT( KCenRepNotifyHandlerTestLogPath, "\\logs\\testframework\\CenRepNotifyHandlerTest\\" );
// Log file
_LIT( KCenRepNotifyHandlerTestLogFile, "CenRepNotifyHandlerTest.txt" );
// Function pointer related internal definitions
// Rounding known bug in GCC
#ifndef __GCC32__
#define GETPTR
#else
#define GETPTR &
#endif
#define ENTRY(str,func) {_S(str), GETPTR func}
#define FUNCENTRY(func) {_S(#func), GETPTR func}
// FUNCTION PROTOTYPES
//?type ?function_name(?arg_list);
// FORWARD DECLARATIONS
//class ?FORWARD_CLASSNAME;
class CCenRepNotifyHandlerTest;
//class CTestScheduler;
// DATA TYPES
//enum ?declaration
//typedef ?declaration
//extern ?data_type;
// A typedef for function that does the actual testing,
// function is a type
// TInt CCenRepNotifyHandlerTest::<NameOfFunction> ( TTestResult& aResult )
typedef TInt (CCenRepNotifyHandlerTest::* TestFunction)(TTestResult&);
// CLASS DECLARATION
/**
* An internal structure containing a test case name and
* the pointer to function doing the test
*
* @lib ?library
* @since ?Series60_version
*/
class TCaseInfoInternal
{
public:
const TText* iCaseName;
TestFunction iMethod;
};
// CLASS DECLARATION
/**
* A structure containing a test case name and
* the pointer to function doing the test
*
* @lib ?library
* @since ?Series60_version
*/
class TCaseInfo
{
public:
TPtrC iCaseName;
TestFunction iMethod;
TCaseInfo( const TText* a ) : iCaseName( (TText*) a )
{
};
};
// CLASS DECLARATION
/**
* This a CenRepNotifyHandlerTest class.
* ?other_description_lines
*
* @lib ?library
* @since ?Series60_version
*/
NONSHARABLE_CLASS(CCenRepNotifyHandlerTest) : public CTestModuleBase, MCenRepNotifyHandlerCallback
{
public: // Constructors and destructor
/**
* Two-phased constructor.
*/
static CCenRepNotifyHandlerTest* NewL();
/**
* Destructor.
*/
virtual ~CCenRepNotifyHandlerTest();
public: // New functions
/**
* ?member_description.
* @since ?Series60_version
* @param ?arg1 ?description
* @return ?description
*/
//?type ?member_function( ?type ?arg1 );
void HandleNotifyInt(TUint32 aId, TInt aNewValue);
void HandleNotifyReal(TUint32 aId, TReal aNewValue);
void HandleNotifyString(TUint32 aId, const TDesC16& aNewValue);
void HandleNotifyBinary(TUint32 aId, const TDesC8& aNewValue);
void HandleNotifyGeneric(TUint32 aId);
void HandleNotifyError(TUint32 aId, TInt error, CCenRepNotifyHandler* aHandler);
public: // Functions from base classes
/**
* From CTestModuleBase InitL is used to initialize the
* CenRepNotifyHandlerTest. It is called once for every instance of
* TestModuleCenRepNotifyHandlerTest after its creation.
* @since ?Series60_version
* @param aIniFile Initialization file for the test module (optional)
* @param aFirstTime Flag is true when InitL is executed for first
* created instance of CenRepNotifyHandlerTest.
* @return Symbian OS error code
*/
TInt InitL( TFileName& aIniFile, TBool aFirstTime );
/**
* From CTestModuleBase GetTestCasesL is used to inquiry test cases
* from CenRepNotifyHandlerTest.
* @since ?Series60_version
* @param aTestCaseFile Test case file (optional)
* @param aTestCases Array of TestCases returned to test framework
* @return Symbian OS error code
*/
TInt GetTestCasesL( const TFileName& aTestCaseFile,
RPointerArray<TTestCaseInfo>& aTestCases );
/**
* From CTestModuleBase RunTestCaseL is used to run an individual
* test case.
* @since ?Series60_version
* @param aCaseNumber Test case number
* @param aTestCaseFile Test case file (optional)
* @param aResult Test case result returned to test framework (PASS/FAIL)
* @return Symbian OS error code (test case execution error, which is
* not reported in aResult parameter as test case failure).
*/
TInt RunTestCaseL( const TInt aCaseNumber,
const TFileName& aTestCaseFile,
TTestResult& aResult );
/**
* Method used to log version of test module
*/
void SendTestModuleVersion();
/**
* ?member_description.
* @since ?Series60_version
* @param ?arg1 ?description
* @return ?description
*/
//?type ?member_function( ?type ?arg1 );
protected: // Functions from base classes
/**
* From ?base_class ?member_description
*/
//?type ?member_function();
private:
/**
* C++ default constructor.
*/
CCenRepNotifyHandlerTest();
/**
* By default Symbian 2nd phase constructor is private.
*/
void ConstructL();
// Prohibit copy constructor if not deriving from CBase.
// ?classname( const ?classname& );
// Prohibit assigment operator if not deriving from CBase.
// ?classname& operator=( const ?classname& );
/**
* Function returning test case name and pointer to test case function.
* @since ?Series60_version
* @param aCaseNumber test case number
* @return TCaseInfo
*/
const TCaseInfo Case ( const TInt aCaseNumber ) const;
/**
* Function returning test case name and pointer to test case function.
* @since ?Series60_version
* @param aCaseNumber test case number
* @return TCaseInfo
*/
void InitializeNotifyData();
/**
* Actual Hardcoded test case functions are listed below.
*/
/**
* Printing test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt ListeningToSingleIntKey( TTestResult& aResult );
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt ListeningToSingleRealKey( TTestResult& aResult );
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt ListeningToSingleStringKey( TTestResult& aResult );
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt ListeningToSingleBinaryKey( TTestResult& aResult );
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt ListeningToAllKeys (TTestResult& aResult);
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt NoMultipleNotifiesOnSameValueChange (TTestResult& aResult);
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt NoNotificationAfterStopListening( TTestResult& aResult );
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt NotificationAfterWholeRepositoryReset ( TTestResult& aResult );
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt NotificationAfterRepositoryKeyReset ( TTestResult& aResult );
/**
* Printing loop test case.
* @since ?Series60_version
* @param aResult Test case result (PASS/FAIL)
* @return Symbian OS error code (test case execution error
* that is not returned as test case result in aResult)
*/
TInt ListeningForTwoNotificationHandler (TTestResult& aResult );
public: // Data
// ?one_line_short_description_of_data
//?data_declaration;
protected: // Data
// ?one_line_short_description_of_data
//?data_declaration;
private: // Data
// Pointer to test (function) to be executed
TestFunction iMethod;
// Pointer to logger
CStifLogger * iLog;
//Pointer to cenrep notify handler
CCenRepNotifyHandler* iNotifyHandler;
//Pointer to cenrep notify handler (needed in test case ListeningForTwoNotificationHandler)
CCenRepNotifyHandler* iSecondHandler;
//Pointer to central repository session
CRepository* iSession;
CActiveScheduler* myScheduler;
TInt iNotifyInt;
TReal iNotifyReal;
TBuf16<NCentralRepositoryConstants::KMaxUnicodeStringLength> iNotifyString;
TBuf8<NCentralRepositoryConstants::KMaxBinaryLength> iNotifyBinary;
TBuf8<NCentralRepositoryConstants::KMaxBinaryLength> iSecondBinary;
TUint32 iNotificationId;
TUint32 iSecondNotificationId;
TInt iNotifyError;
// Reserved pointer for future extension
//TAny* iReserved;
public: // Friend classes
//?friend_class_declaration;
protected: // Friend classes
//?friend_class_declaration;
private: // Friend classes
//?friend_class_declaration;
};
#endif // CENREPNOTIFYHANDLERTEST_H
// End of File | [
"none@none"
]
| [
[
[
1,
395
]
]
]
|
a77fd26038734e416c0d63e1b46c54a6b0d4c8a6 | 8aa65aef3daa1a52966b287ffa33a3155e48cc84 | /Source/Common/LogAppenderDefinitions.h | c7998685e1826bb83f98dc1dd6985e45d1160d4e | []
| no_license | jitrc/p3d | da2e63ef4c52ccb70023d64316cbd473f3bd77d9 | b9943c5ee533ddc3a5afa6b92bad15a864e40e1e | refs/heads/master | 2020-04-15T09:09:16.192788 | 2009-06-29T04:45:02 | 2009-06-29T04:45:02 | 37,063,569 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 628 | h | #pragma once
#include "LogAppender.h"
#include "DebugOutputAppender.h"
#include "FileAppender.h"
#include "ConsoleOutputAppender.h"
namespace P3D
{
namespace LogAppenders
{
typedef LogAppender* (*CreateFromXMLFunction)(TiXmlElement* node);
struct AppenderDefenition
{
const char* Type;
CreateFromXMLFunction FactoryFunction;
};
static AppenderDefenition gAppendersDefenitions[] =
{
{ "Debug", &DebugOutputAppender::CreateFromXMLDefenition },
{ "File", &FileAppender::CreateFromXMLDefenition },
{ "Console", &ConsoleOutputAppender::CreateFromXMLDefenition }
};
}
} | [
"vadun87@6320d0be-1f75-11de-b650-e715bd6d7cf1"
]
| [
[
[
1,
28
]
]
]
|
295e0222b72489f4d768b24de27d3081ba74db38 | 1feabd4308571795d0628355d9385ddb84f4334c | /devices/arduino_master/master_reader/rolade/rolade.cpp | d004ecd137802ecb1350202e7cc283ce46398b82 | []
| no_license | michalharakal/cheesboard.timer-modul | b7312156dafcaed35f12712899cbffc034ce65b7 | e83c2206f08929a5320952ac63d5d20dc0c148dd | refs/heads/master | 2021-01-01T19:06:32.758332 | 2011-12-29T22:04:23 | 2011-12-29T22:04:23 | 38,479,692 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 593 | cpp | #include <stdio.h>
#include <string.h>
#include "rolade.h"
RoladeProperties::RoladeProperties()
{
}
RoladeProperties::~RoladeProperties()
{
}
void RoladeProperties::SetAutomaticInterval(uint8_t h_start, uint8_t m_start, uint8_t h_end, uint8_t m_end)
{
m_start_hour = h_start;
m_start_minute = m_start;
m_start_seconds = 0;
m_end_hour = h_end;
m_end_minute = m_end;
m_end_seconds = 0;
}
void RoladeProperties::Serialize(void *dest, size_t *size)
{
*size = sizeof(RoladePropertiesData);
memcpy(dest, this, sizeof((RoladePropertiesData*)this));
}
| [
"[email protected]"
]
| [
[
[
1,
31
]
]
]
|
32e4e5c5c94de0a69df170eda04b5c7c1ad474c3 | d01196cdfc4451c4e1c88343bdb1eb4db9c5ac18 | /source/server/ents/basemover.cpp | de8d178eebb9c4a81aa82ced352da92427515553 | []
| no_license | ferhan66h/Xash3D_ancient | 7491cd4ff1c7d0b48300029db24d7e08ba96e88a | 075e0a6dae12a0952065eb9b2954be4a8827c72f | refs/heads/master | 2021-12-10T07:55:29.592432 | 2010-05-09T00:00:00 | 2016-07-30T17:37:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 45,501 | cpp | //=======================================================================
// Copyright (C) Shambler Team 2005
// basemover.cpp - base code for linear and
// angular moving brushes e.g. doors, buttons e.t.c
//=======================================================================
#include "extdll.h"
#include "defaults.h"
#include "utils.h"
#include "cbase.h"
#include "client.h"
#include "saverestore.h"
#include "player.h"
//=======================================================================
// main functions ()
//=======================================================================
TYPEDESCRIPTION CBaseMover::m_SaveData[] =
{
DEFINE_FIELD( CBaseMover, m_flBlockedTime, FIELD_TIME ),
DEFINE_FIELD( CBaseMover, m_iMode, FIELD_INTEGER ),
DEFINE_FIELD( CBaseMover, m_flMoveDistance, FIELD_FLOAT ),
DEFINE_FIELD( CBaseMover, m_flWait, FIELD_FLOAT ),
DEFINE_FIELD( CBaseMover, m_flLip, FIELD_FLOAT ),
DEFINE_FIELD( CBaseMover, m_flHeight, FIELD_FLOAT ),
DEFINE_FIELD( CBaseMover, m_flValue, FIELD_FLOAT ),
DEFINE_FIELD( CBaseMover, m_vecFinalDest, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CBaseMover, m_vecPosition1, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CBaseMover, m_vecPosition2, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CBaseMover, m_vecFloor, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CBaseMover, m_pfnCallWhenMoveDone, FIELD_FUNCTION ),
DEFINE_FIELD( CBaseMover, m_vecAngle1, FIELD_VECTOR ),
DEFINE_FIELD( CBaseMover, m_vecAngle2, FIELD_VECTOR ),
DEFINE_FIELD( CBaseMover, m_flLinearMoveSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CBaseMover, m_flAngularMoveSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CBaseMover, m_vecFinalAngle, FIELD_VECTOR ),
DEFINE_FIELD( CBaseMover, flTravelTime, FIELD_FLOAT ),
}; IMPLEMENT_SAVERESTORE( CBaseMover, CBaseBrush );
void CBaseMover :: AxisDir( void )
{
// make backward compatibility
if ( pev->movedir != g_vecZero) return;
if ( FBitSet(pev->spawnflags, 128))
pev->movedir = Vector ( 0, 0, 1 ); // around z-axis
else if ( FBitSet(pev->spawnflags, 64))
pev->movedir = Vector ( 1, 0, 0 ); // around x-axis
else pev->movedir = Vector ( 0, 1, 0 ); // around y-axis
}
void CBaseMover::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "lip"))
{
m_flLip = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
if (FStrEq(pkvd->szKeyName, "waveheight"))
{
//field for volume_water
pev->scale = atof(pkvd->szValue) * (1.0/8.0);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "type"))
{
m_iMode = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "wait"))
{
m_flWait = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "locksound"))
{
m_iStartSound = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "movesound"))
{
m_iMoveSound = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "stopsound"))
{
m_iStopSound = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "distance"))
{
m_flMoveDistance = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "height"))
{
m_flHeight = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "waveheight"))
{
// func_water wave height
pev->scale = atof( pkvd->szValue ) * ( 1.0f / 8.0f );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "contents"))
{
// func_water contents
pev->skin = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else CBaseBrush::KeyValue( pkvd );
}
//=======================================================================
// LinearMove
//
// calculate pev->velocity and pev->nextthink to reach vecDest from
// pev->origin traveling at flSpeed
//=======================================================================
void CBaseMover :: LinearMove( Vector vecInput, float flSpeed )
{
ASSERTSZ(flSpeed != 0, "LinearMove: no speed is defined!");
m_flLinearMoveSpeed = flSpeed;
m_vecFinalDest = vecInput;
SetThink( LinearMoveNow );
UTIL_SetThink( this );
}
void CBaseMover :: LinearMoveNow( void )
{
Vector vecDest;
if (m_pParent)vecDest = m_vecFinalDest + m_pParent->pev->origin;
else vecDest = m_vecFinalDest;
// Already there?
if (vecDest == pev->origin)
{
LinearMoveDone();
return;
}
// set destdelta to the vector needed to move
Vector vecDestDelta = vecDest - pev->origin;
// divide vector length by speed to get time to reach dest
flTravelTime = vecDestDelta.Length() / m_flLinearMoveSpeed;
// set nextthink to trigger a call to LinearMoveDone when dest is reached
SetNextThink( flTravelTime );
SetThink( LinearMoveDone );
UTIL_SetVelocity( this, vecDestDelta / flTravelTime );
}
//=======================================================================
// After moving, set origin to exact final destination,
// call "move done" function
//=======================================================================
void CBaseMover :: LinearMoveDone( void )
{
SetThink(LinearMoveDoneNow);
UTIL_SetThink( this );
}
void CBaseMover :: LinearMoveDoneNow( void )
{
UTIL_SetVelocity(this, g_vecZero);
if (m_pParent) UTIL_AssignOrigin(this, m_vecFinalDest + m_pParent->pev->origin);
else UTIL_AssignOrigin(this, m_vecFinalDest);
DontThink();
if( m_pfnCallWhenMoveDone )(this->*m_pfnCallWhenMoveDone)();
}
//=======================================================================
// AngularMove
//
// calculate pev->velocity and pev->nextthink to reach vecDest from
// pev->origin traveling at flSpeed
// Just like LinearMove, but rotational.
//=======================================================================
void CBaseMover :: AngularMove( Vector vecDestAngle, float flSpeed )
{
ASSERTSZ(flSpeed != 0, "AngularMove: no speed is defined!");
m_vecFinalAngle = vecDestAngle;
m_flAngularMoveSpeed = flSpeed;
SetThink( AngularMoveNow );
UTIL_SetThink( this );
}
void CBaseMover :: AngularMoveNow()
{
Vector vecDestAngle;
if (m_pParent) vecDestAngle = m_vecFinalAngle + m_pParent->pev->angles;
else vecDestAngle = m_vecFinalAngle;
// Already there?
if (vecDestAngle == pev->angles)
{
AngularMoveDone();
return;
}
// set destdelta to the vector needed to move
Vector vecDestDelta = vecDestAngle - pev->angles;
// divide by speed to get time to reach dest
flTravelTime = vecDestDelta.Length() / m_flAngularMoveSpeed;
// set nextthink to trigger a call to AngularMoveDone when dest is reached
SetNextThink( flTravelTime );
SetThink( AngularMoveDone );
// scale the destdelta vector by the time spent traveling to get velocity
UTIL_SetAvelocity(this, vecDestDelta / flTravelTime );
}
void CBaseMover :: AngularMoveDone( void )
{
SetThink( AngularMoveDoneNow );
UTIL_SetThink( this );
}
//=======================================================================
// After rotating, set angle to exact final angle, call "move done" function
//=======================================================================
void CBaseMover :: AngularMoveDoneNow( void )
{
UTIL_SetAvelocity(this, g_vecZero);
if (m_pParent) UTIL_AssignAngles(this, m_vecFinalAngle + m_pParent->pev->angles);
else UTIL_AssignAngles(this, m_vecFinalAngle);
DontThink();
if ( m_pfnCallWhenMoveDone ) (this->*m_pfnCallWhenMoveDone)();
}
//=======================================================================
// ComplexMove
//
// combinate LinearMove and AngularMove
//=======================================================================
void CBaseMover :: ComplexMove( Vector vecInput, Vector vecDestAngle, float flSpeed )
{
ASSERTSZ(flSpeed != 0, "ComplexMove: no speed is defined!");
//set shared speed for moving and rotating
m_flLinearMoveSpeed = flSpeed;
m_flAngularMoveSpeed = flSpeed;
//save local variables into global containers
m_vecFinalDest = vecInput;
m_vecFinalAngle = vecDestAngle;
SetThink( ComplexMoveNow );
UTIL_SetThink( this );
}
void CBaseMover :: ComplexMoveNow( void )
{
Vector vecDest, vecDestAngle;
if (m_pParent)//calculate destination
{
vecDest = m_vecFinalDest + m_pParent->pev->origin;
vecDestAngle = m_vecFinalAngle + m_pParent->pev->angles;
}
else
{
vecDestAngle = m_vecFinalAngle;
vecDest = m_vecFinalDest;
}
// Already there?
if (vecDest == pev->origin && vecDestAngle == pev->angles)
{
ComplexMoveDone();
return;
}
// Calculate TravelTime and final angles
Vector vecDestLDelta = vecDest - pev->origin;
Vector vecDestADelta = vecDestAngle - pev->angles;
// divide vector length by speed to get time to reach dest
flTravelTime = vecDestLDelta.Length() / m_flLinearMoveSpeed;
// set nextthink to trigger a call to LinearMoveDone when dest is reached
SetNextThink( flTravelTime );
SetThink( ComplexMoveDone );
//set linear and angular velocity now
UTIL_SetVelocity( this, vecDestLDelta / flTravelTime );
UTIL_SetAvelocity(this, vecDestADelta / flTravelTime );
}
void CBaseMover :: ComplexMoveDone( void )
{
SetThink(ComplexMoveDoneNow);
UTIL_SetThink( this );
}
void CBaseMover :: ComplexMoveDoneNow( void )
{
UTIL_SetVelocity(this, g_vecZero);
UTIL_SetAvelocity(this, g_vecZero);
if (m_pParent)
{
UTIL_AssignOrigin(this, m_vecFinalDest + m_pParent->pev->origin);
UTIL_AssignAngles(this, m_vecFinalAngle + m_pParent->pev->angles);
}
else
{
UTIL_AssignOrigin(this, m_vecFinalDest);
UTIL_AssignAngles(this, m_vecFinalAngle);
}
DontThink();
if( m_pfnCallWhenMoveDone )(this->*m_pfnCallWhenMoveDone)();
}
//=======================================================================
// func_door - classic QUAKE door
//=======================================================================
void CBaseDoor::Spawn( void )
{
Precache();
if(!IsRotatingDoor()) UTIL_LinearVector( this );
CBaseBrush::Spawn();
if ( pev->spawnflags & SF_NOTSOLID ) // make illusionary door
{
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE;
}
else
{
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
}
if( IsRotatingDoor( ))
{
// check for clockwise rotation
if ( m_flMoveDistance < 0 ) pev->movedir = pev->movedir * -1;
AxisDir();
m_vecAngle1 = pev->angles;
m_vecAngle2 = pev->angles + pev->movedir * m_flMoveDistance;
ASSERTSZ( m_vecAngle1 != m_vecAngle2, "rotating door start/end positions are equal" );
SetBits ( pFlags, PF_ANGULAR );
}
UTIL_SetModel( ENT(pev), pev->model );
UTIL_SetOrigin( this, pev->origin );
// determine work style
if ( m_iMode == 0 ) // normal door - only USE
{
SetUse ( DoorUse );
SetTouch ( NULL );
pev->team = 1; // info_node identifier. Do not edit!!!
}
if( m_iMode == 1 ) // classic QUAKE & HL door - only TOUCH
{
SetUse ( ShowInfo );//show info only
SetTouch ( DoorTouch );
}
if( m_iMode == 2 ) // combo door - USE and TOUCH
{
SetUse ( DoorUse );
SetTouch ( DoorTouch );
}
// as default any door is toggleable, but if mapmaker set waittime > 0
// door will de transformed into timebased door
// if waittime is -1 - button forever stay pressed
if ( m_flWait <= 0.0f ) pev->impulse = 1; // toggleable door
if ( m_flLip == 0 ) m_flLip = 4; // standart offset from Quake1
if ( pev->speed == 0 )
pev->speed = 100; // default speed
m_iState = STATE_OFF;
}
void CBaseDoor :: PostSpawn( void )
{
if (m_pParent) m_vecPosition1 = pev->origin - m_pParent->pev->origin;
else m_vecPosition1 = pev->origin;
// Subtract 2 from size because the engine expands bboxes by 1 in all directions
m_vecPosition2 = m_vecPosition1 + (pev->movedir * (fabs( pev->movedir.x * (pev->size.x-2) ) + fabs( pev->movedir.y * (pev->size.y-2) ) + fabs( pev->movedir.z * (pev->size.z-2) ) - m_flLip));
ASSERTSZ( m_vecPosition1 != m_vecPosition2, "door start/end positions are equal" );
if ( FBitSet( pev->spawnflags, SF_START_ON ))
{
if ( m_pParent )
{
m_vecSpawnOffset = m_vecSpawnOffset + (m_vecPosition2 + m_pParent->pev->origin) - pev->origin;
UTIL_AssignOrigin( this, m_vecPosition2 + m_pParent->pev->origin );
}
else
{
m_vecSpawnOffset = m_vecSpawnOffset + m_vecPosition2 - pev->origin;
UTIL_AssignOrigin( this, m_vecPosition2 );
}
Vector vecTemp = m_vecPosition2;
m_vecPosition2 = m_vecPosition1;
m_vecPosition1 = vecTemp;
}
}
void CBaseDoor :: SetToggleState( int state )
{
if ( m_iState == STATE_ON )
{
if ( m_pParent ) UTIL_AssignOrigin( this, m_vecPosition2 + m_pParent->pev->origin );
else UTIL_AssignOrigin( this, m_vecPosition2 );
}
else
{
if ( m_pParent ) UTIL_AssignOrigin( this, m_vecPosition1 + m_pParent->pev->origin );
else UTIL_AssignOrigin( this, m_vecPosition1 );
}
}
void CBaseDoor::Precache( void )
{
CBaseBrush::Precache(); // precache damage sound
int m_sounds = UTIL_LoadSoundPreset( m_iMoveSound );
switch ( m_sounds ) // load movesound sounds (sound will play when door is moving)
{
case 1: pev->noise1 = UTIL_PrecacheSound ("doors/doormove1.wav");break;
case 2: pev->noise1 = UTIL_PrecacheSound ("doors/doormove2.wav");break;
case 3: pev->noise1 = UTIL_PrecacheSound ("doors/doormove3.wav");break;
case 4: pev->noise1 = UTIL_PrecacheSound ("doors/doormove4.wav");break;
case 5: pev->noise1 = UTIL_PrecacheSound ("doors/doormove5.wav");break;
case 6: pev->noise1 = UTIL_PrecacheSound ("doors/doormove6.wav");break;
case 7: pev->noise1 = UTIL_PrecacheSound ("doors/doormove7.wav");break;
case 8: pev->noise1 = UTIL_PrecacheSound ("doors/doormove8.wav");break;
case 9: pev->noise1 = UTIL_PrecacheSound ("doors/doormove9.wav");break;
case 10: pev->noise1 = UTIL_PrecacheSound ("doors/doormove10.wav");break;
case 0: pev->noise1 = UTIL_PrecacheSound ("common/null.wav"); break;
default: pev->noise1 = UTIL_PrecacheSound(m_sounds); break; // custom sound or sentence
}
m_sounds = UTIL_LoadSoundPreset( m_iStopSound );
switch ( m_sounds ) // load pushed sounds (sound will play at activate or pushed button)
{
case 1: pev->noise2 = UTIL_PrecacheSound ("doors/doorstop1.wav");break;
case 2: pev->noise2 = UTIL_PrecacheSound ("doors/doorstop2.wav");break;
case 3: pev->noise2 = UTIL_PrecacheSound ("doors/doorstop3.wav");break;
case 4: pev->noise2 = UTIL_PrecacheSound ("doors/doorstop4.wav");break;
case 5: pev->noise2 = UTIL_PrecacheSound ("doors/doorstop5.wav");break;
case 6: pev->noise2 = UTIL_PrecacheSound ("doors/doorstop6.wav");break;
case 7: pev->noise2 = UTIL_PrecacheSound ("doors/doorstop7.wav");break;
case 8: pev->noise2 = UTIL_PrecacheSound ("doors/doorstop8.wav");break;
case 0: pev->noise2 = UTIL_PrecacheSound ("common/null.wav"); break;
default: pev->noise2 = UTIL_PrecacheSound(m_sounds); break;//custom sound or sentence
}
if ( !FStringNull( m_sMaster ))//door has master
{
m_sounds = UTIL_LoadSoundPreset( m_iStartSound );
switch ( m_sounds ) // load locked sounds
{
case 1: pev->noise3 = UTIL_PrecacheSound ("!NA"); break;
case 2: pev->noise3 = UTIL_PrecacheSound ("!ND"); break;
case 3: pev->noise3 = UTIL_PrecacheSound ("!NF"); break;
case 4: pev->noise3 = UTIL_PrecacheSound ("!NFIRE"); break;
case 5: pev->noise3 = UTIL_PrecacheSound ("!NCHEM"); break;
case 6: pev->noise3 = UTIL_PrecacheSound ("!NRAD"); break;
case 7: pev->noise3 = UTIL_PrecacheSound ("!NCON"); break;
case 8: pev->noise3 = UTIL_PrecacheSound ("!NH"); break;
case 9: pev->noise3 = UTIL_PrecacheSound ("!NG"); break;
case 0: pev->noise3 = UTIL_PrecacheSound ("common/null.wav"); break;
default: pev->noise3 = UTIL_PrecacheSound(m_sounds); break;//custom sound or sentence
}
}
}
void CBaseDoor::DoorTouch( CBaseEntity *pOther )
{
// make delay before retouching
if ( gpGlobals->time < pev->dmgtime ) return;
pev->dmgtime = gpGlobals->time + 1.0f;
m_hActivator = pOther;// remember who activated the door
if( pOther->IsPlayer( ))
DoorUse ( pOther, this, USE_TOGGLE, 1 ); // player always sending 1
}
void CBaseDoor::DoorUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
m_hActivator = pActivator;
if ( IsLockedByMaster( useType ))//passed only USE_SHOWINFO
{
EMIT_SOUND( edict(), CHAN_VOICE, STRING( pev->noise3 ), 1, ATTN_NORM );
return;
}
if ( useType == USE_SHOWINFO ) // show info
{
ALERT(at_console, "======/Xash Debug System/======\n");
ALERT(at_console, "classname: %s\n", STRING(pev->classname));
ALERT(at_console, "State: %s, Speed %.2f\n", GetStringForState( GetState()), pev->speed );
ALERT(at_console, "Texture frame: %.f. WaitTime: %.2f\n", pev->frame, m_flWait);
}
else if ( m_iState != STATE_DEAD ) // activate door
{
// NOTE: STATE_DEAD is better method for simulate m_flWait -1 without fucking SetThink()
if ( m_iState == STATE_TURN_ON || m_iState == STATE_TURN_OFF ) return; // door in-moving
if ( useType == USE_TOGGLE)
{
if ( m_iState == STATE_OFF )
useType = USE_ON;
else useType = USE_OFF;
}
if ( useType == USE_ON )
{
if( m_iState == STATE_OFF )
DoorGoUp();
}
else if ( useType == USE_OFF )
{
if(m_iState == STATE_ON && pev->impulse) DoorGoDown();
}
else if ( useType == USE_SET )
{
if ( value )
{
m_flWait = value;
pev->impulse = 0;
}
}
else if ( useType == USE_RESET )
{
m_flWait = 0;
pev->impulse = 1;
}
}
}
void CBaseDoor :: ShowInfo ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if(useType == USE_SHOWINFO)//show info
{
ALERT(at_console, "======/Xash Debug System/======\n");
ALERT(at_console, "classname: %s\n", STRING(pev->classname));
ALERT(at_console, "State: %s, Speed %.2f\n", GetStringForState( GetState()), pev->speed );
ALERT(at_console, "Texture frame: %.f. WaitTime: %.2f\n", pev->frame, m_flWait);
}
}
void CBaseDoor::DoorGoUp( void )
{
// It could be going-down, if blocked.
ASSERT( m_iState == STATE_OFF || m_iState == STATE_TURN_OFF );
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise1), 1, ATTN_NORM);
SET_AREAPORTAL( edict(), true ); // open areaportal
m_iState = STATE_TURN_ON;
SetMoveDone( DoorHitTop );
UTIL_FireTargets( pev->target, m_hActivator, this, USE_ON );
if(IsRotatingDoor()) AngularMove(m_vecAngle2, pev->speed);
else LinearMove(m_vecPosition2, pev->speed);
}
void CBaseDoor::DoorHitTop( void )
{
STOP_SOUND( ENT( pev ), CHAN_STATIC, STRING( pev->noise1 ));
EMIT_SOUND( ENT( pev ), CHAN_STATIC, STRING( pev->noise2 ), 1, ATTN_NORM );
ASSERT( m_iState == STATE_TURN_ON );
m_iState = STATE_ON;
if( m_flWait == -1 )
{
m_iState = STATE_DEAD; // keep door in this position
return;
}
if( pev->impulse == 0 ) // time base door
{
SetThink( DoorGoDown );
SetNextThink( m_flWait );
}
// Fire the close target (if startopen is set, then "top" is closed)
if( pev->spawnflags & SF_START_ON )
UTIL_FireTargets( pev->target, m_hActivator, this, USE_OFF );
else UTIL_FireTargets( pev->target, m_hActivator, this, USE_ON );
}
void CBaseDoor::DoorGoDown( void )
{
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise1), 1, ATTN_NORM);
ASSERT(m_iState == STATE_ON);
m_iState = STATE_TURN_OFF;
SetMoveDone( DoorHitBottom );
if(IsRotatingDoor())AngularMove( m_vecAngle1, pev->speed);
else LinearMove(m_vecPosition1, pev->speed);
}
void CBaseDoor::DoorHitBottom( void )
{
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise1) );
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise2), 1, ATTN_NORM);
ASSERT(m_iState == STATE_TURN_OFF);
m_iState = STATE_OFF;
SET_AREAPORTAL( edict(), false ); // close areaportal
if ( pev->spawnflags & SF_START_ON )
UTIL_FireTargets( pev->target, m_hActivator, this, USE_ON );
else UTIL_FireTargets( pev->target, m_hActivator, this, USE_OFF );
UTIL_FireTargets( pev->target, m_hActivator, this, USE_ON );
}
void CBaseDoor::Blocked( CBaseEntity *pOther )
{
CBaseEntity *pTarget = NULL;
CBaseDoor *pDoor = NULL;
UTIL_AssignOrigin( this, pev->origin );
// make delay before retouching
if( gpGlobals->time < m_flBlockedTime ) return;
m_flBlockedTime = gpGlobals->time + 0.5;
if(m_pParent && m_pParent->edict() && pFlags & PF_PARENTMOVE) m_pParent->Blocked( pOther);
if ( pev->dmg ) pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH );
if (m_flWait >= 0)
{
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise1) );
if(IsRotatingDoor())
{
if (m_iState == STATE_TURN_ON) DoorGoUp();
else if (m_iState == STATE_TURN_OFF) DoorGoDown();
}
else
{
if (m_iState == STATE_TURN_ON) DoorGoDown();
else if (m_iState == STATE_TURN_OFF) DoorGoUp();
}
}
SetNextThink( 0 );
}
LINK_ENTITY_TO_CLASS( func_door, CBaseDoor );
//=======================================================================
// func_door_rotating - classic rotating door
//=======================================================================
void CRotDoor::Spawn( void )
{
CBaseDoor::Spawn();
if ( FBitSet (pev->spawnflags, SF_START_ON) )
{
pev->angles = m_vecAngle2;
Vector vecSav = m_vecAngle1;
m_vecAngle2 = m_vecAngle1;
m_vecAngle1 = vecSav;
pev->movedir = pev->movedir * -1;
}
}
void CRotDoor :: SetToggleState( int state )
{
if ( state == STATE_ON ) pev->angles = m_vecAngle2;
else pev->angles = m_vecAngle1;
UTIL_SetOrigin( this, pev->origin );
}
LINK_ENTITY_TO_CLASS( func_door_rotating, CRotDoor );
//=======================================================================
// func_momentary_door
//=======================================================================
void CMomentaryDoor::Precache( void )
{
if(IsWater()) return;//no need sounds for water
CBaseBrush::Precache();
int m_sounds = UTIL_LoadSoundPreset(m_iMoveSound);
switch (m_sounds)//load pushed sounds (sound will play at activate or pushed button)
{
case 1: pev->noise = UTIL_PrecacheSound ("materials/doors/doormove1.wav");break;
case 2: pev->noise = UTIL_PrecacheSound ("materials/doors/doormove2.wav");break;
case 3: pev->noise = UTIL_PrecacheSound ("materials/doors/doormove3.wav");break;
case 4: pev->noise = UTIL_PrecacheSound ("materials/doors/doormove4.wav");break;
case 5: pev->noise = UTIL_PrecacheSound ("materials/doors/doormove5.wav");break;
case 6: pev->noise = UTIL_PrecacheSound ("materials/doors/doormove6.wav");break;
case 0: pev->noise = UTIL_PrecacheSound ("common/null.wav"); break;
default: pev->noise = UTIL_PrecacheSound(m_sounds); break;//custom sound or sentence
}
m_sounds = UTIL_LoadSoundPreset(m_iStopSound);
switch (m_sounds)//load pushed sounds (sound will play at activate or pushed button)
{
case 1: pev->noise2 = UTIL_PrecacheSound ("materials/doors/doorstop1.wav");break;
case 2: pev->noise2 = UTIL_PrecacheSound ("materials/doors/doorstop2.wav");break;
case 3: pev->noise2 = UTIL_PrecacheSound ("materials/doors/doorstop3.wav");break;
case 4: pev->noise2 = UTIL_PrecacheSound ("materials/doors/doorstop4.wav");break;
case 5: pev->noise2 = UTIL_PrecacheSound ("materials/doors/doorstop5.wav");break;
case 6: pev->noise2 = UTIL_PrecacheSound ("materials/doors/doorstop6.wav");break;
case 7: pev->noise2 = UTIL_PrecacheSound ("materials/doors/doorstop7.wav");break;
case 8: pev->noise2 = UTIL_PrecacheSound ("materials/doors/doorstop8.wav");break;
case 0: pev->noise2 = UTIL_PrecacheSound ("common/null.wav"); break;
default: pev->noise2 = UTIL_PrecacheSound(m_sounds); break;//custom sound or sentence
}
}
void CMomentaryDoor::Spawn( void )
{
Precache();
CBaseBrush::Spawn();
UTIL_LinearVector( this );//movement direction
if(pev->spawnflags & SF_NOTSOLID)pev->solid = SOLID_NOT; //make illusionary wall
else pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
m_iState = STATE_OFF;
UTIL_SetOrigin(this, pev->origin);
UTIL_SetModel( ENT(pev), pev->model );
SetTouch( NULL );//just in case
}
void CMomentaryDoor::PostSpawn( void )
{
if (m_pParent) m_vecPosition1 = pev->origin - m_pParent->pev->origin;
else m_vecPosition1 = pev->origin;
// Subtract 2 from size because the engine expands bboxes by 1 in all directions making the size too big
m_vecPosition2 = m_vecPosition1 + (pev->movedir * (fabs( pev->movedir.x * (pev->size.x-2) ) + fabs( pev->movedir.y * (pev->size.y-2) ) + fabs( pev->movedir.z * (pev->size.z-2) ) - m_flLip));
ASSERTSZ(m_vecPosition1 != m_vecPosition2, "door start/end positions are equal");
if(pev->spawnflags & SF_START_ON)
{
if (m_pParent)
{
m_vecSpawnOffset = m_vecSpawnOffset + (m_vecPosition2 + m_pParent->pev->origin) - pev->origin;
UTIL_AssignOrigin(this, m_vecPosition2 + m_pParent->pev->origin);
}
else
{
m_vecSpawnOffset = m_vecSpawnOffset + m_vecPosition2 - pev->origin;
UTIL_AssignOrigin(this, m_vecPosition2);
}
Vector vecTemp = m_vecPosition2;
m_vecPosition2 = m_vecPosition1;
m_vecPosition1 = vecTemp;
}
}
void CMomentaryDoor::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if (useType == USE_ON) value = 1;
else if(useType == USE_OFF) value = 0;
else if(useType == USE_SET);
else if(useType == USE_SHOWINFO)//show info
{
Msg("======/Xash Debug System/======\n");
Msg("classname: %s\n", STRING(pev->classname));
Msg("State: %s, Lip %.2f\n", GetStringForState( GetState()), m_flLip );
SHIFT;
}
else return;
if ( value > 1.0 )value = 1.0;
if (IsLockedByMaster()) return;
Vector move = m_vecPosition1 + (value * (m_vecPosition2 - m_vecPosition1));
float speed = 0;
Vector delta;
if (pev->speed) speed = pev->speed;
else
{
// default: get there in 0.1 secs
delta = move - pev->origin;
speed = delta.Length() * 10;
}
//FIXME: allow for it being told to move at the same speed in the _opposite_ direction!
if ( speed != 0 )
{
// This entity only thinks when it moves
if ( m_iState == STATE_OFF )
{
//ALERT(at_console,"USE: start moving to %f %f %f.\n", move.x, move.y, move.z);
m_iState = STATE_ON;
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), 1, ATTN_NORM);
}
LinearMove( move, speed );
SetMoveDone( MomentaryMoveDone );
}
}
void CMomentaryDoor::MomentaryMoveDone( void )
{
m_iState = STATE_OFF;
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise));
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise2), 1, ATTN_NORM);
}
LINK_ENTITY_TO_CLASS( func_momentary_door, CMomentaryDoor );
//=======================================================================
// func_platform (a lift\elevator)
//=======================================================================
void CBasePlatform::Precache( void )
{
CBaseBrush::Precache();//precache damage sound
int m_sounds = UTIL_LoadSoundPreset(m_iMoveSound);
switch (m_sounds)//load movesound sounds (sound will play when door is moving)
{
case 1: pev->noise = UTIL_PrecacheSound ("plats/bigmove1.wav");break;
case 2: pev->noise = UTIL_PrecacheSound ("plats/bigmove2.wav");break;
case 3: pev->noise = UTIL_PrecacheSound ("plats/elevmove1.wav");break;
case 4: pev->noise = UTIL_PrecacheSound ("plats/elevmove2.wav");break;
case 5: pev->noise = UTIL_PrecacheSound ("plats/elevmove3.wav");break;
case 6: pev->noise = UTIL_PrecacheSound ("plats/freightmove1.wav");break;
case 7: pev->noise = UTIL_PrecacheSound ("plats/freightmove2.wav");break;
case 8: pev->noise = UTIL_PrecacheSound ("plats/heavymove1.wav");break;
case 9: pev->noise = UTIL_PrecacheSound ("plats/rackmove1.wav");break;
case 10: pev->noise = UTIL_PrecacheSound ("plats/railmove1.wav");break;
case 11: pev->noise = UTIL_PrecacheSound ("plats/squeekmove1.wav");break;
case 12: pev->noise = UTIL_PrecacheSound ("plats/talkmove1.wav");break;
case 13: pev->noise = UTIL_PrecacheSound ("plats/talkmove2.wav");break;
case 0: pev->noise = UTIL_PrecacheSound ("common/null.wav"); break;
default: pev->noise = UTIL_PrecacheSound(m_sounds); break;//custom sound or sentence
}
m_sounds = UTIL_LoadSoundPreset(m_iStopSound);
switch (m_sounds)//load pushed sounds (sound will play at activate or pushed button)
{
case 1: pev->noise1 = UTIL_PrecacheSound ("plats/bigstop1.wav");break;
case 2: pev->noise1 = UTIL_PrecacheSound ("plats/bigstop2.wav");break;
case 3: pev->noise1 = UTIL_PrecacheSound ("plats/freightstop1.wav");break;
case 4: pev->noise1 = UTIL_PrecacheSound ("plats/heavystop2.wav");break;
case 5: pev->noise1 = UTIL_PrecacheSound ("plats/rackstop1.wav");break;
case 6: pev->noise1 = UTIL_PrecacheSound ("plats/railstop1.wav");break;
case 7: pev->noise1 = UTIL_PrecacheSound ("plats/squeekstop1.wav");break;
case 8: pev->noise1 = UTIL_PrecacheSound ("plats/talkstop1.wav");break;
case 0: pev->noise1 = UTIL_PrecacheSound ("common/null.wav"); break;
default: pev->noise1 = UTIL_PrecacheSound(m_sounds); break;//custom sound or sentence
}
UTIL_PrecacheSound( "buttons/button11.wav" );//error sound
}
void CBasePlatform :: Setup( void )
{
Precache(); //precache moving & stop sounds
pev->angles = g_vecZero;
if (IsWater()) pev->solid = SOLID_NOT; // special contents (water, slime, e.t.c. )
else pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(this, pev->origin);
UTIL_SetSize(pev, pev->mins, pev->maxs);
UTIL_SetModel(ENT(pev), pev->model );
// vecPosition1 is the top position, vecPosition2 is the bottom
if (m_pParent) m_vecPosition1 = pev->origin - m_pParent->pev->origin;
else m_vecPosition1 = pev->origin;
m_vecPosition2 = m_vecPosition1;
if(IsMovingPlatform() || IsComplexPlatform())
{
m_vecPosition2.z = m_vecPosition2.z + step();
ASSERTSZ(m_vecPosition1 != m_vecPosition2, "moving platform start/end positions are equal\n");
}
if(IsRotatingPlatform() || IsComplexPlatform())
{
if ( m_flMoveDistance < 0 ) pev->movedir = pev->movedir * -1;
AxisDir();
m_vecAngle1 = pev->angles;
m_vecAngle2 = pev->angles + pev->movedir * m_flMoveDistance;
ASSERTSZ(m_vecAngle1 != m_vecAngle2, "rotating platform start/end positions are equal\n");
SetBits (pFlags, PF_ANGULAR);
}
if (!IsWater())CBaseBrush::Spawn();
if (pev->speed == 0) pev->speed = 150;
m_iState = STATE_OFF;
}
void CBasePlatform :: PostSpawn( void )
{
if ( FBitSet( pev->spawnflags, SF_START_ON ) )
{
if (m_pParent) UTIL_AssignOrigin (this, m_vecPosition2 + m_pParent->pev->origin);
else UTIL_AssignOrigin (this, m_vecPosition2);
UTIL_AssignAngles(this, m_vecAngle2);
m_iState = STATE_ON;
}
else
{
if (m_pParent) UTIL_AssignOrigin (this, m_vecPosition1 + m_pParent->pev->origin);
else UTIL_AssignOrigin (this, m_vecPosition1);
UTIL_AssignAngles(this, m_vecAngle1);
m_iState = STATE_OFF;
}
}
void CBasePlatform :: Spawn( void )
{
Setup();
}
void CBasePlatform :: PostActivate( void )
{
if(m_iState == STATE_TURN_OFF || m_iState == STATE_TURN_ON)//platform "in-moving" ? restore sound!
{
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM);
}
}
void CBasePlatform :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
m_hActivator = pActivator;
if (useType == USE_TOGGLE)
{
if(m_iState == STATE_ON) useType = USE_OFF;
else useType = USE_ON;
}
if (useType == USE_ON)
{
GoUp();
}
else if ( useType == USE_OFF )
{
GoDown();
}
else if ( useType == USE_SET )
{
GoToFloor( value );
}
else if ( useType == USE_RESET )
{
GoToFloor( 1 );
}
else if (useType == USE_SHOWINFO)
{
ALERT( at_console, "======/Xash Debug System/======\n");
ALERT( at_console, "classname: %s\n", STRING(pev->classname));
if( IsWater( )) ALERT( at_console, "Contents: %s, WaveHeight %g\n", GetContentsString( pev->skin ), pev->scale );
else ALERT( at_console, "State: %s, floor %g\n", GetStringForState( GetState( )), CalcFloor( ));
ALERT( at_console, "distance %g, speed %g\n", m_flMoveDistance, pev->speed );
}
}
void CBasePlatform :: GoToFloor( float floor )
{
float curfloor = CalcFloor();
m_flValue = floor;
if(curfloor <= 0) return;
if(curfloor == floor) //already there?
{
//pass trough
UTIL_FireTargets( pev->target, m_hActivator, this, USE_RESET, m_flValue );
return;
}
m_vecFloor = m_vecPosition1;
m_vecFloor.z = pev->origin.z + (floor * step()) - (curfloor * step());
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM);
if(floor > curfloor)m_iState = STATE_TURN_ON;
else m_iState = STATE_TURN_OFF;
SetMoveDone( HitFloor );
if(fabs(floor - curfloor) > 1.0) //create floor informator for prop_counter
{
CBaseEntity *pFloor = CBaseEntity::Create( "floorent", pev->origin, g_vecZero, edict() );
pFloor->pev->target = pev->netname;
pFloor->PostActivate();
}
LinearMove(m_vecFloor, pev->speed);
}
void CBasePlatform :: HitFloor( void )
{
STOP_SOUND(ENT(pev), CHAN_STATIC, STRING( pev->noise ));
EMIT_SOUND(ENT(pev), CHAN_WEAPON, STRING( pev->noise1 ), m_flVolume, ATTN_NORM );
ASSERT( m_iState == STATE_TURN_ON || m_iState == STATE_TURN_OFF );
UTIL_FireTargets( pev->target, m_hActivator, this, USE_TOGGLE, m_flValue );
UTIL_FireTargets( pev->netname, m_hActivator, this, USE_SET, m_flValue );
m_vecPosition2 = pev->origin; // save current floor
if( m_iState == STATE_TURN_ON ) m_iState = STATE_ON;
if( m_iState == STATE_TURN_OFF ) m_iState = STATE_OFF;
}
void CBasePlatform :: GoDown( void )
{
EMIT_SOUND( ENT( pev ), CHAN_STATIC, STRING( pev->noise ), m_flVolume, ATTN_NORM );
ASSERT( m_iState == STATE_ON || m_iState == STATE_TURN_ON );
m_iState = STATE_TURN_OFF;
SetMoveDone( HitBottom );
if ( IsRotatingPlatform( )) AngularMove( m_vecAngle1, pev->speed );
else if ( IsMovingPlatform( )) LinearMove( m_vecPosition1, pev->speed );
else if ( IsComplexPlatform( )) ComplexMove( m_vecPosition1, m_vecAngle1, pev->speed );
else HitBottom(); // don't brake platform status
}
void CBasePlatform :: HitBottom( void )
{
STOP_SOUND(ENT(pev), CHAN_STATIC, STRING( pev->noise ));
EMIT_SOUND(ENT(pev), CHAN_WEAPON, STRING( pev->noise1 ), m_flVolume, ATTN_NORM );
ASSERT( m_iState == STATE_TURN_OFF );
UTIL_FireTargets( pev->netname, m_hActivator, this, USE_SET, 1 );
m_iState = STATE_OFF;
}
void CBasePlatform :: GoUp( void )
{
EMIT_SOUND( ENT( pev ), CHAN_STATIC, STRING( pev->noise ), m_flVolume, ATTN_NORM );
ASSERT( m_iState == STATE_OFF || m_iState == STATE_TURN_OFF );
m_iState = STATE_TURN_ON;
SetMoveDone( HitTop );
if ( IsRotatingPlatform( )) AngularMove( m_vecAngle2, pev->speed );
else if ( IsMovingPlatform( )) LinearMove( m_vecPosition2, pev->speed );
else if ( IsComplexPlatform( )) ComplexMove( m_vecPosition2, m_vecAngle2, pev->speed );
else HitTop(); // don't brake platform status
}
void CBasePlatform :: HitTop( void )
{
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise));
EMIT_SOUND(ENT(pev), CHAN_WEAPON, (char*)STRING(pev->noise1), m_flVolume, ATTN_NORM);
ASSERT(m_iState == STATE_TURN_ON);
UTIL_FireTargets( pev->netname, m_hActivator, this, USE_SET, 2 );
m_iState = STATE_ON;
}
void CBasePlatform :: Blocked( CBaseEntity *pOther )
{
UTIL_AssignOrigin(this, pev->origin);
//make delay before retouching
if ( gpGlobals->time < m_flBlockedTime) return;
m_flBlockedTime = gpGlobals->time + 0.5;
if(m_pParent && m_pParent->edict() && pFlags & PF_PARENTMOVE) m_pParent->Blocked( pOther);
pOther->TakeDamage( pev, pev, 1, DMG_CRUSH );
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise));
ASSERT(m_iState == STATE_TURN_ON || m_iState == STATE_TURN_OFF);
if ( m_iState == STATE_TURN_ON ) GoDown();
else if ( m_iState == STATE_TURN_OFF ) GoUp();
SetNextThink( 0 );
}
LINK_ENTITY_TO_CLASS( func_water, CBasePlatform );
LINK_ENTITY_TO_CLASS( func_platform, CBasePlatform );
LINK_ENTITY_TO_CLASS( func_platform_rotating, CBasePlatform );
//=======================================================================
// func_train (Classic QUAKE Train)
//=======================================================================
TYPEDESCRIPTION CFuncTrain::m_SaveData[] =
{
DEFINE_FIELD( CFuncTrain, pPath, FIELD_CLASSPTR ),
DEFINE_FIELD( CFuncTrain, pNextPath, FIELD_CLASSPTR ),
};
IMPLEMENT_SAVERESTORE( CFuncTrain, CBasePlatform );
void CFuncTrain :: Spawn( void )
{
Precache(); // precache moving & stop sounds
if(pev->spawnflags & SF_NOTSOLID)//make illusionary train
{
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE;
}
else
{
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
}
UTIL_SetOrigin( this, pev->origin );
UTIL_SetSize( pev, pev->mins, pev->maxs );
UTIL_SetModel( ENT(pev), pev->model );
CBaseBrush::Spawn();
// determine method for calculating origin
if( pev->origin != g_vecZero ) pev->impulse = 1;
if (pev->speed == 0) pev->speed = 100;
m_iState = STATE_OFF;
}
void CFuncTrain :: PostSpawn( void )
{
if (!FindPath()) return;
if ( pev->impulse )
{
m_vecSpawnOffset = m_vecSpawnOffset + pPath->pev->origin - pev->origin;
if (m_pParent) UTIL_AssignOrigin (this, pPath->pev->origin - m_pParent->pev->origin );
else UTIL_AssignOrigin (this, pPath->pev->origin );
}
else
{
m_vecSpawnOffset = m_vecSpawnOffset + (pPath->pev->origin - TrainOrg()) - pev->origin;
if ( m_pParent ) UTIL_AssignOrigin (this, pPath->pev->origin - TrainOrg() - m_pParent->pev->origin );
else UTIL_AssignOrigin (this, pPath->pev->origin - TrainOrg());
}
}
void CFuncTrain :: PostActivate( void )
{
if ( m_iState == STATE_ON ) // platform "in-moving" ? restore sound!
{
EMIT_SOUND (ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM);
}
if ( pev->spawnflags & SF_START_ON )
{
m_iState = STATE_OFF; // restore sound on a next level
SetThink( Next ); // evil stuff...
SetNextThink( 0.1 );
ClearBits( pev->spawnflags, SF_START_ON );//fire once
}
}
BOOL CFuncTrain::FindPath( void )
{
// find start track
pPath = UTIL_FindEntityByTargetname (NULL, STRING( pev->target ));
if( pPath && pPath->edict( ))
return TRUE;
return FALSE;
}
BOOL CFuncTrain::FindNextPath( void )
{
if( !pPath )
{
ALERT( at_error, "CFuncTrain::FindNextpath failed\n" );
return FALSE;
}
// get pointer to next target
if( pev->speed > 0 ) pNextPath = ((CInfoPath *)pPath)->GetNext();
if( pev->speed < 0 ) pNextPath = ((CInfoPath *)pPath)->GetPrev();
if( pNextPath && pNextPath->edict( )) // validate path
{
// record new value (this will be used after changelevel)
pev->target = pNextPath->pev->targetname;
return TRUE; // path found
}
switch ( m_iMode )
{
case 1: UpdateSpeed(); break;
case 2: UpdateSpeed();
default: Stop(); break;
}
return FALSE;
}
void CFuncTrain::UpdateSpeed( float value )
{
// update path if dir changed
if(( value > 0 && pev->speed < 0 ) || ( value < 0 && pev->speed > 0 ) || value == 0 )
{
if( pNextPath && pNextPath->edict( ))
pPath = pNextPath;
}
if( value != 0 ) pev->speed = value; // get new speed
else pev->speed = -pev->speed;
if( m_iState == STATE_ON ) Next(); // re-calculate speed now!
}
void CFuncTrain::ClearPointers( void )
{
CBaseEntity::ClearPointers();
pPath = NULL;
pNextPath = NULL;
}
void CFuncTrain::OverrideReset( void )
{
// Are we moving?
if ( m_iState == STATE_ON )
{
if ( FindPath( )) SetBits( pev->spawnflags, SF_START_ON ); // PostActivate member
else Stop();
}
}
void CFuncTrain :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
m_hActivator = pActivator;
if ( useType == USE_TOGGLE )
{
if( m_iState == STATE_ON )
useType = USE_OFF;
else useType = USE_ON;
}
if ( useType == USE_ON ) Next();
else if ( useType == USE_OFF ) Stop();
else if ( useType == USE_SET )
{
UpdateSpeed( value ); // set new speed
}
else if ( useType == USE_RESET )
{
UTIL_FireTargets( pev->netname, pActivator, pCaller, USE_TOGGLE ); // just fire
}
else if ( useType == USE_SHOWINFO )
{
DEBUGHEAD;
ALERT( at_console, "State: %s, speed %g\n", GetStringForState( GetState( )), pev->speed );
if( GetPrev() && GetPrev()->edict( )) ALERT( at_console, "Prev path %s", STRING( GetPrev()->pev->targetname ));
if( GetNext() && GetNext()->edict( )) ALERT( at_console, "Next path %s", STRING( GetNext()->pev->targetname ));
ALERT( at_console, "\n" );
}
}
void CFuncTrain :: Next( void )
{
if( !FindNextPath( )) return;
// linear move to next corner.
if ( m_iState == STATE_OFF ) // enable train sound
{
STOP_SOUND( edict(), CHAN_STATIC, STRING( pev->noise ));
EMIT_SOUND( edict(), CHAN_STATIC, STRING( pev->noise ), m_flVolume, ATTN_NORM );
}
ClearBits( pev->effects, EF_NOINTERP ); // enable interpolation
m_iState = STATE_ON;
if( pev->speed < 0 && FBitSet( pNextPath->pev->spawnflags, SF_CORNER_TELEPORT ))
{
SetBits( pev->effects, EF_NOINTERP );
if ( m_pParent ) UTIL_AssignOrigin( this, pNextPath->pev->origin - m_pParent->pev->origin );
else UTIL_AssignOrigin( this, pNextPath->pev->origin );
Wait(); // Get on with doing the next path corner.
return;
}
if ( m_pParent )
{
if ( pev->impulse ) LinearMove( pNextPath->pev->origin - m_pParent->pev->origin, fabs( pev->speed ));
else LinearMove ( pNextPath->pev->origin - TrainOrg() - m_pParent->pev->origin, fabs( pev->speed ));
}
else
{
if ( pev->impulse ) LinearMove( pNextPath->pev->origin, fabs( pev->speed ));
else LinearMove ( pNextPath->pev->origin - TrainOrg(), fabs( pev->speed ));
}
SetMoveDone( Wait );
}
BOOL CFuncTrain :: Teleport( void )
{
if( !FindNextPath( ))
return FALSE;
if( FBitSet( pNextPath->pev->spawnflags, SF_CORNER_TELEPORT ))
{
SetBits( pev->effects, EF_NOINTERP );
// determine teleportation point
if( pev->speed > 0 )
{
pNextPath = pNextPath->GetNext();
UpdateTargets();
}
if( !pNextPath || !pNextPath->edict() )
return FALSE; // dead end
if ( m_pParent )
UTIL_AssignOrigin(this, pNextPath->pev->origin - m_pParent->pev->origin );
else UTIL_AssignOrigin(this, pNextPath->pev->origin );
pPath = pNextPath;
Next(); // Get on with doing the next path corner.
return TRUE;
}
return FALSE;
}
void CFuncTrain :: Wait( void )
{
UpdateTargets();
if(Teleport( )) return;
if( pNextPath )
{
pPath = pNextPath;//move pointer
((CInfoPath *)pPath)->GetSpeed( &pev->speed );
if(!Stop(((CInfoPath *)pPath)->GetDelay())) Next(); // go to next corner
}
else Stop();
}
void CFuncTrain :: UpdateTargets( void )
{
// fire the pass target if there is one
if( !pNextPath || !pNextPath->edict() ) return;
UTIL_FireTargets( pNextPath->pev->message, this, this, USE_TOGGLE );
if ( FBitSet( pNextPath->pev->spawnflags, SF_CORNER_FIREONCE ))
pNextPath->pev->message = iStringNull;
UTIL_FireTargets( pev->netname, this, this, USE_TOGGLE );
}
BOOL CFuncTrain :: Stop( float flWait )
{
if( flWait == 0 ) return FALSE;
m_iState = STATE_OFF;
if( pPath && pPath->edict() )
{
UTIL_FireTargets( pPath->pev->message, this, this, USE_TOGGLE );
if ( FBitSet( pPath->pev->spawnflags, SF_CORNER_FIREONCE ))
pPath->pev->message = iStringNull;
UTIL_FireTargets( pev->netname, this, this, USE_TOGGLE );
}
// clear the sound channel.
STOP_SOUND( edict(), CHAN_STATIC, STRING( pev->noise ));
EMIT_SOUND( edict(), CHAN_VOICE, STRING( pev->noise1 ), m_flVolume, ATTN_NORM );
UTIL_SetVelocity( this, g_vecZero );
UTIL_SetAvelocity( this, g_vecZero );
if( flWait > 0 )
{
SetNextThink( flWait );
SetThink( Next );
}
else if( flWait == -1 ) DontThink(); // wait for retrigger
return TRUE;
}
void CFuncTrain :: Blocked( CBaseEntity *pOther )
{
// Keep "movewith" entities in line
UTIL_AssignOrigin(this, pev->origin);
if ( gpGlobals->time < m_flBlockedTime) return;
m_flBlockedTime = gpGlobals->time + 0.5;
if( m_pParent && m_pParent->edict() && pFlags & PF_PARENTMOVE )
m_pParent->Blocked( pOther );
pOther->TakeDamage( pev, pev, 1, DMG_CRUSH );
STOP_SOUND( edict(), CHAN_STATIC, STRING( pev->noise ));
ASSERT(m_iState == STATE_ON);
Stop( 0.5 );
}
LINK_ENTITY_TO_CLASS( func_train, CFuncTrain ); | [
"[email protected]"
]
| [
[
[
1,
1399
]
]
]
|
44d0dcc709ad89963c31dd9ccbcdf17c47d0d9ff | 57574cc7192ea8564bd630dbc2a1f1c4806e4e69 | /Poker/Cliente/Jugador.h | be578b48a3e922433c2b44245ade1b758654fa1f | []
| no_license | natlehmann/taller-2010-2c-poker | 3c6821faacccd5afa526b36026b2b153a2e471f9 | d07384873b3705d1cd37448a65b04b4105060f19 | refs/heads/master | 2016-09-05T23:43:54.272182 | 2010-11-17T11:48:00 | 2010-11-17T11:48:00 | 32,321,142 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,040 | h | #ifndef _JUGADOR_H__
#define _JUGADOR_H__
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string.h>
#include "ElementoGrafico.h"
#include "Imagen.h"
#include "Carta.h"
#include "Apuesta.h"
#include "Etiqueta.h"
#include "ImagenRecortada.h"
#define ALTO_MIN_ETIQUETA 0.25
#define ANCHO_MIN_CARTAS 0.3
#define SEPARACION_ENTRE_CARTAS 1
#define SEPARACION_CARTAS_APUESTA 5
#define ALTO_MAXIMO_ETIQUETA 20
#define ANCHO_CARTA_PROPORCIONAL 0.65
#define ALTO_CARTA_PROPORCIONAL 0.85
#define JUGADOR_AUSENTE 0
#define JUGADOR_ACTIVO 1
#define JUGADOR_INACTIVO 2
class Jugador : public ElementoGrafico {
private:
string nombre;
int fichas;
int estado;
Carta* carta1;
Carta* carta2;
Apuesta* apuesta;
Etiqueta* etiquetaNombre;
Etiqueta* etiquetaFichas;
bool dealer;
Imagen* imagenDealer;
Color* colorCirculo;
SDL_Surface* supImagen;
ImagenRecortada* supCirculo;
void setearDisposicionAIzq();
void setearDisposicionADer();
SDL_Rect* calcularRectFoto();
Imagen* getImagenDefault();
void calcularCoordenadas();
void configurar();
void dibujarJugador(SDL_Surface* superficie);
protected:
Imagen* imagen;
virtual void dibujarSobreSup(SDL_Surface* superficie);
public:
Jugador(void);
virtual ~Jugador(void);
string getNombre();
void setNombre(string nombre);
Imagen* getImagen();
void setImagen(string nombreImagen);
void setCarta1(Carta* carta);
void setCarta2(Carta* carta);
Carta* getCarta1();
Carta* getCarta2();
/**
* Setea alguna carta (la 1 o la 2) dependiendo de cual no haya sido seteada previamente.
* Si ambas cartas ya fueron seteadas, lanza una excepcion.
*/
void setCarta(Carta* carta);
void setApuesta(string cantidad);
Apuesta* getApuesta();
void setFichas(int cantidad);
int getFichas();
int getEstado();
void setEstado(int estado);
bool isDealer();
void setDealer(bool esDealer);
ElementoGrafico* getElementoPorId(string id);
};
#endif //_JUGADOR_H__
| [
"[email protected]@a9434d28-8610-e991-b0d0-89a272e3a296",
"marianofl85@a9434d28-8610-e991-b0d0-89a272e3a296",
"pablooddo@a9434d28-8610-e991-b0d0-89a272e3a296"
]
| [
[
[
1,
12
],
[
14,
19
],
[
22,
31
],
[
33,
35
],
[
37,
37
],
[
39,
78
],
[
84,
94
]
],
[
[
13,
13
],
[
20,
20
],
[
32,
32
],
[
36,
36
],
[
38,
38
],
[
79,
83
]
],
[
[
21,
21
]
]
]
|
94c3afa6260c842d3294b16648ef41b3f80a51cb | 36bf908bb8423598bda91bd63c4bcbc02db67a9d | /WallPaper/include/WallPaperCrawlerSettingsProxyDlg.h | 8850a347d7e0d32b8eaf66359a53e43a7554f32f | []
| no_license | code4bones/crawlpaper | edbae18a8b099814a1eed5453607a2d66142b496 | f218be1947a9791b2438b438362bc66c0a505f99 | refs/heads/master | 2021-01-10T13:11:23.176481 | 2011-04-14T11:04:17 | 2011-04-14T11:04:17 | 44,686,513 | 0 | 1 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 3,044 | h | /*
WallPaperCrawlerSettingsProxyDlg.h
Dialogo per la pagina relativa alle opzioni per il crawler.
Luca Piergentili, 20/09/01
[email protected]
WallPaper (alias crawlpaper) - the hardcore of Windows desktop
http://www.crawlpaper.com/
copyright © 1998-2004 Luca Piergentili, all rights reserved
crawlpaper is a registered name, all rights reserved
This is a free software, released under the terms of the BSD license. Do not
attempt to use it in any form which violates the license or you will be persecuted
and charged for this.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
- Neither the name of "crawlpaper" nor the names of its contributors may be used
to endorse or promote products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _WALLPAPERCRAWLERSETTINGSPROXYDLG_H
#define _WALLPAPERCRAWLERSETTINGSPROXYDLG_H
#include "window.h"
#include "CToolTipCtrlEx.h"
#include "WallPaperConfig.h"
/*
CWallPaperCrawlerSettingsProxyDlg
*/
class CWallPaperCrawlerSettingsProxyDlg : public CPropertyPage
{
DECLARE_DYNCREATE(CWallPaperCrawlerSettingsProxyDlg)
public:
CWallPaperCrawlerSettingsProxyDlg() {}
~CWallPaperCrawlerSettingsProxyDlg() {}
BOOL CreateEx (CWnd* pParent,UINT nID,CWallPaperConfig* pConfig);
void DoDataExchange (CDataExchange* pDX);
BOOL OnInitDialog (void);
BOOL OnSetActive (void) {return(TRUE);}
void OnCheckUseProxy (void);
CToolTipCtrlEx m_Tooltip;
CToolTipList m_TooltipList;
CWallPaperConfig* m_pConfig;
CString m_strProxyAddress;
UINT m_nProxyPort;
CString m_strProxyUser;
CString m_strProxyPassword;
CString m_strProxyExcludeDomains;
BOOL m_bUseProxy;
DECLARE_MESSAGE_MAP()
};
#endif // _WALLPAPERCRAWLERSETTINGSPROXYDLG_H
| [
"[email protected]"
]
| [
[
[
1,
79
]
]
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.