text stringlengths 1 24.5M |
|---|
#pragma once
#include "CNodeBase.h"
class CNodeFloat : public CNodeBase {
public:
CNodeFloat( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( float ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeFunction.h"
static SCINTILLA_COLORS s_rgbSyntaxAsm[] = {
{ SCE_ASM_COMMENT, RGB_GREEN },
{ SCE_ASM_NUMBER, RGB_DARKYELLOW },
{ SCE_ASM_STRING, RGB_ORANGE },
{ SCE_ASM_REGISTER, RGB_LIGHTRED },
{ SCE_ASM_DIRECTIVE, RGB_MAGENTA },
{ SCE_ASM_OPERATOR, RGB_BL... |
#pragma once
#include "CNodeBase.h"
#include "CScintillaEdit.h"
#include "CClassView.h"
class CNodeFunction : public CNodeBase {
public:
CNodeFunction( );
~CNodeFunction( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return m_dwMemorySize; }
virtual NODESIZE Dr... |
#include "stdafx.h"
#include "CNodeFunctionPtr.h"
static SCINTILLA_COLORS s_rgbSyntaxAsm[] = {
{ SCE_ASM_COMMENT, RGB_GREEN },
{ SCE_ASM_NUMBER, RGB_DARKYELLOW },
{ SCE_ASM_STRING, RGB_ORANGE },
{ SCE_ASM_REGISTER, RGB_LIGHTRED },
{ SCE_ASM_DIRECTIVE, RGB_MAGENTA },
{ SCE_ASM_OPERATOR, RGB... |
#pragma once
#include "CNodeBase.h"
#include "CScintillaEdit.h"
class CNodeFunctionPtr : public CNodeBase {
public:
CNodeFunctionPtr( );
CNodeFunctionPtr( CWnd* pParentWindow, ULONG_PTR Address );
~CNodeFunctionPtr( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { ... |
#include "stdafx.h"
#include "CNodeHex16.h"
CNodeHex16::CNodeHex16( )
{
m_nodeType = nt_hex16;
}
void CNodeHex16::Update( const PHOTSPOT Spot )
{
StandardUpdate( Spot );
unsigned char v = (unsigned char)(_tcstoul( Spot->Text.GetString( ), NULL, 16 ) & 0xFF);
if (Spot->Id == 0)
ReClassWriteMemo... |
#pragma once
#include "CNodeBase.h"
class CNodeHex16 : public CNodeBase {
public:
CNodeHex16( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( __int16 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeHex32.h"
CNodeHex32::CNodeHex32( )
{
m_nodeType = nt_hex32;
}
void CNodeHex32::Update( const PHOTSPOT Spot )
{
StandardUpdate( Spot );
unsigned char v = (unsigned char)(_tcstoul( Spot->Text.GetString( ), NULL, 16 ) & 0xFF);
if (Spot->Id >= 0 && Spot->Id < 4)
... |
#pragma once
#include "CNodeBase.h"
class CNodeHex32 : public CNodeBase {
public:
CNodeHex32( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( __int32 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeHex64.h"
CNodeHex64::CNodeHex64( )
{
m_nodeType = nt_hex64;
}
void CNodeHex64::Update( const PHOTSPOT Spot )
{
StandardUpdate( Spot );
unsigned char v = (unsigned char)(_tcstoul( Spot->Text.GetString( ), NULL, 16 ) & 0xFF);
if (Spot->Id >= 0 && Spot->Id < 8)
... |
#pragma once
#include "CNodeBase.h"
class CNodeHex64 : public CNodeBase {
public:
CNodeHex64( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( __int64 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
};
|
#include "stdafx.h"
#include "CNodeHex8.h"
CNodeHex8::CNodeHex8( )
{
m_nodeType = nt_hex8;
}
void CNodeHex8::Update( const PHOTSPOT Spot )
{
StandardUpdate( Spot );
unsigned char v = (unsigned char)(_tcstoul( Spot->Text.GetString( ), NULL, 16 ) & 0xFF);
if (Spot->Id == 0)
ReClassWriteMemory( (... |
#pragma once
#include "CNodeBase.h"
class CNodeHex8 : public CNodeBase {
public:
CNodeHex8( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( __int8 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeIcon.h"
NODESIZE CNodeIcon::Draw( const PVIEWINFO View, int x, int y )
{
NODESIZE DrawSize;
for (UINT i = 0; i < 21; i++)
x = AddIcon( View, x, y, i, -1, -1 );
DrawSize.x = x;
DrawSize.y = y + g_FontHeight;
return DrawSize;
}
|
#pragma once
#include "CNodeBase.h"
class CNodeIcon : public CNodeBase {
public:
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
};
|
#include "stdafx.h"
#include "CNodeInt16.h"
CNodeInt16::CNodeInt16( )
{
m_nodeType = nt_int16;
}
void CNodeInt16::Update( const PHOTSPOT Spot )
{
__int16 Int16Value;
StandardUpdate( Spot );
Int16Value = _ttoi( Spot->Text.GetString( ) );
if (Spot->Id == 0)
ReClassWriteMemory( (LPVOID)Spot... |
#pragma once
#include "CNodeBase.h"
class CNodeInt16 : public CNodeBase {
public:
CNodeInt16( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( __int16 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeInt32.h"
CNodeInt32::CNodeInt32( )
{
m_nodeType = nt_int32;
}
void CNodeInt32::Update( const PHOTSPOT Spot )
{
__int32 Int32Value;
StandardUpdate( Spot );
Int32Value = _ttoi( Spot->Text.GetString( ) );
if (Spot->Id == 0)
ReClassWriteMemory( (LPVOID)Spot... |
#pragma once
#include "CNodeBase.h"
class CNodeInt32 : public CNodeBase {
public:
CNodeInt32( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( __int32 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeInt64.h"
CNodeInt64::CNodeInt64( )
{
m_nodeType = nt_int64;
}
void CNodeInt64::Update( const PHOTSPOT Spot )
{
__int64 Int64Value;
StandardUpdate( Spot );
Int64Value = _ttoi64( Spot->Text.GetString( ) );
if (Spot->Id == 0)
ReClassWriteMemory( (LPVOID)Sp... |
#pragma once
#include "CNodeBase.h"
class CNodeInt64 : public CNodeBase {
public:
CNodeInt64( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( __int64 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeInt8.h"
CNodeInt8::CNodeInt8( )
{
m_nodeType = nt_int8;
}
void CNodeInt8::Update( const PHOTSPOT Spot )
{
__int8 Int8Value;
StandardUpdate( Spot );
Int8Value = _ttoi( Spot->Text.GetString( ) );
if (Spot->Id == 0)
ReClassWriteMemory( (LPVOID)Spot->Addres... |
#pragma once
#include "CNodeBase.h"
class CNodeInt8 : public CNodeBase {
public:
CNodeInt8( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( __int8 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeMatrix.h"
CNodeMatrix::CNodeMatrix( )
{
m_nodeType = nt_matrix;
}
void CNodeMatrix::Update( const PHOTSPOT Spot )
{
float FloatValue;
StandardUpdate( Spot );
if (Spot->Id < 16)
{
FloatValue = (float)_ttof( Spot->Text.GetString( ) );
ReClassWrite... |
#pragma once
class CNodeMatrix : public CNodeBase {
public:
CNodeMatrix( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return 4 * 4 * sizeof( float ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodePtr.h"
CNodePtr::CNodePtr( )
: m_pClassNode( NULL )
{
m_nodeType = nt_pointer;
}
void CNodePtr::Update( const PHOTSPOT Spot )
{
StandardUpdate( Spot );
}
NODESIZE CNodePtr::Draw( const PVIEWINFO View, int x, int y )
{
NODESIZE DrawSize;
NODESIZE ChildDrawSize;
... |
#pragma once
#include "CNodeBase.h"
#include "CMemory.h"
class CNodePtr : public CNodeBase {
public:
CNodePtr( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( void* ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
inline void SetC... |
#include "stdafx.h"
#include "CNodePtrArray.h"
CNodePtrArray::CNodePtrArray( )
: m_ulPtrCount( 1 )
, m_iCurrentIndex( 0 )
, m_pNodePtr( new CNodePtr )
{
m_nodeType = nt_ptrarray;
}
NODESIZE CNodePtrArray::Draw( const PVIEWINFO View, int x, int y )
{
int tx;
NODESIZE DrawSize;
NODESIZE Chil... |
#pragma once
#include "CNodeBase.h"
class CNodePtrArray : public CNodeBase {
public:
CNodePtrArray( );
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
virtual ULONG GetMemorySize( );
virtual void Update( const PHOTSPOT Spot );
inline ULONG Count( void ) { return m_ulPtrCount; }
... |
#include "stdafx.h"
#include "CNodeQuat.h"
CNodeQuat::CNodeQuat( )
{
m_nodeType = nt_quat;
for (UINT i = 0; i < m_LevelsOpen.size( ); i++)
m_LevelsOpen[i] = true;
}
void CNodeQuat::Update( const PHOTSPOT Spot )
{
float FloatValue;
StandardUpdate( Spot );
FloatValue = (float)_ttof( Spot->... |
#pragma once
#include "CNodeBase.h"
class CNodeQuat : public CNodeBase {
public:
CNodeQuat( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( float ) * 4; }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeQword.h"
CNodeQword::CNodeQword( )
{
m_nodeType = nt_uint64;
}
void CNodeQword::Update( const PHOTSPOT Spot )
{
UINT64 Uint64Value;
StandardUpdate( Spot );
Uint64Value = _tcstoull( Spot->Text.GetString( ), NULL, g_bUnsignedHex ? 16 : 10 );
if (Spot->Id == 0)
... |
#pragma once
#include "CNodeBase.h"
class CNodeQword : public CNodeBase {
public:
CNodeQword( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( UINT64 ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeText.h"
CNodeText::CNodeText( )
{
m_nodeType = nt_text;
m_strName = _T( "Text" );
m_dwMemorySize = 16;
}
void CNodeText::Update( const PHOTSPOT Spot )
{
SIZE_T Length;
StandardUpdate( Spot );
if (Spot->Id == 0)
{
m_dwMemorySize = _ttoi( Spot->Te... |
#pragma once
#include "CNodeBase.h"
class CNodeText : public CNodeBase {
public:
CNodeText( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return m_dwMemorySize; }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
inline void SetSize( DWORD size ) { ... |
#include "stdafx.h"
#include "CNodeUnicode.h"
CNodeUnicode::CNodeUnicode( )
{
m_nodeType = nt_unicode;
m_strName = _T( "Unicode" );
m_dwMemorySize = 8 * sizeof( wchar_t );
}
void CNodeUnicode::Update( const PHOTSPOT Spot )
{
LPCTSTR SourceString;
wchar_t* ConvertedString;
SIZE_T Length;
S... |
#pragma once
#include "CNodeBase.h"
class CNodeUnicode : public CNodeBase
{
public:
CNodeUnicode( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( void ) { return m_dwMemorySize; }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
inline void S... |
#include "stdafx.h"
#include "CNodeVec2.h"
CNodeVec2::CNodeVec2( )
{
m_nodeType = nt_vec2;
for (size_t i = 0; i < m_LevelsOpen.size( ); i++)
m_LevelsOpen[i] = true;
}
void CNodeVec2::Update( const PHOTSPOT Spot )
{
float FloatValue;
StandardUpdate( Spot );
FloatValue = (float)_ttof( Spot... |
#pragma once
#include "CNodeBase.h"
class CNodeVec2 : public CNodeBase {
public:
CNodeVec2( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( float ) * 2; }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeVec3.h"
CNodeVec3::CNodeVec3( )
{
m_nodeType = nt_vec3;
for (size_t i = 0; i < m_LevelsOpen.size( ); i++)
m_LevelsOpen[i] = true;
}
void CNodeVec3::Update( const PHOTSPOT Spot )
{
float FloatValue;
StandardUpdate( Spot );
FloatValue = (float)_ttof( Spot->Text.GetStrin... |
#pragma once
#include "CNodeBase.h"
class CNodeVec3 : public CNodeBase {
public:
CNodeVec3( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( float ) * 3; }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CNodeVTable.h"
CNodeVTable::CNodeVTable( )
: m_pParentWindow( nullptr )
{
m_nodeType = nt_vtable;
}
CNodeVTable::CNodeVTable( CWnd* pParentWindow )
: CNodeVTable( )
{
m_pParentWindow = pParentWindow;
}
void CNodeVTable::Update( const PHOTSPOT Spot )
{
StandardUpdate(... |
#pragma once
#include "CNodeBase.h"
#include "CMemory.h"
class CNodeVTable : public CNodeBase {
public:
CNodeVTable( );
CNodeVTable( CWnd* pParentWindow );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( void* ); }
virtual NODESIZE Draw( const PVIEWIN... |
#include "stdafx.h"
#include "CNodeWCharPtr.h"
CNodeWCharPtr::CNodeWCharPtr( )
{
m_nodeType = nt_pwchar;
m_strName = "PWChar";
}
void CNodeWCharPtr::Update( const PHOTSPOT Spot )
{
uintptr_t PointerValue;
StandardUpdate( Spot );
PointerValue = (uintptr_t)_ttoi64( Spot->Text.GetString( ) );
i... |
#pragma once
#include "CNodeBase.h"
#include "CMemory.h"
class CNodeWCharPtr : public CNodeBase {
public:
CNodeWCharPtr( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( void* ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
public:
... |
#include "stdafx.h"
#include "CNodeWord.h"
CNodeWord::CNodeWord( )
{
m_nodeType = nt_uint16;
}
void CNodeWord::Update( const PHOTSPOT Spot )
{
WORD Uint16Value;
StandardUpdate( Spot );
Uint16Value = (WORD)_tcstoul( Spot->Text.GetString( ), NULL, g_bUnsignedHex ? 16 : 10 );
if (Spot->Id == 0)
... |
#pragma once
#include "CNodeBase.h"
class CNodeWord : public CNodeBase {
public:
CNodeWord( );
virtual void Update( const PHOTSPOT Spot );
virtual ULONG GetMemorySize( ) { return sizeof( WORD ); }
virtual NODESIZE Draw( const PVIEWINFO View, int x, int y );
}; |
#include "stdafx.h"
#include "CProgressBar.h"
IMPLEMENT_DYNCREATE( CProgressBar, CProgressCtrl )
BEGIN_MESSAGE_MAP( CProgressBar, CProgressCtrl )
ON_WM_ERASEBKGND( )
END_MESSAGE_MAP( )
CProgressBar::CProgressBar( ) :
m_pStatusBar( NULL )
{
m_Rect.SetRect( 0, 0, 0, 0 );
}
CProgressBar::CProgressBar( LPC... |
#pragma once
#include <afxwin.h>
class CProgressBar : public CProgressCtrl
{
public:
CProgressBar( );
CProgressBar( LPCTSTR strMessage, int nSize = 100, int MaxValue = 100,
BOOL bSmooth = FALSE, int nPane = 0, CStatusBar* pBar = NULL );
~CProgressBar( );
BOOL Create( LPCTSTR strMessage, int nS... |
#include "stdafx.h"
#include "CScintillaEdit.h"
CScintillaEdit::CScintillaEdit( ) :
m_pSciMsg( NULL ),
m_pSciWndData( NULL )
{
}
BOOL CScintillaEdit::Create( DWORD dwStyle, const RECT & rect, CWnd * pParentWnd, UINT nID )
{
CWnd* pWnd = this;
BOOL ret = FALSE;
ret = pWnd->Create( _T( "Scintilla"... |
#pragma once
#include "afxwin.h"
// Scintilla Colors structure
typedef struct _SCINTILLA_COLORS {
int iItem;
COLORREF rgb;
} SCINTILLA_COLORS, *PSCINTILLA_COLORS;
class CScintillaEdit : public CWnd {
public:
CScintillaEdit( );
virtual ~CScintillaEdit( );
BOOL Create( DWORD dwStyle, const RECT& r... |
#pragma once
#pragma warning(disable : 4996)
#ifdef __cplusplus
extern "C" {
#endif
//
// For demangling rtti names
//
// UnDecorateSymbolName Flags
//
#ifndef UNDNAME_COMPLETE
#define UNDNAME_COMPLETE (0x0000) // Enable full undecoration
#endif
#ifndef UNDNAME_NO_LEADING_UNDERSCORES
#define UNDNAME... |
#include "stdafx.h"
#include "DialogAbout.h"
// For Utils::GetVersionInfo
#pragma comment(lib, "version.lib")
CDialogAbout::CDialogAbout( ) : CDialogEx( CDialogAbout::IDD )
{
}
BEGIN_MESSAGE_MAP( CDialogAbout, CDialogEx )
END_MESSAGE_MAP( )
void CDialogAbout::DoDataExchange( CDataExchange * pDX )
{
CDialogEx::D... |
#pragma once
#include "afxwin.h"
// CAboutDlg dialog used for App About
class CDialogAbout : public CDialogEx {
public:
CDialogAbout( );
enum { IDD = IDD_ABOUTBOX }; // Dialog Data
protected: // DDX/DDV support
virtual void DoDataExchange( CDataExchange* pDX );
virtual BOOL OnInitDialog( );
DECL... |
#include "stdafx.h"
#include "ReClassEx.h"
#include "DialogClasses.h"
#include "CMainFrame.h"
#include "CClassFrame.h"
#include "afxdialogex.h"
IMPLEMENT_DYNAMIC( CDialogClasses, CDialogEx )
CDialogClasses::CDialogClasses( CWnd* pParent ) : CDialogEx( CDialogClasses::IDD, pParent )
{
}
CDialogClasses::~CDialogClas... |
#pragma once
#include "afxwin.h"
class CDialogClasses : public CDialogEx {
DECLARE_DYNAMIC( CDialogClasses )
public:
CDialogClasses( CWnd* pParent = NULL );
virtual ~CDialogClasses( );
enum { IDD = IDD_DIALOG_CLASSES };
protected:
virtual void DoDataExchange( CDataExchange* pDX );
DECLARE_M... |
// DialogConsole.cpp : implementation file
//
#include "stdafx.h"
#include "DialogConsole.h"
#include "ReClassEx.h"
#include "afxdialogex.h"
// Console keywords
static const char g_ConsoleKeyWords[] =
// Standard
"asm auto bool break case catch char class const "
"const_cast continue default delete do double "
"dyna... |
#pragma once
#include "afxwin.h"
#include "Resource.h"
#include "CScintillaEdit.h"
// CDialogConsole dialog
class CDialogConsole : public CDialogEx {
DECLARE_DYNAMIC( CDialogConsole )
public:
CDialogConsole( CString WindowTitle, CWnd* pParent = NULL ); // standard constructor
virtual ~CDialogConsole( ... |
// DialogEdit.cpp : implementation file
//
#include "stdafx.h"
#include "ReClassEx.h"
#include "DialogEdit.h"
#include "afxdialogex.h"
// C++ keywords
static const char g_cppKeyWords[] =
// Standard
"asm auto bool break case catch char class const "
"const_cast continue default delete do double "
"dy... |
#pragma once
#include "afxwin.h"
#include "CScintillaEdit.h"
class CDialogEdit : public CDialogEx {
DECLARE_DYNAMIC( CDialogEdit )
public:
CDialogEdit( CWnd* pParent = NULL );
virtual ~CDialogEdit( );
CString Title;
CString Text;
// Sets a Scintilla style
void SetStyle( int style, COLORR... |
#include "stdafx.h"
#include "DialogModules.h"
#include "DialogProgress.h"
#include "CMainFrame.h"
#include "CClassFrame.h"
#include "afxdialogex.h"
#include <algorithm>
IMPLEMENT_DYNAMIC( CDialogModules, CDialogEx )
CDialogModules::CDialogModules( CWnd* pParent )
: CDialogEx( CDialogModules::IDD, pParent ),
... |
#pragma once
#include "afxwin.h"
class CDialogModules : public CDialogEx {
DECLARE_DYNAMIC( CDialogModules )
public:
CDialogModules( CWnd* pParent = NULL );
virtual ~CDialogModules( );
enum { IDD = IDD_DIALOG_MODULES };
protected:
virtual void DoDataExchange( CDataExchange* pDX );
DECLARE_M... |
// DialogPlugins.cpp : implementation file
//
#include "stdafx.h"
#include "DialogPlugins.h"
#include "ReClassEx.h"
#include "afxdialogex.h"
// CDialogPlugins dialog
IMPLEMENT_DYNAMIC( CDialogPlugins, CDialogEx )
// CDialogPlugins message handlers
BEGIN_MESSAGE_MAP( CDialogPlugins, CDialogEx )
ON_COMMAND( MENU_S... |
#pragma once
#include "afxwin.h"
#include "Resource.h"
#include "PluginAPI.h"
// CDialogPlugins dialog
class CDialogPlugins : public CDialogEx {
DECLARE_DYNAMIC( CDialogPlugins )
public:
// standard constructor
CDialogPlugins( CWnd* pParent = NULL ) : CDialogEx( CDialogPlugins::IDD, pParent ) { }
// ... |
// DialogProcSelect.cpp : implementation file
//
#include "stdafx.h"
#include <afxdialogex.h>
#include "ReClassEx.h"
#include "DialogProcSelect.h"
#include "DialogProgress.h"
#include "CMainFrame.h"
#include <memory>
#include <algorithm>
#include <Psapi.h>
// CDialogProcSelect dialog
std::initializer_list<const... |
#pragma once
#include "afxwin.h"
#include "Resource.h"
// CDialogProcSelect dialog
class CDialogProcSelect : public CDialogEx {
DECLARE_DYNAMIC( CDialogProcSelect )
public:
CDialogProcSelect( CWnd* pParent = NULL );
virtual ~CDialogProcSelect( );
// Dialog Data
enum { IDD = IDD_DIALOGPROCSELECT ... |
// DialogProgress.cpp : implementation file
//
#include "stdafx.h"
#include "DialogProgress.h"
#include <afxdialogex.h>
// CDialogProgress dialog
IMPLEMENT_DYNAMIC(CDialogProgress, CDialogEx)
CDialogProgress::CDialogProgress(CWnd* pParent /*=NULL*/)
: CDialogEx(IDD_DIALOG_PROGRESS, pParent)
{
}
CDialogProgre... |
#pragma once
#include "afxwin.h"
#include "afxcmn.h"
// DialogProgress dialog
class CDialogProgress : public CDialogEx {
DECLARE_DYNAMIC( CDialogProgress )
public:
CDialogProgress( CWnd* pParent = NULL ); // standard constructor
virtual ~CDialogProgress( );
// Dialog Data
enum { IDD = IDD_DIA... |
// DialogTypes.cpp : implementation file
//
#include "stdafx.h"
#include "ReClassEx.h"
#include "DialogTypes.h"
#include "afxdialogex.h"
// CDialogTypes dialog
IMPLEMENT_DYNAMIC( CDialogTypes, CDialogEx )
CDialogTypes::CDialogTypes( CWnd* pParent /*=NULL*/ )
: CDialogEx( CDialogTypes::IDD, pParent )
{
}
CDialo... |
#pragma once
#include "afxwin.h"
// CDialogTypes dialog
class CDialogTypes : public CDialogEx {
DECLARE_DYNAMIC( CDialogTypes )
public:
CDialogTypes( CWnd* pParent = NULL ); // standard constructor
virtual ~CDialogTypes( );
// Dialog Data
enum { IDD = IDD_DIALOG_TYPES };
protected:
virtua... |
#pragma once
#include <atltypes.h>
#include <tchar.h>
#define NONE -1
#define HS_NONE -1
#define HS_EDIT 0
#define HS_OPENCLOSE 1
#define HS_SELECT 2
#define HS_DROP 3
#define HS_CLICK 4
#define HS_CHANGE_A 5
#define HS_CHANGE_X 6
#define HS_DELETE 7
#define HS_RTTI 8
#define HS_SCINTILLA_EDIT 9
#define HS_ADDRESS ... |
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_M_X64)
unsigned __int64 ReadGS( unsigned __int64 );
#else
unsigned long __stdcall ReadFS( unsigned long );
#endif
#ifdef __cplusplus
}
#endif
|
#pragma once
//
// Thanks to Microsoft's DDK and Process Hacker for this stuff!
//
#include "NativeCommon.h"
#include "NativeObjects.h"
#include "NativeProcess.h"
#include "NativeInformation.h"
#include "NativeRtl.h"
#include "NativeLoader.h"
typedef NTSTATUS( NTAPI *tNtOpenProcessToken )(
IN HANDLE ProcessHand... |
#pragma once
#include <Windows.h>
///
/// < Common Defines >
///
#ifndef _NTDEF_
typedef long NTSTATUS;
typedef NTSTATUS *PNTSTATUS;
#endif
#ifndef NT_SUCCESS
#define NT_SUCCESS(x) ((x) >= 0)
#endif //!NT_SUCCESS
#ifndef NT_INFORMATION
#define NT_INFORMATION(Status) ((((ULONG)(Status)) >> 30) == 1)
#endif //!NT_INFO... |
#pragma once
#include "NativeCommon.h"
#include "NativeProcess.h"
///
/// < Information Enums >
///
typedef enum _SYSTEM_INFORMATION_CLASS
{
SystemBasicInformation, // q: SYSTEM_BASIC_INFORMATION
SystemProcessorInformation, // q: SYSTEM_PROCESSOR_INFORMATION
SystemPerformanceInformation, // q: SYSTEM_PER... |
#pragma once
#include "NativeCommon.h"
#include "NativeRtl.h"
///
/// < Loader Definitions >
///
#define LDR_DLL_NOTIFICATION_REASON_LOADED 1
#define LDR_DLL_NOTIFICATION_REASON_UNLOADED 2
///
/// < Loader Enums >
///
enum _LDR_DLL_LOAD_REASON
{
LoadReasonStaticDependency = 0,
LoadReasonStaticForwarderD... |
#pragma once
#include "NativeCommon.h"
///
/// < Native Memory Defines >
///
#define MMPFNLIST_ZERO 0
#define MMPFNLIST_FREE 1
#define MMPFNLIST_STANDBY 2
#define MMPFNLIST_MODIFIED 3
#define MMPFNLIST_MODIFIEDNOWRITE 4
#define MMPFNLIST_BAD 5
#define MMPFNLIST_ACTIVE 6
#define MMPFNLIST_TRANSITION 7
#define MMPFNU... |
#pragma once
#include "NativeCommon.h"
///
/// < Objects Macros and Definitions >
///
#define OBJECT_TYPE_CREATE 0x0001
#define OBJECT_TYPE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1)
#define DIRECTORY_QUERY 0x0001
#define DIRECTORY_TRAVERSE 0x0002
#define DIRECTORY_CREATE_OBJECT 0x0004
#define DIRECTORY_CREATE_SUB... |
#pragma once
#include "NativeCommon.h"
///
/// < PEB Macros and Definitions >
///
#define GDI_HANDLE_BUFFER_SIZE32 34
#define GDI_HANDLE_BUFFER_SIZE64 60
#ifndef WIN64
#define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE32
#else
#define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE64
#endif
typedef ULONG GDI_HANDL... |
#pragma once
#include "NativeCommon.h"
#include "NativeTeb.h"
#include "NativePeb.h"
///
/// < Process Macros and Definitions >
///
// Process access flags
#ifndef PROCESS_TERMINATE
#define PROCESS_TERMINATE 0x0001
#endif //!PROCESS_TERMINATE
#ifndef PROCESS_CREATE_THREAD
#define PROCESS_CREATE_THREAD 0x0002
#endif ... |
#pragma once
#include "NativeCommon.h"
#include "NativeMemory.h"
#include "NativeProcess.h"
#include "NativeInformation.h"
///
/// < RTL Macros and Definitions >
///
// Common
#define RTL_MAX_DRIVE_LETTERS 32
#define RTL_DRIVE_LETTER_VALID ((USHORT)0x0001)
#define RTL_BALANCED_NODE_RESERVED_PARENT_MAS... |
#pragma once
#include "NativePeb.h"
///
/// < TEB Macros and Definitions >
///
#define GDI_BATCH_BUFFER_SIZE 310
///
/// < TEB Structures >
///
typedef struct _GDI_TEB_BATCH
{
ULONG Offset;
ULONG_PTR HDC;
ULONG Buffer[GDI_BATCH_BUFFER_SIZE];
} GDI_TEB_BATCH, *PGDI_TEB_BATCH;
typedef struct _GDI_TEB_B... |
#pragma once
#include "CNodeBase.h"
#include "CNodeIcon.h"
#include "CNodeClass.h"
#include "CNodeHex64.h"
#include "CNodeHex32.h"
#include "CNodeHex16.h"
#include "CNodeHex8.h"
#include "CNodeBits.h"
#include "CNodeVTable.h"
#include "CNodeFunctionPtr.h"
#include "CNodeFunction.h"
#include "CNodePtr.h"
#include "CNod... |
#pragma once
#include <tchar.h>
// Forward declarations for all node base types
class CNodeBase;
class CNodeIcon;
class CNodeClass;
class CNodeHex64;
class CNodeHex32;
class CNodeHex16;
class CNodeHex8;
class CNodeBits;
class CNodeVTable;
class CNodeFunction;
class CNodeFunctionPtr;
class CNodePtr;
class CNodeInt64;
... |
#include "stdafx.h"
#include "NtDll.h"
namespace ntdll {
PVOID Base = nullptr;
tNtQuerySystemInformation NtQuerySystemInformation = nullptr;
tNtQueryInformationProcess NtQueryInformationProcess = nullptr;
tNtCreateThreadEx NtCreateThreadEx = nullptr;
tNtOpenProcessToken NtOpenProcessToken = nullptr;
tNtAdjustPriv... |
#pragma once
#include "Utils.h"
//
// NTDLL
//
namespace ntdll {
extern PVOID Base;
extern tNtQuerySystemInformation NtQuerySystemInformation;
extern tNtQueryInformationProcess NtQueryInformationProcess;
extern tNtCreateThreadEx NtCreateThreadEx;
extern tNtOpenProcessToken NtOpenProcessToken;
extern tNtAdjustPriv... |
#include "stdafx.h"
#include "PluginAPI.h"
PPLUGIN_READ_MEMORY_OPERATION g_PluginOverrideReadMemoryOperation = nullptr;
PPLUGIN_WRITE_MEMORY_OPERATION g_PluginOverrideWriteMemoryOperation = nullptr;
PPLUGIN_OPEN_PROCESS_OPERATION g_PluginOverrideOpenProcessOperation = nullptr;
PPLUGIN_OPEN_THREAD_OPERATION g_PluginO... |
#ifndef _RECLASS_PLUGIN_API_H_
#define _RECLASS_PLUGIN_API_H_
#include <afxwin.h>
#include <afxribbonbar.h>
#include <vector>
//
// ReClass Plugin Loading and Unloading - Not part of the plugin API.
//
VOID
LoadPlugins(
VOID
);
VOID
UnloadPlugins(
VOID
);
//
// ReClass Plugin Calling Conventio... |
#include "stdafx.h"
#include "ReClassEx.h"
#include "afxwinappex.h"
#include "afxdialogex.h"
#include "CMainFrame.h"
#include "CClassFrame.h"
#include "DialogEdit.h"
#include "DialogClasses.h"
#include "DialogModules.h"
#include "DialogPlugins.h"
#include "DialogAbout.h"
// The one and only CReClassExApp object
C... |
#pragma once
#ifndef __AFXWIN_H__
#error "include 'stdafx.h' before including this file for PCH"
#endif
#include "resource.h" // main symbols
// Console
#include "DialogConsole.h"
// Symbols
#include "Symbols.h"
// Class dependency graph
#include "ClassDependencyGraph.h"
class CReClassExApp : public CWinAppEx... |
ÿþ/ / { { N O _ D E P E N D E N C I E S } }
/ / M i c r o s o f t V i s u a l C + + g e n e r a t e d i n c l u d e f i l e .
/ / U s e d b y R e C l a s s E x . r c
/ /
# d e f i n e I D D _ A B O U T B O X 1 0 0
# d e f i n e I D P _ O ... |
#include "stdafx.h"
#include <memory>
#include <Psapi.h>
//Globals
HANDLE g_hProcess = NULL;
DWORD g_ProcessID = NULL;
ULONG_PTR g_AttachedProcessAddress = NULL;
DWORD g_AttachedProcessSize = NULL;
CString g_ProcessName;
/*
Memory and module map info
ReClass makes it easy to tell at a glance whether... |
#pragma once
//
// WinAPI, MFC, & STD Includes
//
// Disable warnings for type casting from HANDLE to DWORD and vice versa
#pragma warning(disable : 4312 4311 4302 4099)
#define PSAPI_VERSION 1
#define WIN32_LEAN_AND_MEAN
//#define _NO_CRT_STDIO_INLINE
#include "targetver.h"
#include <afx.h>
// turns off MFC's h... |
#include "stdafx.h"
#include "SymbolReader.h"
SymbolReader::SymbolReader( )
: m_bInitialized( FALSE )
, m_pSource( NULL )
, m_pSession( NULL )
{
}
SymbolReader::~SymbolReader( )
{
SAFE_RELEASE( m_pSession );
SAFE_RELEASE( m_pSource );
}
BOOLEAN SymbolReader::LoadSymbolData( const TCHAR* pszSear... |
#pragma once
#include <dia2.h>
#include <tchar.h>
#include <afxstr.h>
// Basic types
static const TCHAR* rgBaseType[] = {
_T( "<NoType>" ), // btNoType = 0,
_T( "void" ), // btVoid = 1,
_T( "char" ), // btChar = 2,
_T( "wc... |
#include "stdafx.h"
#include "Symbols.h"
#include <fstream>
Symbols::Symbols( ) :
m_bInitialized( FALSE )
{
ResolveSearchPath( );
if (!WriteSymSrvDll( ))
throw std::exception( "WriteSymSrvDll failed" );
if (!Init( ))
throw std::exception( "init failed" );
ntdll::RtlInitializeC... |
#pragma once
#include "SymbolReader.h"
#include <map>
class Symbols
{
public:
Symbols( );
~Symbols( );
void ResolveSearchPath( );
BOOLEAN WriteSymSrvDll( );
void Cleanup( );
BOOLEAN Init( );
BOOLEAN IsInitialized( ) const { return m_bInitialized; }
BOOLEAN LoadSymbolsForModule( CStr... |
// This MFC Samples source code demonstrates using MFC Microsoft Office Fluent User Interface
// (the "Fluent UI") and is provided only as referential material to supplement the
// Microsoft Foundation Classes Reference and related electronic documentation
// included with the MFC C++ library software.
// License terms... |
/*
Original code by Lee Thomason (www.grinninglizard.com)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.
Permission is granted to anyone to use this software for any
purpose, including comme... |
/*
Original code by Lee Thomason (www.grinninglizard.com)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.
Permission is granted to anyone to use this software for any
purpose, including comme... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.