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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
e5115fdb93170b6803b49401fc280ab12c540b6b | 90e001b00ae30ef22a3b07f6c9c374b0f2a1ee65 | /Computer Code/RobotPartProcessor.cpp | d0b7774a92191b5cb1bc1db25a56bd0659237985 | [] | no_license | yazaddaruvala/2010W_UBC_EECE_375_450_Team6 | 6ca20eacef048a770e4422b45b49cedac8d6efe9 | e87918415ac41c7953f67247d6b9d3ce12f6e95a | refs/heads/master | 2016-09-11T04:20:55.171140 | 2011-05-29T08:32:43 | 2011-05-29T08:32:43 | 1,816,632 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,825 | cpp | /*
* Written by Yazad Daruvala
*/
#include "RobotPartProcessor.h"
RobotPartProcessor::RobotPartProcessor( char* name_p, CvScalar color_p, const int hl, const int sl, const int vl, const int hh, const int sh, const int vh ): Processor()
{
name = name_p;
hueLower = hl, hueUpper = hh;
satLower = sl, satUpper = sh;
valLower = vl, valUpper = vh;
minRadius = 5;
maxRadius = 17;
color = color_p;
}
RobotPartProcessor::~RobotPartProcessor(void)
{
}
void RobotPartProcessor::process( vector<IplImage *> *input ){
IplImage * threshed = arrayToThreshed(input, cvScalar( hueLower, satLower, valLower), cvScalar( hueUpper, satUpper, valUpper) );
data_Mutex.lock();
data->clear();
data = contourFinder->process(threshed, minRadius, cvGetSize(threshed).width/4 );
data_Mutex.unlock();
cvReleaseImage(&threshed);
return;
}
void RobotPartProcessor::configure( vector<IplImage *> *input ){
IplImage * threshed = arrayToThreshed( input, cvScalar( hueLower, satLower, valLower), cvScalar( hueUpper, satUpper, valUpper) );
bounds_Mutex.lock();
char configWindow[50];
sprintf( configWindow, "Configure %s\0", name );
cvCreateTrackbar("LowerHue", configWindow, &hueLower, 255, NULL);
cvCreateTrackbar("UpperHue", configWindow, &hueUpper, 255, NULL);
cvCreateTrackbar("LowerSat", configWindow, &satLower, 255, NULL);
cvCreateTrackbar("UpperSat", configWindow, &satUpper, 255, NULL);
cvCreateTrackbar("LowerVal", configWindow, &valLower, 255, NULL);
cvCreateTrackbar("UpperVal", configWindow, &valUpper, 255, NULL);
cvCreateTrackbar("minRadius", configWindow, &minRadius, 20, NULL);
bounds_Mutex.unlock();
char threshWindow[50];
sprintf( threshWindow, "Thresholded %s\0", name );
cv::imshow( threshWindow, threshed);
cvReleaseImage(&threshed);
}
| [
"[email protected]"
] | [
[
[
1,
55
]
]
] |
d4c4bdcffbc4a34ddf9c6ee90587df215edd1b24 | 3b2322c1adf5e6166259540e767ec67df0887c17 | /finite-state-machine/src/state/StateFighterApproachCarrier.cpp | aeac4007e8086d7a601adbba1c776600ac58132e | [] | no_license | aruwen/various-stefan-ebner | 750aac6e546ddb3e571ac468ecc26087843817d3 | 49eac46ed3a01131d711ea6feca77c32accb4733 | refs/heads/master | 2021-01-20T00:42:40.803881 | 2011-03-13T14:08:22 | 2011-03-13T14:08:22 | 32,136,593 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,561 | cpp | #include "StateFighterApproachCarrier.h"
#include "..\EnemyFighter.h"
#include "StateIdentifiers.h"
#include "ofTypes.h"
const float StateFighterApproachCarrier::maxSpeed = 5.0;
const float StateFighterApproachCarrier::approachEndRadius = 50.0;
void StateFighterApproachCarrier::initState()
{
mID = EnemyState::FIGHTER_APPROACH_CARRIER;
printf("Init Fighter Approach Carrier State\n");
}
void StateFighterApproachCarrier::enterState()
{
printf("Enter Fighter Approach Carrier State\n");
}
void StateFighterApproachCarrier::exitState()
{
printf("Exit Fighter Approach Carrier State\n");
}
int StateFighterApproachCarrier::update()
{
if(mOwnFighter->getAttacking())
return EnemyState::FIGHTER_APPROACH_TARGET;
// handle the approach - this is a form of "Offset pursuit" described by Craig W. Reynolds in
// "Steering Behaviors For Autonomous Characters".
// In this case it could rather be described as "Offset seeking".
ofPoint objectToTargetVector = mTargetCarrier->getPosition() - mOwnFighter->getPosition();
ofPoint speedVector = mOwnFighter->getSpeed();
if (speedVector.x == 0 && speedVector.y == 0)
speedVector = ofPoint(1,1,0);
ofPoint normalizedObjectToTargetVector = objectToTargetVector * getLength(objectToTargetVector);
// added these two lines of code to make the fighter circle around the target.
if (getLength(objectToTargetVector) <60)
speedVector += normalizedObjectToTargetVector * 0.01;
ofPoint speedNormalVector = makeLeftNormalVector(speedVector);
ofPoint targetOffsetVector = getProjectionVector(speedNormalVector, objectToTargetVector);
ofPoint pointToReach = mTargetCarrier->getPosition();
pointToReach += targetOffsetVector / getLength(targetOffsetVector) * -approachEndRadius;
ofPoint distanceVector = pointToReach - mOwnFighter->getPosition();
float distance = sqrt( distanceVector.x * distanceVector.x +
distanceVector.y * distanceVector.y);
ofPoint accelerationVector = (distanceVector/distance) * maxSpeed;
accelerationVector -= mOwnFighter->getSpeed();
mOwnFighter->accelerateWithVector(accelerationVector);
mOwnFighter->move();
return mID;
}
ofPoint getProjectionVector(ofPoint u, ofPoint v)
{
ofPoint w;
w = u * (dot(u,v)/dot(u,u));
return w;
}
ofPoint makeLeftNormalVector(ofPoint u)
{
ofPoint v;
v.x = -u.y;
v.y = u.x;
return v;
}
float dot(ofPoint u, ofPoint v)
{
return u.x*v.x + u.y*v.y + u.z*v.z;
}
float getLength(ofPoint u)
{
return sqrt(dot(u,u));
} | [
"nightwolve@bb536436-bb54-8cee-38f9-046b9e77f541"
] | [
[
[
1,
95
]
]
] |
0e120c0de01f24a05e6d5cbb2a2979252aecd60b | c95a83e1a741b8c0eb810dd018d91060e5872dd8 | /Game/ObjectDLL/ObjectShared/AIHumanStateResurrecting.cpp | 38972b300bd90d84e7a1932841851a4eb900900b | [] | no_license | rickyharis39/nolf2 | ba0b56e2abb076e60d97fc7a2a8ee7be4394266c | 0da0603dc961e73ac734ff365bfbfb8abb9b9b04 | refs/heads/master | 2021-01-01T17:21:00.678517 | 2011-07-23T12:11:19 | 2011-07-23T12:11:19 | 38,495,312 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,903 | cpp | //----------------------------------------------------------------------------
//
// MODULE: AIHumanStateResurrecting.cpp
//
// PURPOSE: - implementation
//
// CREATED: 28.01.2002
//
// (c) 2002 Monolith Productions, Inc. All Rights Reserved
//
//
// COMMENTS:
//
//
//----------------------------------------------------------------------------
// Includes
#include "stdafx.h"
#ifndef __AIHUMANSTATERESURRECTING_H__
#include "AIHumanStateResurrecting.h"
#endif
#ifndef __AI_HUMAN_H__
#include "AIHuman.h"
#endif
#include "MsgIds.h"
#include "DebrisFuncs.h"
// Forward declarations
// Globals
// Statics
DEFINE_AI_FACTORY_CLASS_SPECIFIC(State, CAIHumanStateResurrecting, kState_HumanResurrecting);
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::CAIHumanStateResurrecting()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
CAIHumanStateResurrecting::CAIHumanStateResurrecting()
{
// Construct
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::~CAIHumanStateResurrecting()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ CAIHumanStateResurrecting::~CAIHumanStateResurrecting()
{
// Destruct
if ( GetAI() && !GetAI()->IsDead() )
{
CDestructible* pDestructable = GetAI()->GetDestructible();
pDestructable->SetNeverDestroy( m_bEntryCanDistruct );
pDestructable->SetHitPoints( pDestructable->GetMaxHitPoints() );
}
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::Load()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ void CAIHumanStateResurrecting::Load(ILTMessage_Read *pMsg)
{
CAIHumanState::Load(pMsg);
LOAD_TIME(m_fResurrectCompleteTime);
LOAD_FLOAT(m_fResurrectCompleteDuration);
LOAD_BOOL(m_bEntryCanDistruct);
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::Save()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ void CAIHumanStateResurrecting::Save(ILTMessage_Write *pMsg)
{
CAIHumanState::Save(pMsg);
SAVE_TIME(m_fResurrectCompleteTime);
SAVE_FLOAT(m_fResurrectCompleteDuration);
SAVE_BOOL(m_bEntryCanDistruct);
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::Init()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ LTBOOL CAIHumanStateResurrecting::Init(CAIHuman* pAIHuman)
{
if ( !CAIHumanState::Init(pAIHuman) )
{
return LTFALSE;
}
// Set the time tracking vars to invalid times
m_fResurrectCompleteTime = -1;
m_fResurrectCompleteDuration = -1;
GetAI()->SetBlinking(LTFALSE);
m_eStateStatus = kSStat_Resurrecting;
CDestructible* pDestructable = GetAI()->GetDestructible();
m_bEntryCanDistruct = pDestructable->GetNeverDestroy();
pDestructable->SetNeverDestroy( LTFALSE );
pDestructable->SetHitPoints( pDestructable->GetMaxHitPoints() );
// Ensure that node tracking is disabled.
m_pAIHuman->DisableNodeTracking();
return LTTRUE;
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::Update()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ void CAIHumanStateResurrecting::Update()
{
CAIHumanState::Update();
AIASSERT( m_fResurrectCompleteTime!=-1, GetAI()->m_hObject,
"CAIHumanStateResurrecting::Update: m_fResurrectCompleteTime == -1" );
if ( m_bFirstUpdate )
{
GetAI()->KillDlgSnd();
// TEMP!!
// Replace this with FXEd effects setup!
CLIENTDEBRIS cd;
cd.rRot = m_pAI->GetRotation();
cd.vPos = m_pAI->GetPosition() + LTVector( 0.0f, 10.0f, 0.0f );
cd.nDebrisId = 43;
::CreatePropDebris( cd.vPos, LTVector(0,1,0), 43 );
}
switch ( m_eStateStatus )
{
case kSStat_Conscious:
break;
case kSStat_RegainingConsciousness:
{
if ( GetAnimationContext()->IsPropSet(kAPG_Posture, kAP_Stand) )
{
m_eStateStatus = kSStat_Conscious;
GetAI()->SetBlinking(LTTRUE);
}
}
break;
case kSStat_Resurrecting:
{
if ( m_fResurrectCompleteTime < g_pLTServer->GetTime() )
{
m_eStateStatus = kSStat_RegainingConsciousness;
}
}
break;
}
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::UpdateAnimation()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ void CAIHumanStateResurrecting::UpdateAnimation()
{
CAIHumanState::UpdateAnimation();
switch ( m_eStateStatus )
{
case kSStat_Resurrecting:
GetAI()->GetAnimationContext()->SetProp(kAPG_Posture, kAP_Prone);
GetAI()->GetAnimationContext()->SetProp(kAPG_Action, kAP_Resurrecting);
break;
case kSStat_RegainingConsciousness:
case kSStat_Conscious:
GetAI()->GetAnimationContext()->SetProp(kAPG_Posture, kAP_Stand);
GetAI()->GetAnimationContext()->SetProp(kAPG_WeaponPosition, kAP_Down);
break;
}
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::HandleDamage()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ void CAIHumanStateResurrecting::HandleDamage(const DamageStruct& damage)
{
CAIHumanState::HandleDamage(damage);
ResetExpirationTime();
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::RejectChangeState()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ LTBOOL CAIHumanStateResurrecting::RejectChangeState()
{
return m_eStateStatus != kSStat_Conscious;
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::GetDeathAni()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
/*virtual*/ HMODELANIM CAIHumanStateResurrecting::GetDeathAni(LTBOOL bFront)
{
if ( !GetAnimationContext() )
return INVALID_MODEL_ANIM;
if ( !GetAnimationContext()->IsPropSet(kAPG_Action, kAP_Resurrecting ) )
return INVALID_MODEL_ANIM;
return g_pLTServer->GetAnimIndex(GetAI()->GetObject(), "PrUn");
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIHumanStateResurrecting::SetUnconsciousTime()
//
// PURPOSE:
//
//----------------------------------------------------------------------------
void CAIHumanStateResurrecting::SetResurrectingTime(LTFLOAT fTime)
{
m_fResurrectCompleteDuration = fTime;
}
void CAIHumanStateResurrecting::ResetExpirationTime()
{
m_fResurrectCompleteTime = g_pLTServer->GetTime() + m_fResurrectCompleteDuration;
} | [
"[email protected]"
] | [
[
[
1,
270
]
]
] |
0fba7c2ae4eb7e0ef4ca874cf3d73fcf1fd3f4b9 | 0eb6dae3844d1e57d7580d68b03550f312c0b88d | /Factory/demosystem/imagesystem/src/Noise.h | 851d47a2ad90f62e31cec236c19d78ba51193ba2 | [] | no_license | glerchundi/vasik | da32f4dd04d6b55631493e92a14fa79263af5824 | 177646652f7af5fa2fbbc98e697675d780a41339 | refs/heads/master | 2021-01-10T20:07:51.441193 | 2009-06-16T10:39:09 | 2009-06-16T10:39:09 | 33,879,767 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,330 | h | #ifndef NOISE_H__
#define NOISE_H__
#include <math.h>
#include <stdlib.h>
#ifndef M_PI
#define M_PI 3.14159265358979323846264338327
#endif
// Prime numbers for random number generation
#define prime1 15731
#define prime2 789221
#define prime3 1376312589
class Noise
{
public:
static float linearInterpolator(float v1, float v2, float x);
static float cosineInterpolator(float v1, float v2, float x);
static float cubicInterpolator(float v0, float v1, float v2, float v3, float x);
static void setSeed(unsigned int seed);
static void setPrimes(unsigned int p1, unsigned int p2, unsigned int p3);
static float noise1D(int x);
static float noise2D(int x, int y);
static float noise3D(int x, int y, int z);
static float smoothNoise1D(int x);
static float smoothNoise2D(int x, int y);
static float smoothNoise3D(int x, int y, int z);
static float interpolatedNoise1D(float x);
static float interpolatedNoise2D(float x, float y);
static float interpolatedNoise3D(float x, float y, float z);
static float perlinNoise1D(float x, float ifreq, float persistence, int octaves);
static float perlinNoise2D(float x, float y, float ifreq, float persistence, int octaves);
static float perlinNoise3D(float x, float y, float z, float ifreq, float persistence, int octaves);
};
#endif
| [
"glertxundi@0aa467b6-4590-11de-a2ae-350cbd0950bb"
] | [
[
[
1,
36
]
]
] |
ec0990a0f1c02bc5447414e236b6213676ed0e1f | 7476d2c710c9a48373ce77f8e0113cb6fcc4c93b | /GameFactory.cpp | ad82aaeac31a799d6cb3aa65414543960444a714 | [] | no_license | CmaThomas/Vault-Tec-Multiplayer-Mod | af23777ef39237df28545ee82aa852d687c75bc9 | 5c1294dad16edd00f796635edaf5348227c33933 | refs/heads/master | 2021-01-16T21:13:29.029937 | 2011-10-30T21:58:41 | 2011-10-30T22:00:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,281 | cpp | #include "GameFactory.h"
CriticalSection GameFactory::cs;
ReferenceList GameFactory::instances;
unsigned char GameFactory::game = 0x00;
#ifdef VAULTMP_DEBUG
Debug* GameFactory::debug;
#endif
GameFactory::GameFactory()
{
}
void GameFactory::Initialize( unsigned char game )
{
GameFactory::game = game;
switch ( game )
{
case FALLOUT3:
Container::Items = &Container::Fallout3Items;
break;
case NEWVEGAS:
Container::Items = &Container::FalloutNVItems;
break;
case OBLIVION:
Container::Items = &Container::OblivionItems;
break;
default:
throw VaultException( "Bad game ID %08X", game );
}
#ifdef VAULTMP_DEBUG
if ( debug != NULL )
debug->PrintFormat( "Found %d items in the database", true, Container::Items->size() );
#endif
}
#ifdef VAULTMP_DEBUG
void GameFactory::SetDebugHandler( Debug* debug )
{
GameFactory::debug = debug;
if ( debug != NULL )
debug->Print( "Attached debug handler to GameFactory class", true );
}
#endif
vector<FactoryObject> GameFactory::GetObjectTypes( unsigned char type )
{
vector<FactoryObject> result;
ReferenceList::iterator it;
cs.StartSession();
ReferenceList copy = instances;
cs.EndSession();
for ( it = copy.begin(); it != copy.end() && ( it->second & type ); ++it )
result.push_back( FactoryObject( it->first ) );
return result;
}
FactoryObject GameFactory::GetObject( NetworkID id )
{
cs.StartSession();
Reference* reference = Network::Manager()->GET_OBJECT_FROM_ID<Reference*>( id );
cs.EndSession();
if ( !reference )
throw VaultException( "Unknown object with NetworkID %lld", id );
return FactoryObject( reference );
}
FactoryObject GameFactory::GetObject( unsigned int refID )
{
ReferenceList::iterator it;
cs.StartSession();
for ( it = instances.begin(); it != instances.end() && it->first->GetReference() != refID; ++it );
Reference* reference = ( it != instances.end() ? it->first : NULL );
cs.EndSession();
if ( !reference )
throw VaultException( "Unknown object with reference %08X", refID );
return FactoryObject( reference );
}
vector<FactoryObject> GameFactory::GetMultiple( const vector<NetworkID>& objects )
{
vector<FactoryObject> result;
result.resize( objects.size(), FactoryObject() );
vector<NetworkID>::const_iterator it;
multimap<Reference*, unsigned int> sort;
multimap<Reference*, unsigned int>::iterator it2;
int i = 0;
cs.StartSession();
for ( it = objects.begin(); it != objects.end(); ++it, i++ )
{
Reference* reference = Network::Manager()->GET_OBJECT_FROM_ID<Reference*>( *it );
if ( !reference )
throw VaultException( "Unknown object with NetworkID %lld", *it );
sort.insert( pair<Reference*, unsigned int>( reference, i ) );
}
cs.EndSession();
for ( it2 = sort.begin(); it2 != sort.end(); ++it2 )
result[it2->second] = FactoryObject( it2->first );
return result;
}
vector<FactoryObject> GameFactory::GetMultiple( const vector<unsigned int>& objects )
{
vector<FactoryObject> result;
result.resize( objects.size(), FactoryObject() );
vector<unsigned int>::const_iterator it;
multimap<Reference*, unsigned int> sort;
multimap<Reference*, unsigned int>::iterator it2;
ReferenceList::iterator it3;
int i = 0;
cs.StartSession();
for ( it = objects.begin(); it != objects.end(); ++it, i++ )
{
for ( it3 = instances.begin(); it3 != instances.end() && it3->first->GetReference() != *it; ++it3 );
Reference* reference = ( it3 != instances.end() ? it3->first : NULL );
if ( !reference )
throw VaultException( "Unknown object with reference %08X", *it );
sort.insert( pair<Reference*, unsigned int>( reference, i ) );
}
cs.EndSession();
for ( it2 = sort.begin(); it2 != sort.end(); ++it2 )
result[it2->second] = FactoryObject( it2->first );
return result;
}
NetworkID GameFactory::LookupNetworkID( unsigned int refID )
{
ReferenceList::iterator it;
cs.StartSession();
for ( it = instances.begin(); it != instances.end() && it->first->GetReference() != refID; ++it );
NetworkID id = ( it != instances.end() ? it->first->GetNetworkID() : throw VaultException( "Unknown object with reference %08X", refID ) );
cs.EndSession();
return id;
}
unsigned int GameFactory::LookupRefID( NetworkID id )
{
cs.StartSession();
Reference* reference = Network::Manager()->GET_OBJECT_FROM_ID<Reference*>( id );
unsigned int refID = ( reference != NULL ? reference->GetReference() : throw VaultException( "Unknown object with NetworkID %lld", id ) );
cs.EndSession();
return refID;
}
void GameFactory::LeaveReference( FactoryObject& reference )
{
Reference* _reference = reference.reference;
if ( !_reference )
throw VaultException( "GameFactory::LeaveReference Reference is NULL" );
_reference->EndSession();
reference.reference = NULL;
}
unsigned char GameFactory::GetType( Reference* reference )
{
ReferenceList::iterator it;
cs.StartSession();
unsigned char type;
it = instances.find( reference );
type = ( it != instances.end() ? it->second : 0x00 );
cs.EndSession();
return type;
}
NetworkID GameFactory::CreateInstance( unsigned char type, unsigned int refID, unsigned int baseID )
{
Reference* reference;
switch ( type )
{
case ID_REFERENCE:
throw VaultException( "It is not possible to have a pure Reference instance" );
case ID_OBJECT:
reference = new Object( refID, baseID );
break;
case ID_ITEM:
reference = new Item( refID, baseID );
break;
case ID_CONTAINER:
reference = new Container( refID, baseID );
break;
case ID_ACTOR:
reference = new Actor( refID, baseID );
break;
case ID_PLAYER:
reference = new Player( refID, baseID );
break;
default:
throw VaultException( "Unknown type identifier %X", type );
}
NetworkID id = reference->GetNetworkID();
cs.StartSession();
instances.insert( pair<Reference*, unsigned char>( reference, type ) );
cs.EndSession();
return id;
}
NetworkID GameFactory::CreateInstance( unsigned char type, unsigned int baseID )
{
return CreateInstance( type, 0x00, baseID );
}
void GameFactory::CreateKnownInstance( unsigned char type, NetworkID id, unsigned int refID, unsigned int baseID )
{
Reference* reference;
switch ( type )
{
case ID_REFERENCE:
throw VaultException( "It is not possible to have a pure Reference instance" );
case ID_OBJECT:
reference = new Object( refID, baseID );
break;
case ID_ITEM:
reference = new Item( refID, baseID );
break;
case ID_CONTAINER:
reference = new Container( refID, baseID );
break;
case ID_ACTOR:
reference = new Actor( refID, baseID );
break;
case ID_PLAYER:
reference = new Player( refID, baseID );
break;
default:
throw VaultException( "Unknown type identifier %X", type );
}
reference->SetNetworkID( id );
cs.StartSession();
instances.insert( pair<Reference*, unsigned char>( reference, type ) );
cs.EndSession();
}
void GameFactory::CreateKnownInstance( unsigned char type, NetworkID id, unsigned int baseID )
{
return CreateKnownInstance( type, id, 0x00, baseID );
}
void GameFactory::DestroyAllInstances()
{
ReferenceList::iterator it;
cs.StartSession();
for ( it = instances.begin(); it != instances.end(); ++it )
{
if ( it->second == ID_CONTAINER )
vaultcast<Container>( it->first )->container.clear();
#ifdef VAULTMP_DEBUG
if ( debug != NULL )
debug->PrintFormat( "Reference %08X with base %08X and NetworkID %lld (type: %s) to be destructed", true, it->first->GetReference(), it->first->GetBase(), it->first->GetNetworkID(), typeid( *( it->first ) ).name() );
#endif
Reference* reference = ( Reference* ) it->first->StartSession();
if ( reference )
{
reference->Finalize();
delete reference;
}
}
instances.clear();
cs.EndSession();
// Cleanup classes
game = 0x00;
Object::param_Axis.first = vector<string>();
Container::Items = NULL;
Actor::Actors = NULL;
Actor::Creatures = NULL;
Actor::param_ActorValues.first = vector<string>();
Lockable::Reset();
}
bool GameFactory::DestroyInstance( NetworkID id )
{
FactoryObject reference = GetObject( id );
DestroyInstance( reference );
return true;
}
NetworkID GameFactory::DestroyInstance( FactoryObject& reference )
{
Reference* _reference = reference.reference;
if ( !_reference )
throw VaultException( "GameFactory::DestroyInstance Reference is NULL" );
NetworkID id = _reference->GetNetworkID();
#ifdef VAULTMP_DEBUG
if ( debug != NULL )
debug->PrintFormat( "Reference %08X with base %08X and NetworkID %lld (type: %s) to be destructed", true, _reference->GetReference(), _reference->GetBase(), _reference->GetNetworkID(), typeid( *_reference ).name() );
#endif
cs.StartSession();
ReferenceList::iterator it;
it = instances.find( _reference );
if ( it != instances.end() )
instances.erase( it );
cs.EndSession();
_reference->Finalize();
delete _reference;
reference.reference = NULL;
return id;
}
| [
"[email protected]",
"[email protected]"
] | [
[
[
1,
15
],
[
17,
17
],
[
37,
38
],
[
43,
46
],
[
48,
48
],
[
50,
50
],
[
53,
55
],
[
57,
57
],
[
60,
60
],
[
64,
64
],
[
67,
67
],
[
69,
70
],
[
72,
72
],
[
76,
76
],
[
79,
79
],
[
81,
82
],
[
84,
84
],
[
88,
88
],
[
90,
90
],
[
93,
93
],
[
98,
99
],
[
101,
101
],
[
108,
108
],
[
110,
110
],
[
114,
114
],
[
117,
117
],
[
120,
120
],
[
122,
122
],
[
125,
125
],
[
127,
128
],
[
130,
130
],
[
140,
140
],
[
144,
144
],
[
146,
146
],
[
149,
149
],
[
152,
152
],
[
154,
154
],
[
157,
157
],
[
159,
160
],
[
162,
162
],
[
164,
164
],
[
166,
166
],
[
173,
174
],
[
176,
176
],
[
181,
181
],
[
183,
184
],
[
186,
186
],
[
188,
188
],
[
191,
191
],
[
194,
195
],
[
197,
197
],
[
199,
199
],
[
205,
205
],
[
207,
208
],
[
210,
210
],
[
249,
250
],
[
252,
252
],
[
254,
255
],
[
257,
257
],
[
294,
295
],
[
297,
297
],
[
299,
302
],
[
304,
304
],
[
306,
306
],
[
311,
312
],
[
317,
318
],
[
320,
320
],
[
327,
327
],
[
329,
329
],
[
331,
331
],
[
333,
333
],
[
340,
340
],
[
342,
343
],
[
345,
345
],
[
349,
350
],
[
352,
352
],
[
354,
354
],
[
357,
357
],
[
359,
360
],
[
365,
366
],
[
368,
368
],
[
371,
371
],
[
374,
374
],
[
376,
376
],
[
380,
380
],
[
382,
382
]
],
[
[
16,
16
],
[
18,
36
],
[
39,
42
],
[
47,
47
],
[
49,
49
],
[
51,
52
],
[
56,
56
],
[
58,
59
],
[
61,
63
],
[
65,
66
],
[
68,
68
],
[
71,
71
],
[
73,
75
],
[
77,
78
],
[
80,
80
],
[
83,
83
],
[
85,
87
],
[
89,
89
],
[
91,
92
],
[
94,
97
],
[
100,
100
],
[
102,
107
],
[
109,
109
],
[
111,
113
],
[
115,
116
],
[
118,
119
],
[
121,
121
],
[
123,
124
],
[
126,
126
],
[
129,
129
],
[
131,
139
],
[
141,
143
],
[
145,
145
],
[
147,
148
],
[
150,
151
],
[
153,
153
],
[
155,
156
],
[
158,
158
],
[
161,
161
],
[
163,
163
],
[
165,
165
],
[
167,
172
],
[
175,
175
],
[
177,
180
],
[
182,
182
],
[
185,
185
],
[
187,
187
],
[
189,
190
],
[
192,
193
],
[
196,
196
],
[
198,
198
],
[
200,
204
],
[
206,
206
],
[
209,
209
],
[
211,
248
],
[
251,
251
],
[
253,
253
],
[
256,
256
],
[
258,
293
],
[
296,
296
],
[
298,
298
],
[
303,
303
],
[
305,
305
],
[
307,
310
],
[
313,
316
],
[
319,
319
],
[
321,
326
],
[
328,
328
],
[
330,
330
],
[
332,
332
],
[
334,
339
],
[
341,
341
],
[
344,
344
],
[
346,
348
],
[
351,
351
],
[
353,
353
],
[
355,
356
],
[
358,
358
],
[
361,
364
],
[
367,
367
],
[
369,
370
],
[
372,
373
],
[
375,
375
],
[
377,
379
],
[
381,
381
]
]
] |
5769356b8e0785dd0fd7e923875bd5f7c9ce5bab | bfe8eca44c0fca696a0031a98037f19a9938dd26 | /libjingle-0.4.0/talk/base/common.h | a2c744d49642a7ca1ca0580c006ad26b07606aed | [
"BSD-3-Clause"
] | permissive | luge/foolject | a190006bc0ed693f685f3a8287ea15b1fe631744 | 2f4f13a221a0fa2fecab2aaaf7e2af75c160d90c | refs/heads/master | 2021-01-10T07:41:06.726526 | 2011-01-21T10:25:22 | 2011-01-21T10:25:22 | 36,303,977 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,665 | h | /*
* libjingle
* Copyright 2004--2005, Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 TALK_BASE_COMMON_H__
#define TALK_BASE_COMMON_H__
#if defined(_MSC_VER)
// warning C4355: 'this' : used in base member initializer list
#pragma warning(disable:4355)
#endif
//////////////////////////////////////////////////////////////////////
// General Utilities
//////////////////////////////////////////////////////////////////////
#ifndef UNUSED
#define UNUSED(x) Unused(static_cast<const void *>(&x))
#define UNUSED2(x,y) Unused(static_cast<const void *>(&x)); Unused(static_cast<const void *>(&y))
#define UNUSED3(x,y,z) Unused(static_cast<const void *>(&x)); Unused(static_cast<const void *>(&y)); Unused(static_cast<const void *>(&z))
#define UNUSED4(x,y,z,a) Unused(static_cast<const void *>(&x)); Unused(static_cast<const void *>(&y)); Unused(static_cast<const void *>(&z)); Unused(static_cast<const void *>(&a))
#define UNUSED5(x,y,z,a,b) Unused(static_cast<const void *>(&x)); Unused(static_cast<const void *>(&y)); Unused(static_cast<const void *>(&z)); Unused(static_cast<const void *>(&a)); Unused(static_cast<const void *>(&b))
inline void Unused(const void *) { }
#endif // UNUSED
#ifndef WIN32
#define strnicmp(x,y,n) strncasecmp(x,y,n)
#define stricmp(x,y) strcasecmp(x,y)
#define stdmax(x,y) std::max(x,y)
#else
#define stdmax(x,y) max(x,y)
#endif
#define ARRAY_SIZE(x) (static_cast<int>((sizeof(x)/sizeof(x[0]))))
/////////////////////////////////////////////////////////////////////////////
// Assertions
/////////////////////////////////////////////////////////////////////////////
#ifdef ENABLE_DEBUG
namespace talk_base {
// Break causes the debugger to stop executing, or the program to abort
void Break();
// LogAssert writes information about an assertion to the log
void LogAssert(const char * function, const char * file, int line, const char * expression);
inline void Assert(bool result, const char * function, const char * file, int line, const char * expression) {
if (!result) {
LogAssert(function, file, line, expression);
Break();
}
}
}; // namespace talk_base
#if defined(_MSC_VER) && _MSC_VER < 1300
#define __FUNCTION__ ""
#endif
#ifndef ASSERT
#define ASSERT(x) talk_base::Assert((x),__FUNCTION__,__FILE__,__LINE__,#x)
#endif
#ifndef VERIFY
#define VERIFY(x) talk_base::Assert((x),__FUNCTION__,__FILE__,__LINE__,#x)
#endif
#else // !ENABLE_DEBUG
#ifndef ASSERT
#define ASSERT(x) (void)0
#endif
#ifndef VERIFY
#define VERIFY(x) (void)(x)
#endif
#endif // !ENABLE_DEBUG
#define COMPILE_TIME_ASSERT(expr) char CTA_UNIQUE_NAME[expr]
#define CTA_UNIQUE_NAME MAKE_NAME(__LINE__)
#define CTA_MAKE_NAME(line) MAKE_NAME2(line)
#define CTA_MAKE_NAME2(line) constraint_ ## line
//////////////////////////////////////////////////////////////////////
// A macro to disallow the evil copy constructor and operator= functions
// This should be used in the private: declarations for a class
#define DISALLOW_EVIL_CONSTRUCTORS(TypeName) \
TypeName(const TypeName&); \
void operator=(const TypeName&)
#endif // TALK_BASE_COMMON_H__
| [
"[email protected]@756bb6b0-a119-0410-8338-473b6f1ccd30"
] | [
[
[
1,
120
]
]
] |
4d4baff84106449aaa595b0e89ea0cc58372668b | 6f796044ae363f9ca58c66423c607e3b59d077c7 | /source/SoundChips/YM2413.cpp | e9c4fdd32e674293e8678c25f78b071686cd81c3 | [] | no_license | Wiimpathy/bluemsx-wii | 3a68d82ac82268a3a1bf1b5ca02115ed5e61290b | fde291e57fe93c0768b375a82fc0b62e645bd967 | refs/heads/master | 2020-05-02T22:46:06.728000 | 2011-10-06T20:57:54 | 2011-10-06T20:57:54 | 178,261,485 | 2 | 0 | null | 2019-03-28T18:32:30 | 2019-03-28T18:32:30 | null | UTF-8 | C++ | false | false | 4,797 | cpp | /*****************************************************************************
** $Source: /cvsroot/bluemsx/blueMSX/Src/SoundChips/YM2413.cpp,v $
**
** $Revision: 1.19 $
**
** $Date: 2007/05/23 09:41:56 $
**
** More info: http://www.bluemsx.com
**
** Copyright (C) 2003-2006 Daniel Vik
**
** 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
**
******************************************************************************
*/
#include "../SoundChips/YM2413.h"
#include "OpenMsxYM2413.h"
#include "OpenMsxYM2413_2.h"
#include <cstring>
#include "../Board/Board.h"
#include "../Utils/SaveState.h"
#include "../Memory/IoPort.h"
#include "../Media/MediaDb.h"
#include "../Memory/DeviceManager.h"
#include "../Language/Language.h"
#define FREQUENCY 3579545
struct YM_2413 {
YM_2413() : address(0) {
if (0) {
ym2413 = new OpenYM2413("ym2413", 100, 0);
}
else {
ym2413 = new OpenYM2413_2("ym2413", 100, 0);
}
memset(defaultBuffer, 0, sizeof(defaultBuffer));
}
~YM_2413() {
delete ym2413;
}
Mixer* mixer;
Int32 handle;
OpenYM2413Base* ym2413;
UInt8 address;
UInt8 registers[256];
Int32 buffer[AUDIO_MONO_BUFFER_SIZE];
Int32 defaultBuffer[AUDIO_MONO_BUFFER_SIZE];
};
void ym2413SaveState(YM_2413* ref)
{
YM_2413* ym2413 = (YM_2413*)ref;
SaveState* state = saveStateOpenForWrite("msxmusic");
saveStateSetBuffer(state, "regs", ym2413->registers, 256);
saveStateClose(state);
ym2413->ym2413->saveState();
}
void ym2413LoadState(YM_2413* ref)
{
YM_2413* ym2413 = (YM_2413*)ref;
SaveState* state = saveStateOpenForRead("msxmusic");
saveStateGetBuffer(state, "regs", ym2413->registers, 256);
saveStateClose(state);
ym2413->ym2413->loadState();
}
void ym2413Reset(YM_2413* ref)
{
YM_2413* ym2413 = (YM_2413*)ref;
ym2413->ym2413->reset(boardSystemTime());
}
void ym2413WriteAddress(YM_2413* ym2413, UInt8 address)
{
ym2413->address = address & 0x3f;
}
void ym2413WriteData(YM_2413* ym2413, UInt8 data)
{
UInt32 systemTime = boardSystemTime();
mixerSync(ym2413->mixer);
ym2413->registers[ym2413->address & 0xff] = data;
ym2413->ym2413->writeReg(ym2413->address, data, systemTime);
}
static Int32* ym2413Sync(void* ref, UInt32 count)
{
YM_2413* ym2413 = (YM_2413*)ref;
int* genBuf;
UInt32 i;
genBuf = ym2413->ym2413->updateBuffer(count);
if (genBuf == NULL) {
return ym2413->defaultBuffer;
}
for (i = 0; i < count; i++) {
ym2413->buffer[i] = genBuf[i];
}
return ym2413->buffer;
}
static char* regText(int d)
{
static char text[5];
sprintf(text, "R%.2x", d);
return text;
}
static char regsAvailYM2413[] = {
1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,
1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
};
void ym2413GetDebugInfo(YM_2413* ym2413, DbgDevice* dbgDevice)
{
DbgRegisterBank* regBank;
// Add YM2413 registers
int c = 0;
for (int r = 0; r < sizeof(regsAvailYM2413); r++) {
c += regsAvailYM2413[r];
}
regBank = dbgDeviceAddRegisterBank(dbgDevice, langDbgRegsYm2413(), c);
c = 0;
for (int r = 0; r < sizeof(regsAvailYM2413); r++) {
if (regsAvailYM2413[r]) {
dbgRegisterBankAddRegister(regBank, c++, regText(r), 8, ym2413->ym2413->peekReg(r));
}
}
}
YM_2413* ym2413Create(Mixer* mixer)
{
YM_2413* ym2413;
ym2413 = new YM_2413;
ym2413->mixer = mixer;
ym2413->handle = mixerRegisterChannel(mixer, MIXER_CHANNEL_MSXMUSIC, 0, ym2413Sync, ym2413);
ym2413->ym2413->setSampleRate(AUDIO_SAMPLERATE, boardGetYm2413Oversampling());
ym2413->ym2413->setVolume(32767 * 9 / 10);
return ym2413;
}
void ym2413Destroy(YM_2413* ym2413)
{
mixerUnregisterChannel(ym2413->mixer, ym2413->handle);
delete ym2413;
}
| [
"[email protected]",
"timbrug@c2eab908-c631-11dd-927d-974589228060"
] | [
[
[
1,
27
],
[
29,
31
],
[
38,
63
],
[
66,
110
],
[
112,
120
],
[
122,
153
],
[
155,
157
],
[
159,
159
],
[
161,
171
],
[
173,
182
]
],
[
[
28,
28
],
[
32,
37
],
[
64,
65
],
[
111,
111
],
[
121,
121
],
[
154,
154
],
[
158,
158
],
[
160,
160
],
[
172,
172
]
]
] |
21e73c91cd7adcf7c8b4c0ef2a7ae1290c367cb8 | 15732b8e4190ae526dcf99e9ffcee5171ed9bd7e | /SRC/Trace_Stats/time-value-graph.cc | 378bc4d86b5c801c4509d3c92f211e283eea8839 | [] | no_license | clovermwliu/whutnetsim | d95c07f77330af8cefe50a04b19a2d5cca23e0ae | 924f2625898c4f00147e473a05704f7b91dac0c4 | refs/heads/master | 2021-01-10T13:10:00.678815 | 2010-04-14T08:38:01 | 2010-04-14T08:38:01 | 48,568,805 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,608 | cc | //Copyright (c) 2010, Information Security Institute of Wuhan Universtiy(ISIWhu)
//All rights reserved.
//
//PLEASE READ THIS DOCUMENT CAREFULLY BEFORE UTILIZING THE PROGRAM
//BY UTILIZING THIS PROGRAM, YOU AGREE TO BECOME BOUND BY THE TERMS OF
//THIS LICENSE. IF YOU DO NOT AGREE TO THE TERMS OF THIS LICENSE, DO
//NOT USE THIS PROGRAM OR ANY PORTION THEREOF IN ANY FORM OR MANNER.
//
//This License allows you to:
//1. Make copies and distribute copies of the Program's source code provide that any such copy
// clearly displays any and all appropriate copyright notices and disclaimer of warranty as set
// forth in this License.
//2. Modify the original copy or copies of the Program or any portion thereof ("Modification(s)").
// Modifications may be copied and distributed under the terms and conditions as set forth above.
// Any and all modified files must be affixed with prominent notices that you have changed the
// files and the date that the changes occurred.
//Termination:
// If at anytime you are unable to comply with any portion of this License you must immediately
// cease use of the Program and all distribution activities involving the Program or any portion
// thereof.
//Statement:
// In this program, part of the code is from the GTNetS project, The Georgia Tech Network
// Simulator (GTNetS) is a full-featured network simulation environment that allows researchers in
// computer networks to study the behavior of moderate to large scale networks, under a variety of
// conditions. Our work have great advance due to this project, Thanks to Dr. George F. Riley from
// Georgia Tech Research Corporation. Anyone who wants to study the GTNetS can come to its homepage:
// http://www.ece.gatech.edu/research/labs/MANIACS/GTNetS/
//
//File Information:
//
//
//File Name:
//File Purpose:
//Original Author:
//Author Organization:
//Construct Data:
//Modify Author:
//Author Organization:
//Modify Data:
// Implement a Time-Value statistics object, that graphs using Qt
// George F. Riley, Georgia Tech, Fall 2004
#include <iostream>
#ifdef HAVE_QT
#include "GUI_Defs.h"
#endif
#include "G_debug.h"
#include "time-value-graph.h"
#include "simulator.h"
using namespace std;
TimeValueGraph::TimeValueGraph(double xmin1, double xmax1,
double ymin1, double ymax1)
: QTChildWindow(), xmin(xmin1), xmax(xmax1), ymin(ymin1), ymax(ymax1),
lastRecordTime(0), timeLine(nil)
{
}
TimeValueGraph::~TimeValueGraph()
{
#ifdef HAVE_QT /* not necessay but quietens compiler warnings */
if (timeLine) delete timeLine;
#endif
}
// Interited from TimeValueStats
bool TimeValueGraph::Record(Time_t t, double v) // Record the time and value
{
bool r = TimeValueStats::Record(t, v);
#ifdef HAVE_QT
// Add a new rectangle
if (t < xmax)
{
double w = width * (t-lastRecordTime) / xmax;
if (w < 1) w = 1;
double h = height * v / ymax;
double x = width * lastRecordTime / xmax;
MyCanvasRectangle* r = new MyCanvasRectangle(canvas);
r->setSize((int)w, (int)-h);
r->moveBy(x, height);
r->setPen(QPen(Qt::black));
r->setBrush(Qt::red);
r->show();
items.push_back(r);
canvas->update();
}
#endif
lastRecordTime = t;
return r;
}
void TimeValueGraph::Reset() // Clear all values
{
TimeValueStats::Reset();
#ifdef HAVE_QT
for (CanvasItemVec_t::size_type i = 0; i < items.size(); ++i)
{
delete items[i];
}
items.clear();
if (timeLine) timeLine->hide();
#endif
}
void TimeValueGraph::Update()
{
#ifdef HAVE_QT
QTChildWindow::Update();
// Move the timeLine to appropriate spot
Time_t now = Simulator::instance->Now();
double x = width * now / xmax;
if (!timeLine)
{
timeLine = new MyCanvasLine(canvas);
timeLine->setPen(QPen(Qt::black));
}
timeLine->setPoints((int)x, 0, (int)x, height);
timeLine->show();
canvas->update();
#endif
}
void TimeValueGraph::closeEvent(QCloseEvent* e)
{
DEBUG0((cout << "Hello from TVG::closeEvent" << endl));
#ifdef HAVE_QT
e->accept();
#endif
}
void TimeValueGraph::resizeEvent(QResizeEvent* e)
{
DEBUG0((cout << "Hello from TVG::resizeEvent" << endl));
#ifdef HAVE_QT
cout << "New size w " << e->size().width()
<< " h " << e->size().height() << endl;
#endif
}
Statistics* TimeValueGraph::Copy() const
{
return new TimeValueGraph(xmin, xmax, ymin, ymax);
}
| [
"pengelmer@f37e807c-cba8-11de-937e-2741d7931076"
] | [
[
[
1,
156
]
]
] |
e24483eef549c9b925b7e16d68e30b891963c06d | 51febe6598848c79ffa36890655e25ed05652d7d | /MarioBros/MarioBros/Clumn.h | 488866a30a3be8dc03afb95199c8240d3c402f41 | [] | no_license | vohoangviet/game-mario-directx | d6db92457ad10fa97d2241394a2c46457fdbe2c3 | e7ad07e7335cd7a2c0cb6b3d1a02af36798cafc4 | refs/heads/master | 2021-01-10T01:33:15.453400 | 2011-12-08T14:15:39 | 2011-12-08T14:15:39 | 43,821,369 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 384 | h | #pragma once
#include "GAnimation.h"
#include "GSprite.h"
#include "GObject.h"
#include <list>
using namespace std;
class Clumn:public GObject
{
public:
Clumn();
Clumn(float _x, float _y,float width,float height,int _ID,GSprite* _sprite);
void Render(GCamera* camera);
void ResetWhenReload(GSprite* _sprite);
void Save(fstream *fs);
void Load(fstream *fs);
}; | [
"[email protected]"
] | [
[
[
1,
18
]
]
] |
1fea50b4ad24c5029d209d44888b866ff154f232 | 91b964984762870246a2a71cb32187eb9e85d74e | /SRC/OFFI SRC!/boost_1_34_1/boost_1_34_1/boost/iostreams/positioning.hpp | 8f9467c9f0592c08e6365a509b2a3de9f2131e8d | [
"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 | 3,278 | hpp | // (C) Copyright Jonathan Turkanis 2003.
// 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/iostreams for documentation.
// Thanks to Gareth Sylvester-Bradley for the Dinkumware versions of the
// positioning functions.
#ifndef BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED
#define BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/integer_traits.hpp>
#include <boost/iostreams/detail/config/codecvt.hpp> // mbstate_t.
#include <boost/iostreams/detail/ios.hpp> // streamoff, streampos.
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
#ifdef BOOST_NO_STDC_NAMESPACE
namespace std { using ::fpos_t; }
#endif
namespace boost { namespace iostreams {
typedef boost::intmax_t stream_offset;
inline std::streamoff stream_offset_to_streamoff(stream_offset off)
{ return static_cast<stream_offset>(off); }
template<typename PosType> // Hande custom pos_type's.
inline stream_offset position_to_offset(PosType pos)
{ return std::streamoff(pos); }
#if ((defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)) && \
!defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) \
&& !defined(__QNX__) \
/**/
/* Dinkumware */
inline std::streampos offset_to_position(stream_offset off)
{
// Use implementation-specific constructor.
return std::streampos(std::mbstate_t(), off);
}
inline stream_offset fpos_t_to_offset(std::fpos_t pos)
{ // Helper function.
#if defined(_POSIX_) || (_INTEGRAL_MAX_BITS >= 64)
return pos;
#else
return _FPOSOFF(pos);
#endif
}
# if defined(_CPPLIB_VER) //--------------------------------------------------//
/* Recent Dinkumware */
inline stream_offset position_to_offset(std::streampos pos)
{
// Use implementation-specific member function seekpos().
return fpos_t_to_offset(pos.seekpos()) +
stream_offset(std::streamoff(pos)) -
stream_offset(std::streamoff(pos.seekpos()));
}
# else // # if defined(_CPPLIB_VER) //----------------------------------------//
/* Old Dinkumware */
inline stream_offset position_to_offset(std::streampos pos)
{
// use implementation-specific member function get_fpos_t().
return fpos_t_to_offset(pos.get_fpos_t()) +
stream_offset(std::streamoff(pos)) -
stream_offset(std::streamoff(pos.get_fpos_t()));
}
# endif // # if defined(_CPPLIB_VER) //---------------------------------------//
#else // Dinkumware //--------------------------------------------------------//
/* Non-Dinkumware */
inline std::streampos offset_to_position(stream_offset off) { return off; }
inline stream_offset position_to_offset(std::streampos pos) { return pos; }
#endif // Dinkumware //-------------------------------------------------------//
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED
| [
"[email protected]@e2c90bd7-ee55-cca0-76d2-bbf4e3699278"
] | [
[
[
1,
102
]
]
] |
0ea968e7a99bf4b84cfd97efe8fc123f4d5482e5 | 14298a990afb4c8619eea10988f9c0854ec49d29 | /PowerBill四川电信专用版本/ibill_source/EditSearchParamFrm.h | 41896fc837a872eb6b80350e448f742fd6670aa1 | [] | no_license | sridhar19091986/xmlconvertsql | 066344074e932e919a69b818d0038f3d612e6f17 | bbb5bbaecbb011420d701005e13efcd2265aa80e | refs/heads/master | 2021-01-21T17:45:45.658884 | 2011-05-30T12:53:29 | 2011-05-30T12:53:29 | 42,693,560 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,746 | h | //---------------------------------------------------------------------------
#ifndef EditSearchParamFrmH
#define EditSearchParamFrmH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include "RzPanel.hpp"
#include <ExtCtrls.hpp>
#include "RzButton.hpp"
#include "RzEdit.hpp"
#include <Mask.hpp>
#include "RzCmboBx.hpp"
#include "RzRadChk.hpp"
#include <ActnList.hpp>
#include "RzDTP.hpp"
#include <ComCtrls.hpp>
#include "BillField.h"
#include <Graphics.hpp>
//---------------------------------------------------------------------------
class TfrmEditSearchParam : public TForm
{
__published: // IDE-managed Components
TRzPanel *RzPanel1;
TLabel *Label1;
TLabel *Label2;
TLabel *Label3;
TLabel *Label4;
TRzComboBox *cbxOperator;
TRzComboBox *cbxValues;
TRzCheckBox *cbxMatch;
TRzEdit *txtContext;
TRzDateTimePicker *dtDate;
TRzDateTimePicker *dtTime;
TRzComboBox *cbxField;
TRzComboBox *cbxAndOr;
TRzBitBtn *btnQuery;
void __fastcall FormKeyPress(TObject *Sender, char &Key);
void __fastcall btnQueryClick(TObject *Sender);
void __fastcall cbxFieldChange(TObject *Sender);
bool __fastcall FormHelp(WORD Command, int Data, bool &CallHelp);
private: // User declarations
public: // User declarations
void __fastcall SetSelectedFieldIndex(TBillField * Field);
__fastcall TfrmEditSearchParam(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TfrmEditSearchParam *frmEditSearchParam;
//---------------------------------------------------------------------------
#endif
| [
"cn.wei.hp@e7bd78f4-57e5-8052-e4e7-673d445fef99"
] | [
[
[
1,
52
]
]
] |
daf645cdb64702c1b3c2d939fe713ae9462cacac | fbd2deaa66c52fc8c38baa90dd8f662aabf1f0dd | /totalFirePower/ta demo/code/ReadMap.cpp | 9766e7cb6e6c0caff6fa08f30508c7b4cf507b44 | [] | no_license | arlukin/dev | ea4f62f3a2f95e1bd451fb446409ab33e5c0d6e1 | b71fa9e9d8953e33f25c2ae7e5b3c8e0defd18e0 | refs/heads/master | 2021-01-15T11:29:03.247836 | 2011-02-24T23:27:03 | 2011-02-24T23:27:03 | 1,408,455 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 7,782 | cpp | // ReadMap.cpp: implementation of the CReadMap class.
//
//////////////////////////////////////////////////////////////////////
#include "windows.h"
#include "mygl.h"
#include <gl\glu.h> // Header file for the gLu32 library
#include <gl\glaux.h> // Header File For The Glaux Library
#include "ReadMap.h"
#include <stdlib.h>
#include <math.h>
#include "float3.h"
#include <ostream>
#include "tapalette.h"
#include "hpihandler.h"
#include "irenderer.h"
#include "bitmap.h"
#include "featurehandler.h"
#include "reghandler.h"
using namespace std;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CReadMap* readmap;
CReadMap* CReadMap::_instance=0;
CReadMap* CReadMap::Instance()
{
if(_instance==0){
_instance=new CReadMap();
readmap=_instance;
}
return _instance;
}
CReadMap::CReadMap()
{
int y;
PrintLoadMsg("Opening map file");
string mapname="maps\\tetra.tnt";
if(g.shared){
mapname=g.shared->mapname;
}
int fsize=hpiHandler->GetFileSize(mapname);
if(fsize==0){
char t[700];
if(mapname=="")
sprintf(t,"The map name is empty. Make sure 3dta har been initilized correctly inside TA");
else
sprintf(t,"Couldnt find the file %s. Make sure that the regkey HKEY_LOCAL_MACHINE\\Software\\Microsoft\\DirectPlay\\Applications\\Total Annihilation\\path is setup correctly and that all files resides inside container files in your TA root folder (ie not on CD or unpacked in subfolders) and that the container files have the extensions gp3/ccx/ufo/hpi",mapname.c_str());
MessageBox(0,t,"Error opening map",0);
return;
}
unsigned char* fileBuf=new unsigned char[fsize+1];
hpiHandler->LoadFile(mapname,fileBuf);
int IDversion=*(int*)&fileBuf[0];
int Width=*(int*)&fileBuf[4];
int Height=*(int*)&fileBuf[8];
int PTRmapdata=*(int*)&fileBuf[12];
int PTRmapattr=*(int*)&fileBuf[16];
int PTRtilegfx=*(int*)&fileBuf[20];
int tiles =*(int*)&fileBuf[24];
int tileanims =*(int*)&fileBuf[28];
int PTRtileanim=*(int*)&fileBuf[32];
int sealevel =*(int*)&fileBuf[36]-1;
int PTRminimap =*(int*)&fileBuf[40];
g.mapx=Width+1;
g.mapy=Height+1;
g.seaLevel=sealevel;
/*
char rt[500];
sprintf(rt,"%d %d",Width,Height);
MessageBox(0,rt,"",0);
*/
int mapsize=(g.mapx+1)*(g.mapy+9);
if(mapsize<513*513)
mapsize=513*513;
map=new float[mapsize];
normals=new float3[mapsize];
facenormals=new float3[mapsize*2];
tile=new unsigned short[mapsize/4];
int heightStart=PTRmapattr;
int tileStart=PTRmapdata;
numtiles=tiles;
union mapInfo{
int data;
unsigned char height;
};
mapInfo rad[4000];
PrintLoadMsg("Loading height+feature data");
for(y=0;y<Height;y++){
int place=heightStart+4*((y)*Width);
memcpy(rad,&fileBuf[place],4*Width);
for(int x=0;x<Width;x++){
map[y*g.mapx+x]=rad[x].height;
}
map[y*g.mapx+Width]=rad[Width-1].height;
}
for(int x=0;x<Width;x++){
map[y*g.mapx+x]=rad[x].height;
}
map[y*g.mapx+Width]=rad[Width-1].height;
if(regHandler.GetInt("FilterMap",1)){
float* map2=new float[mapsize];
for(int a=0;a<mapsize;++a)
map2[a]=map[a];
int h;
for(y=1;y<g.mapy-1;y++){
for(int x=0;x<g.mapx-1;x++){
h =map2[(y-1)*g.mapx+x-1];
h+=map2[(y-1)*g.mapx+x];
h+=map2[(y-1)*g.mapx+x+1];
h+=map2[(y)*g.mapx+x-1];
h+=map2[(y)*g.mapx+x]*2;
h+=map2[(y)*g.mapx+x+1];
h+=map2[(y+1)*g.mapx+x-1];
h+=map2[(y+1)*g.mapx+x];
h+=map2[(y+1)*g.mapx+x+1];
map[(y)*g.mapx+x]=h*0.1;
}
}
delete[] map2;
}
PrintLoadMsg("Loading tiles");
int place=tileStart;
memcpy(tile,&fileBuf[place],g.mapx*(g.mapy>>1));
PrintLoadMsg("Creating tile textures");
unsigned char* memtex=new unsigned char[32*32*tiles+1];
tileData[0]=new unsigned char[32*32*4*tiles];
memcpy(memtex,&fileBuf[PTRtilegfx],32*32*tiles);
for(int a=0;a<32*32*tiles;++a){
tileData[0][a*4+0]=palette[memtex[a]][0];
tileData[0][a*4+1]=palette[memtex[a]][1];
tileData[0][a*4+2]=palette[memtex[a]][2];
tileData[0][a*4+3]=255;
}
int tsize=32*32*tiles*4;
int rowsize=32;
for(a=1;a<4;++a){
tsize/=4;
rowsize/=2;
tileData[a]=new unsigned char[tsize];
for(int row=0;row<tsize/rowsize/4;++row){
int rowstart=row*rowsize;
int rowstart2=row*rowsize*4;
int rowstart3=row*rowsize*4+rowsize*2;
for(int b=0;b<rowsize;++b)
for(int c=0;c<4;++c)
tileData[a][(rowstart+b)*4+c]=((int)tileData[a-1][(rowstart2+b*2)*4+c]+(int)tileData[a-1][(rowstart2+b*2+1)*4+c]+(int)tileData[a-1][(rowstart3+b*2)*4+c]+(int)tileData[a-1][(rowstart3+b*2+1)*4+c])/4;
}
}
PrintLoadMsg("Creating overhead texture");
char* bt=new char[1024*1024*4];
int xpixs=Width*16/1024/2;
int ypixs=Height*16/1024/2;
for(y=0;y<1024;y++){
for(int x=0;x<1024;x++){
unsigned int col[]={0,0,0};
for(int y2=0;y2<ypixs;++y2){
for(int x2=0;x2<xpixs;++x2){
unsigned int ypix=(y*Height*16/1024/2+y2);
unsigned int xpix=(x*Width*16/1024/2+x2);
unsigned int t=tile[(ypix/16)*(Width>>1)+(xpix/16)];
unsigned int ypixel=ypix&15;
unsigned int xpixel=xpix&15;
for(int c=0;c<3;++c)
col[c]+=tileData[1][(t*16*16+ypixel*16+xpixel)*4+c];
}
}
for(int c=0;c<3;++c)
bt[((y)*1024+x)*4+c]=col[c]/(xpixs*ypixs);
}
}
glGenTextures(1, &bigtex);
glBindTexture(GL_TEXTURE_2D, bigtex);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D,0, 4,1024, 1024,0, GL_RGBA, GL_UNSIGNED_BYTE, bt);
delete[] memtex;
delete[] bt;
featureHandler.LoadFeatures(fileBuf,PTRmapattr,PTRtileanim,tileanims);
delete[] fileBuf;
PrintLoadMsg("Creating surface normals");
float3 n1,n2,n3,n4;
for(y=0;y<g.mapy;y++)
for(int x=0;x<g.mapx;x++)
normals[y*g.mapx+x]=float3(0,1,0);
for(y=0;y<g.mapy-1;y++)
for(int x=0;x<g.mapx-1;x++){
facenormals[(y*(g.mapx-1)+x)*2]=float3(0,1,0);
facenormals[(y*(g.mapx-1)+x)*2+1]=float3(0,1,0);
}
for(y=1;y<g.mapy-1;y++){
for(int x=1;x<g.mapx-1;x++){
float myz=map[y*g.mapx+x];
float3 e1(-SQUARE_SIZE,map[y*g.mapx+x-1]-myz,0);
float3 e2( SQUARE_SIZE,map[y*g.mapx+x+1]-myz,0);
float3 e3(0,map[(y-1)*g.mapx+x]-myz,-SQUARE_SIZE);
float3 e4(0,map[(y+1)*g.mapx+x]-myz, SQUARE_SIZE);
n1=e3.cross(e1);
n1.Normalize();
n2=e4.cross(e2);
n2.Normalize();
n3=e2.cross(e3);
n3.Normalize();
n4=e1.cross(e4);
n4.Normalize();
facenormals[(y*(g.mapx-1)+x)*2]=n2;
// if((x-1>=0) && (y-1>=0))
facenormals[((y-1)*(g.mapx-1)+x-1)*2+1]=n1;
normals[y*g.mapx+x]=n1+n2+n3+n4;
normals[y*g.mapx+x].Normalize();
}
}
PrintLoadMsg("Loading detail texture");
glGenTextures(1, &detailtex);
CBitmap bm("bitmaps\\detailtex.jpg");
// create mipmapped texture
glBindTexture(GL_TEXTURE_2D, detailtex);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D,4 ,bm.xsize, bm.ysize, GL_RGBA, GL_UNSIGNED_BYTE, bm.mem);
}
CReadMap::~CReadMap()
{
glDeleteTextures (1, &bigtex);
glDeleteTextures (1, &detailtex);
delete[] map;
delete[] tile;
delete[] normals;
delete[] facenormals;
for(int a=0;a<4;++a)
delete[] tileData[a];
}
| [
"[email protected]"
] | [
[
[
1,
283
]
]
] |
97f9b963f647935782f94ce5657e35ed7ab5e797 | fc4946d917dc2ea50798a03981b0274e403eb9b7 | /gentleman/gentleman/WindowsAPICodePack/WindowsAPICodePack/DirectX/DirectX/WIC/WICBitmapDecoder.cpp | 111a9cbf7f4435b9e7f09c0e891f4d6659af8a05 | [] | no_license | midnite8177/phever | f9a55a545322c9aff0c7d0c45be3d3ddd6088c97 | 45529e80ebf707e7299887165821ca360aa1907d | refs/heads/master | 2020-05-16T21:59:24.201346 | 2010-07-12T23:51:53 | 2010-07-12T23:51:53 | 34,965,829 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 746 | cpp | // Copyright (c) Microsoft Corporation. All rights reserved.
#include "stdafx.h"
#include "WICBitmapDecoder.h"
using namespace Microsoft::WindowsAPICodePack::DirectX::WindowsImagingComponent;
unsigned int BitmapDecoder::FrameCount::get( )
{
unsigned int frameCount = 0;
CommonUtils::VerifyResult(
GetInterface<IWICBitmapDecoder>()->GetFrameCount( &frameCount ) );
return frameCount;
}
BitmapFrameDecode^ BitmapDecoder::GetFrame( unsigned int index )
{
IWICBitmapFrameDecode* pFrameDecode = NULL;
CommonUtils::VerifyResult(
GetInterface<IWICBitmapDecoder>()->GetFrame( index, &pFrameDecode ) );
return pFrameDecode == NULL ? nullptr : gcnew BitmapFrameDecode(pFrameDecode);
}
| [
"lucemia@9e708c16-f4dd-11de-aa3c-59de0406b4f5"
] | [
[
[
1,
23
]
]
] |
591d18f8fed13852ac141a35851137a53dd2a052 | 965bcb2cd3d377b03840ae3899bc1243d2b6203d | /engineTest/engineTest/agentSteeringBehaviors.cpp | c73945b88c9a53ae1e8686b26151fb1fc262e88c | [] | no_license | VirtuosoChris/gameaiproject1 | 42cd6245a824e2a5c09384b1f756a31b4ec904e7 | 789a6a420559bf32e15fa56db64c7c063df668e7 | refs/heads/master | 2020-06-01T19:00:15.998072 | 2009-04-19T19:25:29 | 2009-04-19T19:25:29 | 32,121,286 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,906 | cpp | #include "agent.h"
#include "cpMath.h"
#include "coverObject.h"
//generates a seek steering force
irr::core::vector3df Agent::seek(irr::core::vector3df tp){
if(tp == mynodep->getPosition())
return vector3df(0,0,0);
//irr::f32 MAXSPEED = .3f;
irr::core::vector3df target = tp - mynodep->getPosition();
target.Y = 0;
if(target.getLength() == 0)
return vector3df(0,0,0);
target.normalize();
target*=ACCELRATE;
//irr::f32 mass = 10.0f;
irr::core::vector3df accel = (target-velocity);
accel/=mass;
//accel*= (tp - mynodep->getPosition()).getLength()*.05;
return accel;
}
//generates a flee steering force
irr::core::vector3df Agent::flee(irr::core::vector3df tp){
if(tp == mynodep->getPosition())
return vector3df(0,0,0);
//irr::f32 MAXSPEED = .3f;
irr::core::vector3df target = -tp + mynodep->getPosition();
target.Y = 0;
if(target.getLength() == 0)
return vector3df(0,0,0);
target.normalize();
target*=ACCELRATE;
//irr::f32 mass = 10.0f;
irr::core::vector3df accel = (target-velocity);
accel/=mass;
//accel*= (tp - mynodep->getPosition()).getLength()*.05;
return accel;
}
//updates animation/rotation, moves the agent along its velocity
void Agent::walk(irr::core::vector3df accel){
if(!(velocity+(accel*TIMEELAPSED)).getLength() == 0.0f){ velocity += accel*TIMEELAPSED; if(velocity.getLength() > MAXSPEED){ velocity = velocity.normalize()*MAXSPEED; } }
else{ velocity = vector3df(0,0,0); } if(velocity.getLength() > .01f){ irr::core::vector3df ppos = mynodep->getPosition(); mynodep->setPosition(mynodep->getPosition() + (TIMEELAPSED * velocity)); position = mynodep->getPosition(); mynodep->setPosition( ppos + (TIMEELAPSED * velocity)); if(!MOVING){ MOVING= true; ((irr::scene::IAnimatedMeshSceneNode*)mynodep)->setMD2Animation(scene::EMAT_RUN); } } else if(MOVING){ MOVING = false; ((irr::scene::IAnimatedMeshSceneNode*)mynodep)->setMD2Animation(scene::EMAT_STAND); } vector3df abc = velocity;//SEEK_POS - mynodep->getPosition(); abc.Y = 0; abc = abc.normalize(); double tAngle = radiansToDegrees(acos(fabs(abc.X)));
switch( quadrant(velocity.normalize() ) ){ case 1: break; case 2: tAngle = 180-tAngle; break; case 3: tAngle = 180+tAngle; break; case 4: tAngle = 360-tAngle; break; default:; }
if(velocity.getLength()!=0){ orientation = tAngle; mynodep->setRotation(irr::core::vector3df(0.0f,(irr::f32)fabs(360-orientation),0.0f)); } position = mynodep->getPosition();}
irr::core::vector3df Agent::wallAvoidance(){
irr::core::vector3df wallavoidaccel;
wallavoidaccel = vector3df(0,0,0);
for(int i = 0; i < s1d->getNumFeelers(); i++){
//if(s1d->feelerDistances[i] < 50){
//wallavoidaccel+=s1d->triangle[i].getNormal()*(1/(s1d->feelerDistances[i]*s1d->feelerDistances[i]));
//if(velocity.getLength() - s1d->feelerDistances[i] > 0.0){
double tmp = (s1d->maxRange - s1d->feelerDistances[i]);
tmp/=5000000;//1
//if(tmp>0.0f){
wallavoidaccel+=s1d->triangle[i].getNormal()*tmp;
//std::cout<<s1d->feelerDistances[i]<<"\n";
//}
//}
//}
} wallavoidaccel.Y = 0; //wallavoidaccel = wallavoidaccel.normalize(); if(wallavoidaccel.getLength() > .025f){ wallavoidaccel = wallavoidaccel.normalize(); wallavoidaccel*=.025f; } if(wallavoidaccel.getLength() != 0){ //std::cout<<wallavoidaccel.getLength()<<"\n"; } return wallavoidaccel;}
static const double EXTRA_RADIUS = 30;
irr::core::vector3df Agent::followPath(const irr::ITimer* timer){ //seek to the current seek target vector3df tp = currentSeekTarget; tp.Y = 0; vector3df ap = mynodep->getPosition(); ap.Y = 0; tp = tp-ap; core::vector3df tv = (-mynodep->getPosition() + currentSeekTarget); tv.Y = 0; if(tv.getLength()<RADIUS){ if(!pathList.empty()){ //std::cout<<"popping node off list\n"; previousSeekTarget = currentSeekTarget;//mynodep->getPosition(); currentSeekTarget = pathList.front(); pathList.erase(pathList.begin()); //ZOMG WTF obscure bug avoidance tip #666 : don't use list.remove(pathList.begin()) when you mean list.erase(pathList.begin()) //std::cout<<"Arrival\n"; int p = this->graph->getClosestNode(previousSeekTarget); int q = this->graph->getClosestNode(currentSeekTarget); //std::cout<<"Going from"<<p<<"to"<<q<<std::endl; //if(graph->adjacencyList[p][q]){ //std::cout<<"ok\n"; //}else{ //std::cout<<"WTF BAD EDGE POPPED\n"; //} this->pathStartTime = timer->getTime(); this->expectedArrivalTime = pathStartTime+(currentSeekTarget - this->getPosition()).getLength() / MAXSPEED; } else{ velocity = core::vector3df(0,0,0); currentSeekTarget = mynodep->getPosition(); previousSeekTarget = mynodep->getPosition(); this->pathStartTime = timer->getTime(); this->expectedArrivalTime = pathStartTime+(currentSeekTarget - this->getPosition()).getLength() / MAXSPEED; } }
//check to see if the path needs to be corrected if( (timer->getTime() - this->pathStartTime) > TIMEMULTIPLIER*(this->expectedArrivalTime - this->pathStartTime) ){ this->pathStartTime = timer->getTime(); correctPath(); this->expectedArrivalTime = pathStartTime+(pathList.front() - this->getPosition()).getLength() / MAXSPEED; }
irr::core::vector3df accel; accel = seek(currentSeekTarget) + wallAvoidance();
/////////////////////////////////////////////////begin new obstacle avoidance code:keeping this isolated! if( timer->getTime() - this->LAST_OBSTACLE_CORRECTANCE > 2000){ //create the line from the agent extending outward through its velocity irr::core::line3d<irr::f32> line; line.start = mynodep->getPosition(); line.end = line.start + (this->getVelocity().normalize() *(coverObject::getRadius() + 50));
//get the scene node it intersects irr::scene::ISceneNode* tnode; tnode= smgr->getSceneCollisionManager()->getSceneNodeFromRayBB(line); coverObject* coverObj= NULL;
if(tnode){ //get the cover object it represents; for(int i = 0; i < (*this->coverObjectList).size(); i++){ if(tnode == (*this->coverObjectList)[i]->getSceneNode()){ coverObj = (*this->coverObjectList)[i]; break; } } //if its a cover object if(coverObj){ //and i'm close to it if( (this->getSceneNode()->getPosition() - coverObj->getSceneNode()->getPosition()).getLength() < coverObj->getBoundaryRadius()){ std::cout<<"I'm too near the cover objects!\n"; irr::core::vector3df startVector; irr::core::vector3df endVector;
startVector = mynodep->getPosition() - coverObj->getSceneNode()->getPosition();
startVector = startVector.normalize();
endVector = this->currentSeekTarget - coverObj->getSceneNode()->getPosition();
endVector = endVector.normalize();
double startAngle = vectorAngle(startVector);
double endAngle = vectorAngle(endVector);
const double nodeCount = 8;
//get the angle of each of these vectors so we can generate a path correction arc
std::list<irr::core::vector3df> result(nodeCount);
const irr::core::vector3df& canPos =coverObj->getSceneNode()->getPosition();
double increment = (startAngle - endAngle) / nodeCount;
for(int i = 0; i < nodeCount; i++){ double currentAngle = endAngle + increment*i; //this->pathListAvd.push_front( //result.push_back( pathList.push_front( (coverObj->getBoundaryRadius() + EXTRA_RADIUS)*vector3df( cos(currentAngle) ,0,sin(currentAngle) ) + canPos); //irr::scene::ISceneNode* a = this->smgr->addSphereSceneNode(5); //a->setPosition(result.back()); } previousSeekTarget = mynodep->getPosition(); currentSeekTarget = pathList.front(); this->pathStartTime = timer->getTime(); this->expectedArrivalTime = pathStartTime+(currentSeekTarget - this->getPosition()).getLength() / MAXSPEED; this->LAST_OBSTACLE_CORRECTANCE = timer->getTime(); this->setVelocity(vector3df(0,0,0)); } } } } /////////////////////////////////////////end new obstacle avoidance code return accel;}
irr::core::vector3df Agent::pursue(physicsObject* tgt){
const double constant = 1.0f;
double lookAheadTime = (this->getPosition() - tgt->getPosition()).getLength();
lookAheadTime /= (.45);//(this->getVelocity().getLength() + tgt->getVelocity().getLength());
lookAheadTime *= constant;
return seek(tgt->getPosition() + lookAheadTime* tgt->getVelocity());
}
irr::core::vector3df Agent::avoid(physicsObject* tgt){
const double constant = 1.0f; double lookAheadTime = (this->getPosition() - tgt->getPosition()).getLength();
lookAheadTime /= (this->getVelocity().getLength() + tgt->getVelocity().getLength());
lookAheadTime *= constant;
return flee(tgt->getPosition() + lookAheadTime* tgt->getVelocity());
}
irr::core::vector3df Agent::hide(){
if(!myCoverObject)
return vector3df(0,0,0);
return this->seek(myCoverObject->getCoverPosition(this->getIt()));
}
| [
"ChrisPugh666@be266342-eca9-11dd-a550-c997509ed985",
"javidscool@be266342-eca9-11dd-a550-c997509ed985"
] | [
[
[
1,
6
],
[
10,
11
],
[
17,
27
],
[
31,
31
],
[
38,
48
],
[
53,
55
],
[
65,
71
],
[
73,
73
],
[
76,
76
],
[
91,
91
],
[
93,
93
],
[
95,
95
],
[
98,
106
],
[
108,
111
],
[
113,
119
],
[
121,
121
],
[
123,
125
]
],
[
[
7,
9
],
[
12,
16
],
[
28,
30
],
[
32,
37
],
[
49,
52
],
[
56,
64
],
[
72,
72
],
[
74,
75
],
[
77,
90
],
[
92,
92
],
[
94,
94
],
[
96,
97
],
[
107,
107
],
[
112,
112
],
[
120,
120
],
[
122,
122
],
[
126,
128
]
]
] |
2cc1c0feb1f08b0d4a4d3b2735adb7e9a2ac86ac | 5a05acb4caae7d8eb6ab4731dcda528e2696b093 | /ThirdParty/luabind/luabind/detail/property.hpp | 683e65fab40a112ffb1f91fa29aa119370a645d5 | [] | no_license | andreparker/spiralengine | aea8b22491aaae4c14f1cdb20f5407a4fb725922 | 36a4942045f49a7255004ec968b188f8088758f4 | refs/heads/master | 2021-01-22T12:12:39.066832 | 2010-05-07T00:02:31 | 2010-05-07T00:02:31 | 33,547,546 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 837 | hpp | // Copyright Daniel Wallin 2008. 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)
#ifndef LUABIND_PROPERTY_081020_HPP
# define LUABIND_PROPERTY_081020_HPP
namespace luabind
{
namespace detail
{
template < class Class, class T, class Result = T >
struct access_member_ptr
{
access_member_ptr( T Class::* mem_ptr )
: mem_ptr( mem_ptr )
{}
Result operator()( Class const& x ) const
{
return const_cast<Class&>( x ).*mem_ptr;
}
void operator()( Class& x, T const& value ) const
{
x.*mem_ptr = value;
}
T Class::* mem_ptr;
};
}
} // namespace luabind::detail
#endif // LUABIND_PROPERTY_081020_HPP
| [
"DreLnBrown@e933ee44-1dc6-11de-9e56-bf19dc6c588e"
] | [
[
[
1,
37
]
]
] |
42d53e0799a30d748e079a317ec5597c6e16781e | 6777a1d08a287959ad5db2cbbb29f529e3ab5e3c | /mspv21_midrcp/arm9/source/main.cpp | 27be41c5e90d543d28710c183c237ef60cf0f8dd | [] | no_license | btuduri/codecomposer | 07d6b68c0b836ae92429b6123b7a78094acb4e0c | b3225b456da3d77f5cc13c3d1b1c0d5291dc0277 | refs/heads/master | 2016-09-09T18:52:07.106499 | 2008-07-03T16:49:43 | 2008-07-03T16:49:43 | 32,828,244 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 19,025 | cpp |
#include <stdio.h>
#include <NDS.h>
#include "_const.h"
#include "plugin.h"
#include "plugin_def.h"
#include "std.h"
#include "inifile.h"
#include "smidlib.h"
#include "rcplib.h"
// CallBack from plugin_dll.cpp
void cbLoadLibrary(void)
{
}
void cbFreeLibrary(void)
{
}
void cbQueryInterfaceLibrary(void)
{
}
// -----------------
static u8 *DeflateBuf=NULL;
static u32 DeflateSize;
static u32 SamplePerFrame;
static int TotalClock,CurrentClock;
static u32 ClockCur;
enum EFileFormat {EFF_MID,EFF_RCP};
static EFileFormat FileFormat;
#define MaxSampleRate (32768)
#define MinFramePerSecond (120)
#define MaxSamplePerFrame (MaxSampleRate/MinFramePerSecond)
static ALIGNED_VAR_IN_DTCM s32 DTCM_tmpbuf[MaxSamplePerFrame*2];
static ALIGNED_VAR_IN_DTCM s32 DTCM_dstbuf[MaxSamplePerFrame*2];
static u32 StackIndex;
static u32 StackCount;
#define MaxStackCount (12)
static s32 *pStackBuf[ChannelsCount][MaxStackCount];
static s32 StackLastCount[ChannelsCount];
// --------------------------------------------------------------------
// ------------------------------------------------------------------------------------
void Free(void);
static void selSetParam(u8 *data,u32 SampleRate,u32 SampleBufCount,u32 MaxChannelCount,u32 GenVolume)
{
switch(FileFormat){
case EFF_MID: smidlibSetParam(DeflateBuf,SampleRate,SampleBufCount,MaxChannelCount,GenVolume); break;
case EFF_RCP: rcplibSetParam(DeflateBuf,SampleRate,SampleBufCount,MaxChannelCount,GenVolume); break;
}
}
static bool selStart(void)
{
switch(FileFormat){
case EFF_MID: return(smidlibStart()); break;
case EFF_RCP: return(rcplibStart()); break;
}
return(false);
}
static void selFree(void)
{
switch(FileFormat){
case EFF_MID: smidlibFree(); break;
case EFF_RCP: rcplibFree(); break;
}
}
static int selGetNearClock(void)
{
switch(FileFormat){
case EFF_MID: return(smidlibGetNearClock()); break;
case EFF_RCP: return(rcplibGetNearClock()); break;
}
return(0);
}
static bool selNextClock(bool ShowEventMessage,bool EnableNote,int DecClock)
{
switch(FileFormat){
case EFF_MID: return(smidlibNextClock(ShowEventMessage,EnableNote,DecClock)); break;
case EFF_RCP: return(rcplibNextClock(ShowEventMessage,EnableNote,DecClock)); break;
}
return(false);
}
static void selAllSoundOff(void)
{
switch(FileFormat){
case EFF_MID: smidlibAllSoundOff(); break;
case EFF_RCP: rcplibAllSoundOff(); break;
}
}
static bool sel_isAllTrackEOF(void)
{
switch(FileFormat){
case EFF_MID: return(SM_isAllTrackEOF()); break;
case EFF_RCP: return(RCP_isAllTrackEOF()); break;
}
return(false);
}
static u32 sel_GetSamplePerClockFix16(void)
{
switch(FileFormat){
case EFF_MID: return(SM_GetSamplePerClockFix16()); break;
case EFF_RCP: return(RCP_GetSamplePerClockFix16()); break;
}
return(0);
}
static void Start_smidlibDetectTotalClock()
{
TSM_Track *pSM_Track=NULL;
u32 trklen=0;
{
for(u32 idx=0;idx<StdMIDI.SM_Chank.Track;idx++){
TSM_Track *pCurSM_Track=&StdMIDI.SM_Tracks[idx];
u32 ctrklen=(u32)pCurSM_Track->DataEnd-(u32)pCurSM_Track->Data;
if(trklen<ctrklen){
trklen=ctrklen;
pSM_Track=pCurSM_Track;
}
}
}
if((pSM_Track==NULL)||(trklen==0)){
_consolePrintf("Fatal error.\n");
ShowLogHalt();
}
MWin_ProgressShow("Loading...",trklen);
int LastClock=0;
int PrevDiv=StdMIDI.SM_Chank.TimeRes*8;
while(1){
if(PrevDiv<(TotalClock-LastClock)){
LastClock=TotalClock;
u32 lastlen=(u32)pSM_Track->DataEnd-(u32)pSM_Track->Data;
if(lastlen<trklen) MWin_ProgressSetPos(trklen-lastlen);
}
int DecClock=smidlibGetNearClock();
if(smidlibNextClock(false,false,DecClock)==false) break;
TotalClock+=DecClock;
}
MWin_ProgressHide();
}
static void Start_rcplibDetectTotalClock()
{
TRCP_Track *pRCP_Track=NULL;
u32 trklen=0;
{
for(u32 idx=0;idx<RCP_Chank.TrackCount;idx++){
TRCP_Track *pCurRCP_Track=&RCP.RCP_Track[idx];
u32 ctrklen=(u32)pCurRCP_Track->DataEnd-(u32)pCurRCP_Track->Data;
if(trklen<ctrklen){
trklen=ctrklen;
pRCP_Track=pCurRCP_Track;
}
}
}
if((pRCP_Track==NULL)||(trklen==0)){
_consolePrintf("Fatal error.\n");
ShowLogHalt();
}
MWin_ProgressShow("Loading...",trklen);
int LastClock=0;
int PrevDiv=RCP_Chank.TimeRes*8;
while(1){
if(PrevDiv<(TotalClock-LastClock)){
LastClock=TotalClock;
u32 lastlen=(u32)pRCP_Track->DataEnd-(u32)pRCP_Track->Data;
if(lastlen<trklen) MWin_ProgressSetPos(trklen-lastlen);
}
int DecClock=rcplibGetNearClock();
if(rcplibNextClock(false,false,DecClock)==false) break;
TotalClock+=DecClock;
}
MWin_ProgressHide();
}
bool Start_InitStackBuf(void)
{
for(u32 ch=0;ch<ChannelsCount;ch++){
for(u32 sidx=0;sidx<MaxStackCount;sidx++){
pStackBuf[ch][sidx]=NULL;
}
}
StackCount=GlobalINI.MIDPlugin.DelayStackSize;
if(StackCount==0) StackCount=1;
if(MaxStackCount<StackCount) StackCount=MaxStackCount;
for(u32 ch=0;ch<ChannelsCount;ch++){
for(u32 sidx=0;sidx<StackCount;sidx++){
pStackBuf[ch][sidx]=(s32*)safemalloc((MaxSamplePerFrame+1)*2*4);
if(pStackBuf[ch][sidx]==NULL){
_consolePrintf("pStackBuf: Memory overflow.\n");
return(false);
}
MemSet32CPU(0,pStackBuf[ch][sidx],(MaxSamplePerFrame+1)*2*4);
}
StackLastCount[ch]=0;
}
StackIndex=0;
return(true);
}
#define ReserveCount (4)
static void *pReserve[ReserveCount];
static u32 SoundFontLoadTimeus;
bool Start(int FileHandle)
{
InitINI();
LoadINI(GetINIData(),GetINISize());
if(Start_InitStackBuf()==false) return(false);
TiniMIDPlugin *MIDPlugin=&GlobalINI.MIDPlugin;
{
if(MaxSampleRate<MIDPlugin->SampleRate) MIDPlugin->SampleRate=MaxSampleRate;
SamplePerFrame=MIDPlugin->SampleRate/MIDPlugin->FramePerSecond;
if(MaxSamplePerFrame<SamplePerFrame) SamplePerFrame=MaxSamplePerFrame;
SamplePerFrame&=~15;
if(SamplePerFrame<16) SamplePerFrame=16;
}
{
u32 samples=SamplePerFrame+16;
pReserve[0]=safemalloc(samples*8*2);
pReserve[1]=safemalloc(samples*8*2);
pReserve[2]=safemalloc(samples*2);
pReserve[3]=safemalloc(samples*2);
}
fseek(FileHandle,0,SEEK_END);
DeflateSize=ftell(FileHandle);
fseek(FileHandle,0,SEEK_SET);
DeflateBuf=(u8*)safemalloc(DeflateSize);
if(DeflateBuf==NULL) return(false);
fread(DeflateBuf,1,DeflateSize,FileHandle);
if(GetBINFileHandle()==0){
_consolePrintf("not found sound font file. 'midrcp.bin'\n");
if(DeflateBuf!=NULL){
safefree(DeflateBuf); DeflateBuf=NULL;
}
return(false);
}
PCH_SetProgramMap(GetBINFileHandle());
{
bool detect=false;
if(strncmp((char*)DeflateBuf,"MThd",4)==0){
_consolePrintf("Start Standard MIDI file.\n");
detect=true;
FileFormat=EFF_MID;
}
if(strncmp((char*)DeflateBuf,"RCM-PC98V2.0(C)COME ON MUSIC",28)==0){
_consolePrintf("Start RecomposerV2.0 file.\n");
detect=true;
FileFormat=EFF_RCP;
}
if(detect==false){
_consolePrintf("Unknown file format!!\n");
PCH_FreeProgramMap();
if(DeflateBuf!=NULL){
safefree(DeflateBuf); DeflateBuf=NULL;
}
return(false);
}
}
selSetParam(DeflateBuf,MIDPlugin->SampleRate,SamplePerFrame,MIDPlugin->MaxVoiceCount,MIDPlugin->GenVolume);
if(selStart()==false){
Free();
return(false);
}
TotalClock=0;
CurrentClock=0;
PrfStart();
switch(FileFormat){
case EFF_MID: Start_smidlibDetectTotalClock(); break;
case EFF_RCP: Start_rcplibDetectTotalClock(); break;
}
SoundFontLoadTimeus=PrfEnd(0);
if(TotalClock==0){
_consolePrintf("Detect TotalClock equal Zero.\n");
Free();
return(false);
}
selFree();
selStart();
ClockCur=selGetNearClock();
selNextClock(MIDPlugin->ShowEventMessage,true,selGetNearClock());
for(u32 idx=0;idx<ReserveCount;idx++){
if(pReserve[idx]!=NULL){
safefree(pReserve[idx]); pReserve[idx]=NULL;
}
}
return(true);
}
void Free(void)
{
for(u32 idx=0;idx<ReserveCount;idx++){
if(pReserve[idx]!=NULL){
safefree(pReserve[idx]); pReserve[idx]=NULL;
}
}
selFree();
PCH_FreeProgramMap();
for(u32 ch=0;ch<ChannelsCount;ch++){
for(u32 sidx=0;sidx<MaxStackCount;sidx++){
if(pStackBuf[ch][sidx]!=NULL){
safefree(pStackBuf[ch][sidx]); pStackBuf[ch][sidx]=NULL;
}
}
}
if(DeflateBuf!=NULL){
safefree(DeflateBuf); DeflateBuf=NULL;
}
}
u32 Update(s16 *lbuf,s16 *rbuf)
{
// _consolePrintf("SoundFontLoadTimeus=%dus\n",SoundFontLoadTimeus);
// PrfStart();
if(sel_isAllTrackEOF()==true) return(0);
TiniMIDPlugin *MIDPlugin=&GlobalINI.MIDPlugin;
int ProcClock=0;
{
u32 SamplePerFrameFix16=SamplePerFrame*0x10000;
u32 SamplePerClockFix16=sel_GetSamplePerClockFix16();
while(ClockCur<SamplePerFrameFix16){
ProcClock++;
ClockCur+=SamplePerClockFix16;
}
ClockCur-=SamplePerFrame*0x10000;
}
while(ProcClock!=0){
int DecClock=selGetNearClock();
// if(ProcClock>=DecClock) _consolePrintf("[%d]",CurrentClock+1);
if(ProcClock<DecClock) DecClock=ProcClock;
ProcClock-=DecClock;
CurrentClock+=DecClock;
if(selNextClock(MIDPlugin->ShowEventMessage,true,DecClock)==false) break;
}
PCH_NextClock();
PCH_RenderStart(SamplePerFrame);
if((lbuf!=NULL)&&(rbuf!=NULL)){
MemSet32CPU(0,DTCM_dstbuf,SamplePerFrame*2*4);
StackIndex++;
if(StackIndex==StackCount) StackIndex=0;
for(u32 ch=0;ch<ChannelsCount;ch++){
bool reqproc=false;
bool reqrender=false;
if(StackLastCount[ch]!=0) reqproc=true;
if(PCH_RequestRender(ch)==true){
reqproc=true;
reqrender=true;
}
if(reqproc==true){
s32 *ptmpbuf=DTCM_tmpbuf;
MemSet32CPU(0,ptmpbuf,SamplePerFrame*2*4);
if(reqrender==true){
PCH_Render(ch,ptmpbuf,SamplePerFrame);
StackLastCount[ch]=StackCount*4;
}else{
StackLastCount[ch]--;
}
s32 *pstackbuf=pStackBuf[ch][StackIndex];
{
s32 *p=&pstackbuf[(SamplePerFrame-1)*2];
asm volatile(
"ldmia %0!,{r0,r1} \n"
"stmia %0,{r0,r1} \n"
"sub %0,#2*4 \n"
: : "r"(p)
: "r0","r1"
);
}
s32 *pdstbuf=DTCM_dstbuf;
u32 ReverbFactor;
if(PCH_isDrumMap(ch)==true){
ReverbFactor=GlobalINI.MIDPlugin.ReverbFactor_DrumMap;
}else{
ReverbFactor=GlobalINI.MIDPlugin.ReverbFactor_ToneMap;
}
vu32 Reverb=PCH_GetReverb(ch)*ReverbFactor; // 127*127=14bit
Reverb+=16*128;
Reverb<<=1; // 14bit -> 15bit
if(0x6000<Reverb) Reverb=0x6000; // limited
asm volatile(
// %0=SamplePerFrame
// %1=pstackbuf
// %2=ptmpbuf
// %3=Reverb
// %4=pdstbuf
// r0,r1,r2,r3=pstackbuf l/r/l/r
// r4,r5=ptmpbuf l/r
// r10=SamplePerFrame-1
"mov r10,%0 \n"
"reverb_loop: \n"
"ldmia %1,{r0,r1,r2,r3} \n"
"ldmia %2!,{r4,r5} \n"
"add r0,r2 \n"
"smulwb r2,r0,%3 \n"
"add r1,r3 \n"
"smulwb r3,r1,%3 \n"
"add r1,r2,r5 \n"
"add r0,r3,r4 \n"
"stmia %1!,{r0,r1} \n"
"ldmia %4,{r4,r5} \n"
"add r4,r0 \n"
"add r5,r1 \n"
"stmia %4!,{r4,r5} \n"
"subs %0,#1 \n"
"bne reverb_loop \n"
"mov r10,%0 \n"
"sub %1,r10,lsl #3 \n"
"sub %2,r10,lsl #3 \n"
"sub %4,r10,lsl #3 \n"
: : "r"(SamplePerFrame),"r"(pstackbuf),"r"(ptmpbuf),"r"(Reverb),"r"(pdstbuf)
: "r0","r1","r2","r3","r4","r5","r10"
);
}
}
asm volatile(
"push {%0} \n"
"ldr r8,=-0x8000 \n"
"ldr r9,=0xffff \n"
"copybuffer_stereo: \n"
"ldmia %1!,{r0,r1,r2,r3,r4,r5,r6,r7} \n"
"cmps r0,r8 \n movlt r0,r8 \n cmps r0,r9,lsr #1 \n movgt r0,r9,lsr #1 \n"
"cmps r1,r8 \n movlt r1,r8 \n cmps r1,r9,lsr #1 \n movgt r1,r9,lsr #1 \n"
"cmps r2,r8 \n movlt r2,r8 \n cmps r2,r9,lsr #1 \n movgt r2,r9,lsr #1 \n"
"cmps r3,r8 \n movlt r3,r8 \n cmps r3,r9,lsr #1 \n movgt r3,r9,lsr #1 \n"
"cmps r4,r8 \n movlt r4,r8 \n cmps r4,r9,lsr #1 \n movgt r4,r9,lsr #1 \n"
"cmps r5,r8 \n movlt r5,r8 \n cmps r5,r9,lsr #1 \n movgt r5,r9,lsr #1 \n"
"cmps r6,r8 \n movlt r6,r8 \n cmps r6,r9,lsr #1 \n movgt r6,r9,lsr #1 \n"
"cmps r7,r8 \n movlt r7,r8 \n cmps r7,r9,lsr #1 \n movgt r7,r9,lsr #1 \n"
"and r0,r9 \n"
"orr r0,r0,r2,lsl #16 \n"
"and r4,r9 \n"
"orr r4,r4,r6,lsl #16 \n"
"stmia %2!,{r0,r4} \n"
"and r1,r9 \n"
"orr r1,r1,r3,lsl #16 \n"
"and r5,r9 \n"
"orr r5,r5,r7,lsl #16 \n"
"stmia %3!,{r1,r5} \n"
"subs %0,#4 \n"
"bne copybuffer_stereo \n"
"pop {%0} \n"
: : "r"(SamplePerFrame),"r"(DTCM_dstbuf),"r"(lbuf),"r"(rbuf)
: "r0","r1","r2","r3","r4","r5","r6","r7", "r8","r9"
);
}
PCH_RenderEnd();
/*
static u32 a=0;
if(a<256){
a++;
}else{
ShowLogHalt();
}
*/
// PrfEnd(0);
return(SamplePerFrame);
}
s32 GetPosMax(void)
{
return(TotalClock);
}
s32 GetPosOffset(void)
{
return(CurrentClock);
}
void SetPosOffset(s32 ofs)
{
if(ofs<CurrentClock){
selFree();
selStart();
CurrentClock=0;
}else{
selAllSoundOff();
}
while(CurrentClock<=ofs){
int DecClock=selGetNearClock();
if(selNextClock(false,false,DecClock)==false) break;
CurrentClock+=DecClock;
}
ClockCur=0;
}
u32 GetChannelCount(void)
{
return(2);
}
u32 GetSampleRate(void)
{
TiniMIDPlugin *MIDPlugin=&GlobalINI.MIDPlugin;
return(MIDPlugin->SampleRate);
}
u32 GetSamplePerFrame(void)
{
return(SamplePerFrame);
}
int GetInfoIndexCount(void)
{
if(GlobalINI.MIDPlugin.ShowInfomationMessages==true){
if(GetBINSize()<1*1024*1024) return(5);
if(MemoryOverflowFlag==true) return(5);
}
switch(FileFormat){
case EFF_MID: return(5); break;
case EFF_RCP: return(15); break;
}
return(0);
}
bool GetInfoStrL(int idx,char *str,int len)
{
if(GlobalINI.MIDPlugin.ShowInfomationMessages==true){
if(GetBINSize()<1*1024*1024){
switch(idx){
case 0: snprintf(str,len,"This sound font is very compact."); return(true); break;
case 1: snprintf(str,len,"Install full sound font from web site."); return(true); break;
case 2: snprintf(str,len,"これは小さなサウンドフォントです。"); return(true); break;
case 3: snprintf(str,len,"ウェブサイトから完全版をDLできます。"); return(true); break;
case 4: snprintf(str,len,"http://mdxonline.dyndns.org/"); return(true); break;
}
return(false);
}
if(MemoryOverflowFlag==true){
switch(idx){
case 0: snprintf(str,len,"Sound font memory overflow."); return(true);
case 1: snprintf(str,len,"Please try 8bit sound font."); return(true);
case 2: snprintf(str,len,"PCMメモリが足りませんでした。"); return(true);
case 3: snprintf(str,len,"詳しくはサウンドフォント付属の"); return(true);
case 4: snprintf(str,len,"テキストを参照してください。"); return(true);
}
return(false);
}
}
switch(FileFormat){
case EFF_MID: {
TSM_Chank *_SM_Chank=&StdMIDI.SM_Chank;
switch(idx){
case 0: snprintf(str,len,"Format=%d Tracks=%d TimeRes=%d",_SM_Chank->Format,_SM_Chank->Track,_SM_Chank->TimeRes); return(true); break;
case 1: snprintf(str,len,"Title=%s",(gME_Title!=NULL) ? gME_Title : ""); return(true); break;
case 2: snprintf(str,len,"Copyright=%s",(gME_Copyright!=NULL) ? gME_Copyright : ""); return(true); break;
case 3: snprintf(str,len,"Text=%s",(gME_Text!=NULL) ? gME_Text : ""); return(true); break;
case 4: snprintf(str,len,"TotalClock=%d",TotalClock); return(true); break;
}
} break;
case EFF_RCP: {
TRCP_Chank *pRCP_Chank=&RCP_Chank;
switch(idx){
case 0: snprintf(str,len,"TimeRes=%d Tempo=%d PlayBias=%d",pRCP_Chank->TimeRes,pRCP_Chank->Tempo,pRCP_Chank->PlayBias); return(true); break;
case 1: snprintf(str,len,"TrackCount=%d TotalClock=%d",pRCP_Chank->TrackCount,TotalClock); return(true); break;
case 2: snprintf(str,len,"%0.64s",pRCP_Chank->Title); return(true); break;
case 3: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[0*28]); return(true); break;
case 4: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[1*28]); return(true); break;
case 5: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[2*28]); return(true); break;
case 6: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[3*28]); return(true); break;
case 7: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[4*28]); return(true); break;
case 8: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[5*28]); return(true); break;
case 9: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[6*28]); return(true); break;
case 10: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[7*28]); return(true); break;
case 11: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[8*28]); return(true); break;
case 12: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[9*28]); return(true); break;
case 13: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[10*28]); return(true); break;
case 14: snprintf(str,len,"%0.28s",&pRCP_Chank->Memo[11*28]); return(true); break;
}
} break;
}
return(false);
}
bool GetInfoStrW(int idx,UnicodeChar *str,int len)
{
return(false);
}
bool GetInfoStrUTF8(int idx,char *str,int len)
{
return(false);
}
// -----------------------------------------------------------
| [
"yy20716@73b7253b-944e-0410-bf16-698164e7ef75"
] | [
[
[
1,
712
]
]
] |
4bcab03f09909d79473614c2b415f30f3637ceae | 0cf09d7cc26a513d0b93d3f8ef6158a9c5aaf5bc | /twittle/src/feed_panel.cpp | 1dc5e163000ceca24fbc09fbe352617be9f73a2b | [] | no_license | shenhuashan/Twittle | 0e276c1391c177e7586d71c607e6ca7bf17e04db | 03d3d388d5ba9d56ffcd03482ee50e0a2a5f47a1 | refs/heads/master | 2023-03-18T07:53:25.305468 | 2009-08-11T05:55:07 | 2009-08-11T05:55:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,336 | cpp | #include <wx/wx.h>
#include <wx/clipbrd.h>
#include <wx/regex.h>
#include "feed_panel.h"
#include "application.h"
#include "twitter/twitter_feed.h"
#include "twitter/twitter_user.h"
#include "twitter/twitter_status.h"
#include "thread_callback.h"
BEGIN_EVENT_TABLE(FeedPanel, wxHtmlListBox)
EVT_COMMAND(wxID_ANY, EVT_FEED_UPDATED, FeedPanel::OnFeedUpdated)
EVT_COMMAND(wxID_ANY, EVT_IMAGE_UPDATED, FeedPanel::OnImageUpdated)
EVT_HTML_LINK_CLICKED(1, FeedPanel::OnLinkClicked)
EVT_RIGHT_DOWN(FeedPanel::OnRightClick)
EVT_MENU(ID_COPYTEXT, FeedPanel::CopyItemAsText)
EVT_MENU(ID_COPYHTML, FeedPanel::CopyItemAsHtml)
EVT_TIMER(ID_UPDATEUI, FeedPanel::OnUpdateUI)
END_EVENT_TABLE()
DEFINE_EVENT_TYPE(EVT_FEED_UPDATED)
DEFINE_EVENT_TYPE(EVT_IMAGE_UPDATED)
FeedPanel::FeedPanel() : wxHtmlListBox(), filter(FilteredIterator::FILTER_NONE)
{
}
FeedPanel::FeedPanel(wxWindow* parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name)
: wxHtmlListBox(parent, id, pos, size, style, name), filter(FilteredIterator::FILTER_NONE)
{
Create(parent, 1, pos, size, style, name);
}
FeedPanel::~FeedPanel()
{
wxGetApp().GetTwitter().UnregisterListener(*this, feedResource);
}
void FeedPanel::Create(wxWindow* parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name)
{
wxHtmlListBox::Create(parent, id, pos, size, style, name);
SetMargins(0, 0);
SetSelectionBackground(wxColour(240, 240, 240));
CreateItemMenu();
CreateAccelerators();
// Start update UI timer
updateUITimer.SetOwner(this, ID_UPDATEUI);
updateUITimer.Start(60000, false); // 60 second update
}
void FeedPanel::CreateAccelerators()
{
wxAcceleratorEntry entries[1];
entries[0].Set(wxACCEL_CTRL, (int)'C', ID_COPYTEXT);
wxAcceleratorTable accel(1, entries);
SetAcceleratorTable(accel);
}
void FeedPanel::CreateItemMenu()
{
itemMenu.Append(ID_COPYTEXT, _T("Copy as text"));
itemMenu.Append(ID_COPYHTML, _T("Copy as HTML"));
}
unsigned int FeedPanel::GetStatusSize() const
{
unsigned int count = 0;
const TwitterFeed *feed = wxGetApp().GetTwitter().GetFeed(feedResource);
const std::vector<TwitterStatus>& statuses = feed->GetStatuses();
FilteredIterator it(statuses.begin(), statuses.end(), filter);
for (; it != statuses.end(); ++it, ++count);
return count - 1;
}
const TwitterStatus FeedPanel::GetStatusItem(unsigned int n) const
{
unsigned int count = 0;
const TwitterFeed *feed = wxGetApp().GetTwitter().GetFeed(feedResource);
const std::vector<TwitterStatus>& statuses = feed->GetStatuses();
n = (GetStatusSize() - 1) - n; // reverse n index
FilteredIterator it(statuses.begin(), statuses.end(), filter);
for (; it != statuses.end(); ++it, ++count) {
if (count - 1 == n) return *it;
}
throw "invalid status item";
}
void FeedPanel::StatusNotification(const TwitterStatus& status)
{
wxString title = status.GetUser().GetName() + _T(" (") +
status.GetUser().GetScreenName() + _T(") tweets:");
if (title.Length() > 64) {
title = status.GetUser().GetScreenName() + _T(" tweets:");
}
wxString notification = status.GetText();
wxGetApp().GetMainWindow().TrayNotification(notification, title);
}
void FeedPanel::SetFeed(const wxString& resource, int delay)
{
// Already watching this feed
if (resource == feedResource) return;
Twitter &twitter = wxGetApp().GetTwitter();
if (feedResource != _T("")) {
// unregister the old resource
twitter.UnregisterListener(*this, feedResource);
twitter.GetFeed(feedResource)->Pause();
SetItemCount(0); // flush the data
}
// Load any residual data in the feedResource
feedResource = resource;
TwitterFeed *feed = wxGetApp().GetTwitter().GetFeed(feedResource);
if (feed) {
SetItemCount(GetStatusSize());
}
else {
// Attempt to de-serialize any saved data
feed = Serializer<wxString, TwitterFeed>().Read(feedResource);
if (feed) {
twitter.LoadFeed(feedResource, feed);
SetItemCount(GetStatusSize());
}
}
// register the listener and begin the monitoring threads
twitter.RegisterListener(*this, feedResource);
twitter.BeginFeed(feedResource, delay);
}
void FeedPanel::TwitterUpdateReceived(const Twitter& twitter, const wxString& resource)
{
if (resource != feedResource) return;
bool showNotifications = wxGetApp().GetSettings().GetBool(_T("window.shownotifications"));
if (showNotifications && resource == Twitter::FriendsTimelineUrl) {
// show update notifications for friends
TwitterFeed *feed = twitter.GetFeed(resource);
if (feed && feed->GetStatuses().size() > 0) {
const TwitterStatus& last = feed->GetStatuses().back();
StatusNotification(last);
}
}
// post event
wxCommandEvent evt(EVT_FEED_UPDATED, wxID_ANY);
wxPostEvent(this, evt);
}
void FeedPanel::OnFeedUpdated(wxCommandEvent &event)
{
SetItemCount(GetStatusSize());
RefreshAll();
}
// unused
void FeedPanel::OnImageUpdated(wxCommandEvent &event)
{
}
wxString FeedPanel::DecorateStatusText(wxString text) const
{
wxRegEx links(_T("((https?|www\\.)://[^[:space:]]+)"), wxRE_ICASE);
wxRegEx hashtags(_T("#([[:alnum:]_]+)"));
wxRegEx refs(_T("@([[:alnum:]_]+)"));
links.ReplaceAll(&text, _T("<a href='\\1'>\\1</a>"));
refs.ReplaceAll(&text, _T("@<a href='http://twitter.com/\\1'>\\1</a>"));
hashtags.ReplaceAll(&text, _T("#<a href='http://hashtags.org/tag/\\1'>\\1</a>"));
return text;
}
wxString FeedPanel::DecorateSource(wxString text) const
{
wxRegEx links(_T("(<a[^>]+>)([^<]+)"), wxRE_ICASE);
links.ReplaceAll(&text, _T("\\1<font color='#555555'>\\2</font>"));
return text;
}
wxString FeedPanel::OnGetItem(size_t n) const
{
const TwitterFeed *feed = wxGetApp().GetTwitter().GetFeed(feedResource);
if (feed == NULL) return _T("");
TwitterStatus status = GetStatusItem(n);
const TwitterUser &user = status.GetUser();
wxString list;
list << _T("<table cellpadding='5'><tr><td valign='top'>");
list << _T("<img id='") << user.GetId() <<_T("' width=48 height=48 src='");
list << user.GetProfileImageFilename();
list << _T("' align='left'>");
list << _T("</td><td valign='top'>");
if (wxGetApp().GetSettings().GetBool(_T("feedpanel.showscreenname"))) {
list << _T("<b>") + user.GetScreenName() + _T("</b>: ");
}
list << DecorateStatusText(status.GetText());
list << _T("<p><font color='#aaaaaa' size='2'>");
list << user.GetName() << _T(" (");
list << _T("<a href='http://twitter.com/") << user.GetScreenName() << _T("'>");
list << _T("<font color='#555555'>") << user.GetScreenName() << _T("</font></a>");
list << _T(") <font color='#555555'>") << status.GetTimeSincePost();
list << _T("</font> via <font color='#555555'>") << DecorateSource(status.GetSource()) << _T("</font>");
list << _T("</font>");
list << _T("</td></tr></table>");
return list;
}
void FeedPanel::OnLinkClicked(wxHtmlLinkEvent &evt)
{
wxGetApp().OpenUrl(evt.GetLinkInfo().GetHref());
}
void FeedPanel::OnRightClick(wxMouseEvent& evt)
{
// make sure an item gets selected
wxMouseEvent clickevt = evt;
clickevt.SetEventType(wxEVT_LEFT_DOWN);
wxPostEvent(this, clickevt);
// show popup menu
PopupMenu(&itemMenu, evt.GetPosition());
}
void FeedPanel::CopyItemAsText(wxCommandEvent& evt)
{
int selId = GetSelection();
if (selId != wxNOT_FOUND && wxTheClipboard->Open()) {
TwitterStatus status = GetStatusItem(selId);
wxString text = status.GetUser().GetScreenName() + _T(": ") + status.GetText();
wxTheClipboard->SetData(new wxTextDataObject(text));
wxTheClipboard->Close();
}
}
void FeedPanel::CopyItemAsHtml(wxCommandEvent& evt)
{
int selId = GetSelection();
if (selId != wxNOT_FOUND && wxTheClipboard->Open()) {
TwitterStatus status = GetStatusItem(selId);
wxString decoratedText = DecorateStatusText(status.GetText());
decoratedText = status.GetUser().GetScreenName() + _T(": ") + decoratedText;
wxTheClipboard->SetData(new wxTextDataObject(decoratedText));
wxTheClipboard->Close();
}
}
void FeedPanel::OnUpdateUI(wxTimerEvent& evt)
{
RefreshAll();
}
wxColour FeedPanel::GetSelectedTextColour(const wxColour& colFg) const
{
return *wxBLACK;
}
| [
"[email protected]"
] | [
[
[
1,
267
]
]
] |
1e6ee7465c7df64f136be598cd49e30d55255fc4 | b22c254d7670522ec2caa61c998f8741b1da9388 | /FinalClient/ServerThread.cpp | c5b5e593b51d2fb0f7f072e5625c482b19b33d64 | [] | no_license | ldaehler/lbanet | 341ddc4b62ef2df0a167caff46c2075fdfc85f5c | ecb54fc6fd691f1be3bae03681e355a225f92418 | refs/heads/master | 2021-01-23T13:17:19.963262 | 2011-03-22T21:49:52 | 2011-03-22T21:49:52 | 39,529,945 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,705 | cpp | /*
------------------------[ Lbanet Source ]-------------------------
Copyright (C) 2009
Author: Vivien Delage [Rincevent_123]
Email : [email protected]
-------------------------------[ GNU License ]-------------------------------
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, see <http://www.gnu.org/licenses/>.
-----------------------------------------------------------------------------
*/
#include "ServerThread.h"
#include "ServerReceiveingWorkpile.h"
#include "SynchronizedTimeHandler.h"
/***********************************************************
constructor
***********************************************************/
ServerThread::ServerThread(long cycle_time, boost::shared_ptr<ServerReceivingWorkpile> receiver)
: m_stopped(false), m_cycle_time(cycle_time), m_receiver(receiver)
{
}
/***********************************************************
stop the thread
***********************************************************/
void ServerThread::Stop()
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(m_monitor);
m_stopped = true;
m_monitor.notifyAll();
}
/***********************************************************
running function of the thread
***********************************************************/
void ServerThread::run()
{
m_lasttime = SynchronizedTimeHandler::getInstance()->GetCurrentTimeSync();
while(true)
{
// check if thread needs to be stopped - else wait a few milliseconds
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(m_monitor);
if(m_stopped)
{
m_stopped = false;
break;
}
}
//do the work here
// get key pressed since the last time
std::vector<Sendedinfo> keypressed;
m_receiver->GetkeyPressed(keypressed);
// wait a scan cycle time
unsigned long currenttime = SynchronizedTimeHandler::getInstance()->GetCurrentTimeSync();
long diff = (long)(currenttime-m_lasttime);
m_lasttime = currenttime;
if(diff < m_cycle_time)
{
IceUtil::Time t = IceUtil::Time::milliSeconds(diff-m_cycle_time);
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(m_monitor);
m_monitor.timedWait(t);
}
}
} | [
"vdelage@3806491c-8dad-11de-9a8c-6d5b7d1e4d13"
] | [
[
[
1,
91
]
]
] |
81f7021d22044eb61bc8030aae786f3d9cf5779c | 7a4326a6fffc766fb3c126e01b2ff8cd811a7986 | /code/games/tank/src/InstantHitWeapon.cpp | b550b0c13f72e977a188da41d8623a68dd3728b5 | [] | no_license | zhangchenghgd/zeroballistics | c326351f537d5a657e1441b978a3111441e1d8f2 | 34bb5f294b032ad025e3b4f5d82b86ac62245a10 | refs/heads/master | 2021-05-31T01:30:25.977219 | 2011-01-16T21:28:41 | 2011-01-16T21:28:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,921 | cpp |
#ifndef TANK_MACHINE_GUN_INCLUDED
#define TANK_MACHINE_GUN_INCLUDED
#include "InstantHitWeapon.h"
#include <limits>
#include "physics/OdeSimulator.h"
#include "Tank.h"
#include "Projectile.h"
#include "PuppetMasterServer.h"
#include "GameState.h"
#include "AutoRegister.h"
#include "ParameterManager.h"
#include "PuppetMasterClient.h"
#include "GameLogicServerCommon.h"
#include "TankMine.h"
#include "Water.h"
#ifndef DEDICATED_SERVER
#include <osg/Node>
#include <osg/MatrixTransform>
#include "SceneManager.h"
#include "SoundManager.h"
#include "GameLogicClientCommon.h"
#include "OsgNodeWrapper.h"
#include "TankVisual.h"
#include "ReaderWriterBbm.h"
#include "UtilsOsg.h"
#include "EffectManager.h"
const float SND_FIRING_GAIN = 0.5f;
const float TRACER_DIST_UPDATE_DT = 0.2f;
const float TRACER_LENGTH = 0.1f; ///< XXXX This is used to correct the distance
#endif
#undef min
#undef max
REGISTER_CLASS(WeaponSystem, InstantHitWeaponServer);
#ifndef DEDICATED_SERVER
REGISTER_CLASS(WeaponSystem, InstantHitWeaponClient);
#endif
//------------------------------------------------------------------------------
InstantHitWeapon::~InstantHitWeapon()
{
}
//------------------------------------------------------------------------------
InstantHitWeapon::InstantHitWeapon() :
ray_intersection_dist_(0.0f),
hit_normal_(Vector(0.0f, 0.0f, 0.0f)),
hit_body_(NULL)
{
}
//------------------------------------------------------------------------------
void InstantHitWeapon::doRayTest(physics::OdeSimulator * sim)
{
Matrix muzzle_trans;
tank_->getMuzzleTransform(&muzzle_trans);
ray_intersection_dist_ = s_params.get<float>(section_ + ".range");
physics::OdeRayGeom ray(ray_intersection_dist_);
ray.set(muzzle_trans.getTranslation(), -muzzle_trans.getZ());
hit_body_ = NULL;
sim->getStaticSpace()->collide(&ray, physics::CollisionCallback(this, &InstantHitWeapon::rayCollisionCallback));
sim->getActorSpace() ->collide(&ray, physics::CollisionCallback(this, &InstantHitWeapon::rayCollisionCallback));
}
//------------------------------------------------------------------------------
bool InstantHitWeapon::rayCollisionCallback(const physics::CollisionInfo & info)
{
// Ignore water plane on server so we can still shoot e.g. mines
// below water
if (tank_->getLocation() == CL_SERVER_SIDE &&
info.other_geom_->getName() == WATER_GEOM_NAME) return false;
RigidBody * cur_hit = (RigidBody*) info.other_geom_->getUserData();
// Find closest hit that is not our own tank
if (cur_hit != tank_ &&
(hit_body_ == NULL || info.penetration_ < ray_intersection_dist_))
{
ray_intersection_dist_ = info.penetration_;
hit_normal_ = info.n_;
hit_body_ = cur_hit;
if(cur_hit)
{
hit_rigid_body_type_ = cur_hit->getType();
hit_player_ = cur_hit->getType() == "Tank" ? cur_hit->getOwner() : UNASSIGNED_SYSTEM_ADDRESS;
}
else
{
hit_rigid_body_type_ = "";
hit_player_ = UNASSIGNED_SYSTEM_ADDRESS;
}
}
return false;
}
//------------------------------------------------------------------------------
/**
* Cast a ray, see what's hit, deal damage (in callback fun), decrease ammo.
*/
void InstantHitWeaponServer::doFire()
{
assert(game_logic_server_);
// Because this is a scheduled function, the tank may have been
// destroyed in the meantime...
if (tank_->getOwner() == UNASSIGNED_SYSTEM_ADDRESS) return;
doRayTest(game_logic_server_->getPuppetMaster()->getGameState()->getSimulator());
if (hit_body_)
{
game_logic_server_->onInstantWeaponHit(this, hit_body_);
}
}
#ifndef DEDICATED_SERVER
//------------------------------------------------------------------------------
InstantHitWeaponClient::InstantHitWeaponClient() :
task_tracer_dist_(INVALID_TASK_HANDLE),
task_hitfeedback_(INVALID_TASK_HANDLE)
{
}
//------------------------------------------------------------------------------
void InstantHitWeaponClient::init(Tank * tank, const std::string & section)
{
WeaponSystem::init(tank, section);
TankVisual * tank_visual = (TankVisual*)tank_->getUserData();
assert(tank_visual);
assert(tank_visual->getWrapperNode());
// TODO check why this triggers with bots...
// assert(tracer_effect_.empty());
if(!tracer_effect_.empty()) tracer_effect_.clear();
// retrieve tracer effect modeled in blender
std::vector<osg::Node*> tracer_v =
s_scene_manager.findNode(s_params.get<std::string>(section_ + ".tracer_effect"),
tank_visual->getWrapperNode()->getOsgNode());
for (unsigned i=0; i<tracer_v.size(); ++i)
{
ParticleEffectNode * n = dynamic_cast<ParticleEffectNode*>(tracer_v[i]);
assert(n);
tracer_effect_.push_back(n);
}
if (tracer_effect_.empty())
{
s_log << Log::warning
<< "No tracer effect found for "
<< section
<< "\n";
}
}
//------------------------------------------------------------------------------
bool InstantHitWeaponClient::startFiring()
{
if (!WeaponSystem::startFiring()) return false;
s_log << Log::debug('l')
<< "startFiringClient\n";
// Schedule next tracer round
task_tracer_dist_ = s_scheduler.addTask(PeriodicTaskCallback(this, &InstantHitWeaponClient::handleTracerDistance),
TRACER_DIST_UPDATE_DT,
"InstantHitWeapon::handleTracerDistance",
&fp_group_);
// Single-event based in order to allow for random fluctuations.
handleHitFeedback(NULL);
TankVisual * tank_visual = (TankVisual*)tank_->getUserData();
assert(tank_visual);
EnableGroupVisitor v(s_params.get<std::string>(section_ + ".effect_group"), true);
tank_visual->getWrapperNode()->getOsgNode()->accept(v);
tank_visual->enableSecondaryWeaponEffect(true);
assert(snd_firing_.get() == NULL);
snd_firing_ = s_soundmanager.playLoopingEffect(s_params.get<std::string>(section_ + ".sound_effect"),
tank_visual->getWrapperNode()->getOsgNode());
snd_firing_->setGain(SND_FIRING_GAIN);
return true;
}
//------------------------------------------------------------------------------
bool InstantHitWeaponClient::stopFiring()
{
if (!WeaponSystem::stopFiring())
{
assert(task_hitfeedback_ == INVALID_TASK_HANDLE);
assert(!snd_firing_.get());
return false;
}
assert(snd_firing_.get());
// Will be deleted after last sample has finished playing
snd_firing_->setLooping(false);
snd_firing_ = NULL;
s_scheduler.removeTask(task_tracer_dist_, &fp_group_);
task_tracer_dist_ = INVALID_TASK_HANDLE;
s_scheduler.removeTask(task_hitfeedback_, &fp_group_);
task_hitfeedback_ = INVALID_TASK_HANDLE;
TankVisual * tank_visual = (TankVisual*)tank_->getUserData();
if(tank_visual)
{
EnableGroupVisitor v(s_params.get<std::string>(section_ + ".effect_group"), false);
tank_visual->getWrapperNode()->getOsgNode()->accept(v);
tank_visual->enableSecondaryWeaponEffect(false);
}
return true;
}
//------------------------------------------------------------------------------
void InstantHitWeaponClient::onOverheat()
{
TankVisual * tank_visual = (TankVisual*)tank_->getUserData();
if (tank_visual)
{
tank_visual->playTankSoundEffect(s_params.get<std::string>("sfx.mg_overheating"),
tank_->getPosition());
}
}
//------------------------------------------------------------------------------
/**
* First, cast a ray into the scene to see how far tracer must
* fly. Then create tracer round with the appropriate lifetime, and
* schedule the next tracer event.
*/
void InstantHitWeaponClient::handleTracerDistance(float dt)
{
doRayTest(game_logic_client_->getPuppetMaster()->getGameState()->getSimulator());
for (unsigned i=0; i < tracer_effect_.size(); ++i)
{
for (unsigned eff=0; eff<tracer_effect_[i]->getNumEffects(); ++eff)
{
osgParticle::ModularEmitter * emitter = tracer_effect_[i]->getEffect(eff).emitter_.get();
osgParticle::RadialShooter * shooter = dynamic_cast<osgParticle::RadialShooter*>(emitter->getShooter());
assert(shooter);
float speed = shooter->getInitialSpeedRange().mid();
emitter->getParticleSystem()->getDefaultParticleTemplate().setLifeTime(
std::max(ray_intersection_dist_ - TRACER_LENGTH, TRACER_LENGTH)/speed);
}
}
}
//------------------------------------------------------------------------------
/**
* Uses the current ray_intersection_dist_ and hit_normal_ to create
* a particle & sound effect.
*
* Reschedules itself.
*/
void InstantHitWeaponClient::handleHitFeedback(void *)
{
assert(game_logic_client_);
assert(tank_);
doRayTest(game_logic_client_->getPuppetMaster()->getGameState()->getSimulator());
// Only create feedback if something was hit actually
if (ray_intersection_dist_ != s_params.get<float>(section_ + ".range"))
{
Matrix muzzle_trans;
tank_->getMuzzleTransform(&muzzle_trans);
Vector hit_pos = muzzle_trans.getTranslation() - ray_intersection_dist_*muzzle_trans.getZ();
uint8_t object_hit_type;
uint8_t weapon_hit_type;
/// XXX better solution??
if(section_ == "mg")
{
weapon_hit_type = WHT_MACHINE_GUN;
} else if(section_ == "flamethrower")
{
weapon_hit_type = WHT_FLAME_THROWER;
} else if(section_ == "laser")
{
weapon_hit_type = WHT_LASER;
} else if (section_ == "tractor_beam")
{
weapon_hit_type = WHT_TRACTOR_BEAM;
} else
{
weapon_hit_type = WHT_MACHINE_GUN;
s_log << Log::warning << " Unknown weapon hit type in InstantHitWeapon.\n";
}
/// Object hit by ray
if(hit_rigid_body_type_ == "Tank")
{
object_hit_type = OHT_TANK;
}
else if(hit_rigid_body_type_ == "Water")
{
object_hit_type = OHT_WATER;
} else
{
object_hit_type = OHT_OTHER;
}
RakNet::BitStream args;
args.Write(tank_->getOwner());
args.Write(hit_player_);
args.Write(hit_pos);
args.Write(hit_normal_);
args.Write(weapon_hit_type);
args.Write(object_hit_type);
game_logic_client_->executeCustomCommand(CSCT_WEAPON_HIT, args);
}
// Schedule next hit feedback
task_hitfeedback_ = s_scheduler.addEvent(SingleEventCallback(this, &InstantHitWeaponClient::handleHitFeedback),
s_params.get<float>(section_ + ".feedback_interval"),
NULL,
"Hit Feedback",
&fp_group_);
}
#endif // #ifndef DEDICATED_SERVER
#endif // #ifndef TANK_MACHINE_GUN_INCLUDED
| [
"musch@2846cbf5-6c17-0410-bc73-dc7e12504047"
] | [
[
[
1,
393
]
]
] |
8bd51a06e504e844dcbf52c237ec70c9b2b50f19 | b5ad65ebe6a1148716115e1faab31b5f0de1b493 | /src/Oilify/oilify.cpp | d73f7463fa82ebc85477a0dc57bf26b093b24360 | [] | no_license | gasbank/aran | 4360e3536185dcc0b364d8de84b34ae3a5f0855c | 01908cd36612379ade220cc09783bc7366c80961 | refs/heads/master | 2021-05-01T01:16:19.815088 | 2011-03-01T05:21:38 | 2011-03-01T05:21:38 | 1,051,010 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,394 | cpp | #include "oilify.h"
#include "oilify_api.h"
#define HDASHLINE "-----------------------------------------------------------\n"
#define CLAMP(v,lo,hi) ((v)<(lo))?(lo):((v)>(hi))?(hi):(v)
#define CLAMP0255(v) CLAMP((v), 0, 255)
#define HISTSIZE (256)
#define GIMP_RGB_LUMINANCE_RED (0.2126)
#define GIMP_RGB_LUMINANCE_GREEN (0.7152)
#define GIMP_RGB_LUMINANCE_BLUE (0.0722)
#define MAX(a,b) ((a)<(b))?(b):(a)
/* for GIMP source code compatability */
typedef int gint;
typedef float gfloat;
typedef unsigned int guint;
typedef unsigned char guchar;
static inline unsigned char
intensityFromRgb(unsigned char rgb[3])
{
return static_cast<unsigned char>(CLAMP0255(GIMP_RGB_LUMINANCE_RED*rgb[0] + GIMP_RGB_LUMINANCE_GREEN*rgb[1] + GIMP_RGB_LUMINANCE_BLUE*rgb[2]));
}
/*
* This is a special-case form of the powf() function, limited to integer
* exponents. It calculates e.g. x^13 as (x^8)*(x^4)*(x^1).
*
* x can be anything, y must be in [0,255]
*/
static inline gfloat
fast_powf (gfloat x, gint y)
{
gfloat value;
gfloat x_pow[8];
guint y_uint = (guint) y;
guint bitmask;
gint i;
if (y_uint & 0x01)
value = x;
else
value = 1.0;
x_pow[0] = x;
for (bitmask = 0x02, i = 1;
bitmask <= y_uint;
bitmask <<= 1, i++)
{
/* x_pow[i] == x_pow[i-1]^2 == x^(2^i) */
x_pow[i] = SQR (x_pow[i - 1]);
if (y_uint & bitmask)
value *= x_pow[i];
}
return value;
}
/*
* For each i in [0, HISTSIZE), hist[i] is the number of occurrences of
* pixels with intensity i. hist_rgb[][i] is the average color of those
* pixels with intensity i, but with each channel multiplied by hist[i].
* Write to dest a pixel whose color is a weighted average of all the
* colors in hist_rgb[][], biased heavily toward those with the most
* frequently-occurring intensities (as noted in hist[]).
*
* The weight formula is the same as in weighted_average_value().
*/
static inline void
weighted_average_color (gint hist[HISTSIZE],
gint hist_rgb[4][HISTSIZE],
gfloat exponent,
guchar *dest,
gint bpp)
{
gint i, b;
gint hist_max = 1;
gint exponent_int = 0;
gfloat div = 1.0e-6f;
gfloat color[4] = { 0.0, 0.0, 0.0, 0.0 };
for (i = 0; i < HISTSIZE; i++)
hist_max = MAX (hist_max, hist[i]);
if ((exponent - floor (exponent)) < 0.001 && exponent <= 255.0)
exponent_int = (gint) exponent;
for (i = 0; i < HISTSIZE; i++)
{
gfloat ratio = (gfloat) hist[i] / (gfloat) hist_max;
gfloat weight;
if (exponent_int)
weight = fast_powf (ratio, exponent_int);
else
weight = pow (ratio, exponent);
if (hist[i] > 0)
for (b = 0; b < bpp; b++)
color[b] += weight * (gfloat) hist_rgb[b][i] / (gfloat) hist[i];
div += weight;
}
for (b = 0; b < bpp; b++)
{
gint c = (gint) (color[b] / div);
dest[b] = (guchar) CLAMP0255 (c);
}
}
inline static void
printHelpMessage(const char* cmdname)
{
printf("%s : Oilify a picture\n", cmdname);
printf("\n");
printf(" ARGUMENTS\n");
printf(" input file <string>\n");
printf(" output file <string> (overwrites if exists)\n");
printf(" radius [optional] <int> (0,30] (default: 4)\n");
printf(" exponent [optional] <float> [0.0, 20.0] (default: 8.0)\n");
printf("\n");
printf(" EXAMPLE\n");
printf(" %s input.png output.png\n", cmdname);
printf(" %s input.png output.png 6.0\n", cmdname);
printf(" %s input.png output.png 2.0 4.0\n", cmdname);
}
//////////////////////////////////////////////////////////////////////////////
//! Loads a Program file and prepends the cPreamble to the code.
//!
//! @return the source string if succeeded, 0 otherwise
//! @param cFilename program filename
//! @param cPreamble code that is prepended to the loaded file, typically a set of #defines or a header
//! @param szFinalLength returned length of the code string
//////////////////////////////////////////////////////////////////////////////
char* oclLoadProgSource(const char* cFilename, const char* cPreamble, size_t* szFinalLength)
{
// locals
FILE* pFileStream = NULL;
size_t szSourceLength;
// open the OpenCL source code file
#ifdef _WIN32 // Windows version
if(fopen_s(&pFileStream, cFilename, "rb") != 0)
{
return NULL;
}
#else // Linux version
pFileStream = fopen(cFilename, "rb");
if(pFileStream == 0)
{
return NULL;
}
#endif
size_t szPreambleLength = strlen(cPreamble);
// get the length of the source code
fseek(pFileStream, 0, SEEK_END);
szSourceLength = ftell(pFileStream);
fseek(pFileStream, 0, SEEK_SET);
// allocate a buffer for the source code string and read it in
char* cSourceString = (char *)malloc(szSourceLength + szPreambleLength + 1);
memcpy(cSourceString, cPreamble, szPreambleLength);
if (fread((cSourceString) + szPreambleLength, szSourceLength, 1, pFileStream) != 1)
{
fclose(pFileStream);
free(cSourceString);
return 0;
}
// close the file and return the total length of the combined (preamble + source) string
fclose(pFileStream);
if(szFinalLength != 0)
{
*szFinalLength = szSourceLength + szPreambleLength;
}
cSourceString[szSourceLength + szPreambleLength] = '\0';
return cSourceString;
}
// Round Up Division function
size_t shrRoundUp(int group_size, int global_size)
{
int r = global_size % group_size;
if(r == 0)
{
return global_size;
} else
{
return global_size + group_size - r;
}
}
//////////////////////////////////////////////////////////////////////////////
//! Get and log the binary (PTX) from the OpenCL compiler for the requested program & device
//!
//! @param cpProgram OpenCL program
//! @param cdDevice device of interest
//////////////////////////////////////////////////////////////////////////////
void oclLogBuildInfo(cl_program cpProgram, cl_device_id cdDevice)
{
// write out the build log and ptx, then exit
char cBuildLog[10240];
clGetProgramBuildInfo(cpProgram, cdDevice, CL_PROGRAM_BUILD_LOG,
sizeof(cBuildLog), cBuildLog, NULL );
printf("\n%s\nBuild Log:\n%s\n%s\n", HDASHLINE, cBuildLog, HDASHLINE);
}
//////////////////////////////////////////////////////////////////////////////
//! Get and log the binary (PTX) from the OpenCL compiler for the requested program & device
//!
//! @param cpProgram OpenCL program
//! @param cdDevice device of interest
//! @param const char* cPtxFileName optional PTX file name
//////////////////////////////////////////////////////////////////////////////
void oclLogPtx(cl_program cpProgram, cl_device_id cdDevice, const char* cPtxFileName)
{
// Grab the number of devices associated with the program
cl_uint num_devices;
clGetProgramInfo(cpProgram, CL_PROGRAM_NUM_DEVICES, sizeof(cl_uint), &num_devices, NULL);
// Grab the device ids
cl_device_id* devices = (cl_device_id*) malloc(num_devices * sizeof(cl_device_id));
clGetProgramInfo(cpProgram, CL_PROGRAM_DEVICES, num_devices * sizeof(cl_device_id), devices, 0);
// Grab the sizes of the binaries
size_t* binary_sizes = (size_t*)malloc(num_devices * sizeof(size_t));
clGetProgramInfo(cpProgram, CL_PROGRAM_BINARY_SIZES, num_devices * sizeof(size_t), binary_sizes, NULL);
// Now get the binaries
char** ptx_code = (char**)malloc(num_devices * sizeof(char*));
for( unsigned int i=0; i<num_devices; ++i)
{
ptx_code[i] = (char*)malloc(binary_sizes[i]);
}
clGetProgramInfo(cpProgram, CL_PROGRAM_BINARIES, 0, ptx_code, NULL);
// Find the index of the device of interest
unsigned int idx = 0;
while((idx < num_devices) && (devices[idx] != cdDevice))
{
++idx;
}
// If the index is associated, log the result
if(idx < num_devices)
{
// if a separate filename is supplied, dump ptx there
if (NULL != cPtxFileName)
{
printf("\nWriting ptx to separate file: %s ...\n\n", cPtxFileName);
FILE* pFileStream = NULL;
#ifdef _WIN32
fopen_s(&pFileStream, cPtxFileName, "wb");
#else
pFileStream = fopen(cPtxFileName, "wb");
#endif
fwrite(ptx_code[idx], binary_sizes[idx], 1, pFileStream);
fclose(pFileStream);
}
else // log to logfile and console if no ptx file specified
{
printf("\n%s\nProgram Binary:\n%s\n%s\n", HDASHLINE, ptx_code[idx], HDASHLINE);
}
}
// oilify_cleanup
free(devices);
free(binary_sizes);
for(unsigned int i = 0; i < num_devices; ++i)
{
free(ptx_code[i]);
}
free( ptx_code );
}
//////////////////////////////////////////////////////////////////////////////
//! Gets the id of the first device from the context
//!
//! @return the id
//! @param cxGPUContext OpenCL context
//////////////////////////////////////////////////////////////////////////////
cl_device_id oclGetFirstDev(cl_context cxGPUContext)
{
size_t szParmDataBytes;
cl_device_id* cdDevices;
// get the list of GPU devices associated with context
clGetContextInfo(cxGPUContext, CL_CONTEXT_DEVICES, 0, NULL, &szParmDataBytes);
cdDevices = (cl_device_id*) malloc(szParmDataBytes);
clGetContextInfo(cxGPUContext, CL_CONTEXT_DEVICES, szParmDataBytes, cdDevices, NULL);
cl_device_id first = cdDevices[0];
free(cdDevices);
return first;
}
int oilify_cleanup(OclContext* pOc)
{
assert(pOc);
OclContext& oc = *pOc;
if (oc.cxGpuContext)
{
clReleaseContext(oc.cxGpuContext);
oc.cxGpuContext = 0;
}
if(oc.cqCommandQueue)
{
clReleaseCommandQueue(oc.cqCommandQueue);
oc.cqCommandQueue = 0;
}
if(oc.cdDevices)
{
free(oc.cdDevices);
oc.cdDevices = 0;
}
if(oc.cSourceCL)
{
free(oc.cSourceCL);
oc.cSourceCL = 0;
}
if(oc.ckKernel)
{
clReleaseKernel(oc.ckKernel);
oc.ckKernel = 0;
}
if(oc.cpProgram)
{
clReleaseProgram(oc.cpProgram);
oc.cpProgram = 0;
}
if(oc.rgba)
{
clReleaseMemObject(oc.rgba);
oc.rgba = 0;
}
if(oc.inten)
{
clReleaseMemObject(oc.inten);
oc.inten = 0;
}
if(oc.outRgba)
{
clReleaseMemObject(oc.outRgba);
oc.outRgba = 0;
}
if(oc.outDebug)
{
clReleaseMemObject(oc.outDebug);
oc.outDebug = 0;
}
return 0;
}
static int radius_arg_index;
static int exponent_arg_index;
int oilify_radius(const OclContext* pOc, unsigned int radius)
{
return clSetKernelArg(pOc->ckKernel, radius_arg_index, sizeof(cl_int), (void*)&radius);
}
int oilify_exponent(const OclContext* pOc, unsigned int exponent)
{
return clSetKernelArg(pOc->ckKernel, exponent_arg_index, sizeof(cl_int), (void*)&exponent);
}
int oilify_prepare(OclContext* pOc, unsigned int w, unsigned int h, unsigned int radius, unsigned int exponent, int bFlipY)
{
assert(pOc);
OclContext& oc = *pOc;
cl_int ciErr1, ciErr2;
memset(&oc, 0, sizeof(OclContext));
oc.cxGpuContext = clCreateContextFromType(0, CL_DEVICE_TYPE_GPU, NULL, NULL, &ciErr1);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clCreateBuffer, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
oilify_cleanup(pOc);
exit(EXIT_FAILURE);
}
// Get the list of GPU devices associated with context
size_t szParmDataBytes;
ciErr1 = clGetContextInfo(oc.cxGpuContext, CL_CONTEXT_DEVICES, 0, NULL, &szParmDataBytes);
oc.cdDevices = (cl_device_id*)malloc(szParmDataBytes);
ciErr1 |= clGetContextInfo(oc.cxGpuContext, CL_CONTEXT_DEVICES, szParmDataBytes, oc.cdDevices, NULL);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clGetContextInfo, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
oilify_cleanup(pOc);
exit(EXIT_FAILURE);
}
// Create a command-queue on the first device
oc.cqCommandQueue = clCreateCommandQueue(oc.cxGpuContext, oc.cdDevices[0], 0, &ciErr1);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clCreateCommandQueue, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
oilify_cleanup(pOc);
exit(EXIT_FAILURE);
}
size_t szKernelLength;
oc.cSourceCL = oclLoadProgSource("d:/devel3/aran/src/oilify/oilify.cl", "", &szKernelLength);
// Create the program
oc.cpProgram = clCreateProgramWithSource(oc.cxGpuContext, 1, (const char **)&oc.cSourceCL, &szKernelLength, &ciErr1);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clCreateProgramWithSource, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
oilify_cleanup(pOc);
exit(EXIT_FAILURE);
}
ciErr1 = clBuildProgram(oc.cpProgram, 0, NULL, "-cl-unsafe-math-optimizations -cl-finite-math-only -cl-fast-relaxed-math", NULL, NULL);
oclLogBuildInfo(oc.cpProgram, oclGetFirstDev(oc.cxGpuContext));
oclLogPtx(oc.cpProgram, oclGetFirstDev(oc.cxGpuContext), "oilify-log.ptx");
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clBuildProgram, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
oilify_cleanup(pOc);
exit(EXIT_FAILURE);
}
// Create the kernel
oc.ckKernel = clCreateKernel(oc.cpProgram, "Oilify", &ciErr1);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clCreateKernel, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
oilify_cleanup(pOc);
exit(EXIT_FAILURE);
}
// Global and local work size calculation
//
// two-dimension work-item
// Use 9x9 neighbor pixels are used to calculate a pixel output
//
//static const size_t pixelNeighborSize = 9;
/*
szGlobalWorkSize[0] = shrRoundUp(pixelNeighborSize, w);
szGlobalWorkSize[1] = shrRoundUp(pixelNeighborSize, h);
szLocalWorkSize[0] = pixelNeighborSize;
szLocalWorkSize[1] = pixelNeighborSize;
*/
oc.szLocalWorkSize[0] = 256;
oc.szLocalWorkSize[1] = 1;
oc.szGlobalWorkSize[0] = shrRoundUp(256, w*h);
oc.szGlobalWorkSize[1] = 1;
// Allocate the OpenCL buffer memory objects for source and result on the device GMEM
printf("Actual global work size = %d = %dx%d\n", w*h, w, h);
printf("szGlobalWorkSize = %d = %dx%d\n", oc.szGlobalWorkSize[0]*oc.szGlobalWorkSize[1], oc.szGlobalWorkSize[0], oc.szGlobalWorkSize[1]);
printf("szLocalWorkSize = %d = %dx%d\n", oc.szLocalWorkSize[0]*oc.szLocalWorkSize[1], oc.szLocalWorkSize[0], oc.szLocalWorkSize[1]);
oc.rgba = clCreateBuffer(oc.cxGpuContext, CL_MEM_READ_ONLY, sizeof(cl_uchar4) * oc.szGlobalWorkSize[0] * oc.szGlobalWorkSize[1], NULL, &ciErr1);
oc.inten = clCreateBuffer(oc.cxGpuContext, CL_MEM_READ_ONLY, sizeof(cl_uchar) * oc.szGlobalWorkSize[0] * oc.szGlobalWorkSize[1], NULL, &ciErr2);
ciErr1 |= ciErr2;
oc.outRgba = clCreateBuffer(oc.cxGpuContext, CL_MEM_WRITE_ONLY, sizeof(cl_uchar4) * oc.szGlobalWorkSize[0] * oc.szGlobalWorkSize[1], NULL, &ciErr2);
ciErr1 |= ciErr2;
oc.outDebug = clCreateBuffer(oc.cxGpuContext, CL_MEM_WRITE_ONLY, sizeof(cl_float4) * oc.szGlobalWorkSize[0] * oc.szGlobalWorkSize[1], NULL, &ciErr2);
ciErr1 |= ciErr2;
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clCreateBuffer, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
oilify_cleanup(pOc);
exit(EXIT_FAILURE);
}
// Set the Argument values
int argIdx = 0;
ciErr1 = clSetKernelArg(oc.ckKernel, argIdx++, sizeof(cl_mem), (void*)&oc.rgba);
ciErr1 |= clSetKernelArg(oc.ckKernel, argIdx++, sizeof(cl_mem), (void*)&oc.inten);
ciErr1 |= clSetKernelArg(oc.ckKernel, argIdx++, sizeof(cl_mem), (void*)&oc.outRgba);
ciErr1 |= clSetKernelArg(oc.ckKernel, argIdx++, sizeof(cl_int), (void*)&w);
ciErr1 |= clSetKernelArg(oc.ckKernel, argIdx++, sizeof(cl_int), (void*)&h);
radius_arg_index = argIdx; // Will be used later
ciErr1 |= clSetKernelArg(oc.ckKernel, argIdx++, sizeof(cl_int), (void*)&radius);
exponent_arg_index = argIdx; // Will be used later
ciErr1 |= clSetKernelArg(oc.ckKernel, argIdx++, sizeof(cl_int), (void*)&exponent);
ciErr1 |= clSetKernelArg(oc.ckKernel, argIdx++, sizeof(cl_int), (void*)&bFlipY);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clSetKernelArg, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
oilify_cleanup(pOc);
exit(EXIT_FAILURE);
}
return 0;
}
int oilify_run(const OclContext* pOc, const unsigned char * const rgbData, unsigned int w, unsigned int h, unsigned char* ub_out)
{
assert(pOc);
const OclContext& oc = *pOc;
static const int bpp = 4;
cl_int ciErr1;
std::vector<unsigned char> srcInten(w * h);
BwWin32Timer timer;
timer.start();
#pragma omp parallel for schedule(dynamic)
for (int y = 0; y < (int)h; ++y)
{
for (int x = 0; x < (int)w; ++x)
{
const int pixelOffset = w*y + x;
unsigned char srcRgb[3] = { rgbData[bpp*pixelOffset + 0], rgbData[bpp*pixelOffset + 1], rgbData[bpp*pixelOffset + 2] };
srcInten[pixelOffset] = intensityFromRgb(srcRgb);
}
}
// --------------------------------------------------------
// Start Core sequence... copy input data to GPU, compute, copy results back
// Asynchronous write of data to GPU device
ciErr1 = clEnqueueWriteBuffer(oc.cqCommandQueue, oc.rgba, CL_FALSE, 0, sizeof(cl_uchar4) * w * h, &rgbData[0], 0, NULL, NULL);
ciErr1 |= clEnqueueWriteBuffer(oc.cqCommandQueue, oc.inten, CL_FALSE, 0, sizeof(cl_uchar) * w * h, &srcInten[0], 0, NULL, NULL);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clEnqueueWriteBuffer, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
return -1;
}
// Launch kernel
ciErr1 = clEnqueueNDRangeKernel(oc.cqCommandQueue, oc.ckKernel, 1, NULL, oc.szGlobalWorkSize, oc.szLocalWorkSize, 0, NULL, NULL);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clEnqueueNDRangeKernel, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
return -2;
}
// Synchronous/blocking read of results, and check accumulated errors
ciErr1 = clEnqueueReadBuffer(oc.cqCommandQueue, oc.outRgba, CL_TRUE, 0, sizeof(cl_uchar4) * w * h, ub_out, 0, NULL, NULL);
if (ciErr1 != CL_SUCCESS)
{
printf("Error in clEnqueueReadBuffer, Line %u in file %s !!!\n\n", __LINE__, __FILE__);
return -3;
}
printf("Process time: %lf ms\n", timer.getTicks());
return 0;
}
int main (int argc, const char* argv[])
{
// Default parameters
int radius = 2;
int exponent = 10;
// Parse arguments
if (argc == 3)
{
}
else if (argc == 4)
{
radius = atoi(argv[3]);
}
else if (argc == 5)
{
radius = atoi(argv[3]);
exponent = atoi(argv[4]);
}
else
{
printHelpMessage(argv[0]);
return 0;
}
// Check radius and exponent boundaries)
if (radius <= 0 || radius > 30 || exponent < 0 || exponent > 20)
{
printHelpMessage(argv[0]);
return 0;
}
const char* inputFileName = argv[1];
const char* outputFileName = argv[2];
if (ArnInitializeImageLibrary() < 0)
{
printf("Image library initialization failed.\n");
abort();
}
// Load an input image file.
ArnTexture* texture = ArnTexture::createFrom(inputFileName);
texture->init();
printf("Dimension : %d x %d\n", texture->getWidth(), texture->getHeight());
printf(" BPP : %d\n", texture->getBpp());
printf(" Type : ");
switch (texture->getFormat())
{
case ACF_RGB: printf("RGB"); break;
case ACF_RGBA: printf("RGBA"); break;
case ACF_BGR: printf("BGR"); break;
case ACF_BGRA: printf("BGRA"); break;
default: throw std::runtime_error("xxx");
}
printf("\n");
const std::vector<unsigned char>& rgbData = texture->getRawData();
const int w = texture->getWidth();
const int h = texture->getHeight();
const int bpp = texture->getBpp();
assert(rgbData.size() == w*h*texture->getBpp());
OclContext oc;
oilify_prepare(&oc, w, h, radius, exponent, true);
std::vector<unsigned char> outData(w * h * 4); // output image consists of RGB channels
oilify_run(&oc, &rgbData[0], w, h, &outData[0]);
oilify_cleanup(&oc);
delete texture;
ILuint ImageName;
ilGenImages(1, &ImageName);
ilBindImage(ImageName);
ilTexImage(w, h, 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, &outData[0]);
ilEnable(IL_FILE_OVERWRITE);
ilSave(IL_PNG, outputFileName);
ilDeleteImages(1, &ImageName);
if (ArnCleanupImageLibrary() < 0)
{
printf("Image library cleanup failed.\n");
}
return 0;
}
| [
"[email protected]"
] | [
[
[
1,
656
]
]
] |
ac9dd65f11a66373094bb57c8f45861be5d70ee6 | ea12fed4c32e9c7992956419eb3e2bace91f063a | /zombie/code/zombie/gpbasicactions/src/gpactionscript/ngpactionscript.cc | a36e9d8fb4a476d48dc415e886b4b56f3c217f95 | [] | no_license | ugozapad/TheZombieEngine | 832492930df28c28cd349673f79f3609b1fe7190 | 8e8c3e6225c2ed93e07287356def9fbdeacf3d6a | refs/heads/master | 2020-04-30T11:35:36.258363 | 2011-02-24T14:18:43 | 2011-02-24T14:18:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 619 | cc | //------------------------------------------------------------------------------
// ngpactionscript.cc
// (C) 2005 Conjurer Services, S.A.
//------------------------------------------------------------------------------
#include "precompiled/pchgpbasicactions.h"
#include "gpactionscript/ngpactionscript.h"
nNebulaScriptClass(nGPActionScript, "ngpbasicaction");
//------------------------------------------------------------------------------
/**
Nebula class scripting initialization
*/
NSCRIPT_INITCMDS_BEGIN (nGPActionScript)
// Empty: all commands are scripts
NSCRIPT_INITCMDS_END()
| [
"magarcias@c1fa4281-9647-0410-8f2c-f027dd5e0a91"
] | [
[
[
1,
18
]
]
] |
54512731de40d735624dc28d2096ea01ec1d12ed | 2dbbca065b62a24f47aeb7ec5cd7a4fd82083dd4 | /OUAN/OUAN/Src/Game/GameObject/GameObjectNightGoblin.h | 32c4706b43802539c4ac119e04e8606a25902a99 | [] | no_license | juanjmostazo/once-upon-a-night | 9651dc4dcebef80f0475e2e61865193ad61edaaa | f8d5d3a62952c45093a94c8b073cbb70f8146a53 | refs/heads/master | 2020-05-28T05:45:17.386664 | 2010-10-06T12:49:50 | 2010-10-06T12:49:50 | 38,101,059 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,057 | h | #ifndef GameObjectNightGoblinH_H
#define GameObjectNightGoblinH_H
#include "GameObject.h"
#include "../../Graphics/RenderComponent/RenderComponentInitial.h"
#include "../../Graphics/RenderComponent/RenderComponentPositional.h"
#include "../../Graphics/RenderComponent/RenderComponentEntity.h"
#include "../../Physics/PhysicsComponent/PhysicsComponentCharacter.h"
#include "../../Logic/LogicComponent/LogicComponentEnemy.h"
namespace OUAN
{
/// Class modelling a particular enemy type
class GameObjectNightGoblin : public GameObject, public boost::enable_shared_from_this<GameObjectNightGoblin>
{
private:
/// Visual component
RenderComponentEntityPtr mRenderComponentEntityDreams;
RenderComponentEntityPtr mRenderComponentEntityNightmares;
/// Positional component
RenderComponentInitialPtr mRenderComponentInitial;
RenderComponentPositionalPtr mRenderComponentPositional;
/// Physics information
PhysicsComponentCharacterPtr mPhysicsComponentCharacter;
/// Logic component: it'll represent the 'brains' of the game object
/// containing information on its current state, its life and health(if applicable),
/// or the world(s) the object belongs to
LogicComponentEnemyPtr mLogicComponentEnemy;
public:
/// Constructor
/// @param name name of the game object, specific to this class
/// @param id unique id of the game object
GameObjectNightGoblin(const std::string& name);
//Destructor
~GameObjectNightGoblin();
/// Set logic component
void setLogicComponentEnemy(LogicComponentEnemyPtr logicComponentEnemy);
/// return logic component
LogicComponentEnemyPtr getLogicComponentEnemy();
/// Return render component entity
/// @return render component entity
RenderComponentEntityPtr getRenderComponentEntityDreams() const;
RenderComponentEntityPtr getRenderComponentEntityNightmares() const;
/// Set render component
/// @param pRenderComponentEntity
void setRenderComponentEntityDreams(RenderComponentEntityPtr pRenderComponentEntityDreams);
void setRenderComponentEntityNightmares(RenderComponentEntityPtr pRenderComponentEntityNightmares);
/// Set positional component
/// @param pRenderComponentPositional the component containing the positional information
void setRenderComponentPositional(RenderComponentPositionalPtr pRenderComponentPositional);
/// Set initial component
void setRenderComponentInitial(RenderComponentInitialPtr pRenderComponentInitial);
/// Return positional component
/// @return positional component
RenderComponentPositionalPtr getRenderComponentPositional() const;
/// Return initial component
/// @return initial component
RenderComponentInitialPtr getRenderComponentInitial() const;
/// Set physics component
void setPhysicsComponentCharacter(PhysicsComponentCharacterPtr pPhysicsComponentCharacter);
/// Get physics component
PhysicsComponentCharacterPtr getPhysicsComponentCharacter() const;
/// Update object
virtual void update(double elapsedSeconds);
/// Reset object
virtual void reset();
/// React to a world change to the one given as a parameter
/// @param world world to change to
void changeToWorld(int newWorld, double perc);
void changeWorldFinished(int newWorld);
void changeWorldStarted(int newWorld);
bool hasPositionalComponent() const;
RenderComponentPositionalPtr getPositionalComponent() const;
bool hasPhysicsComponent() const;
PhysicsComponentPtr getPhysicsComponent() const;
bool hasRenderComponentEntity() const;
RenderComponentEntityPtr getEntityComponent() const;
/// Process collision event
/// @param gameObject which has collision with
void processCollision(GameObjectPtr pGameObject, Ogre::Vector3 pNormal);
/// Process collision event
/// @param gameObject which has collision with
void processEnterTrigger(GameObjectPtr pGameObject);
/// Process collision event
/// @param gameObject which has collision with
void processExitTrigger(GameObjectPtr pGameObject);
bool hasLogicComponent() const;
LogicComponentPtr getLogicComponent() const;
};
/// Information data structure to carry around data between the
/// level loader and the "GameObjectNightGoblin"
class TGameObjectNightGoblinParameters: public TGameObjectParameters
{
public:
/// Default constructor
TGameObjectNightGoblinParameters();
/// Default destructor
~TGameObjectNightGoblinParameters();
///Parameters specific to an Ogre Entity
TRenderComponentEntityParameters tRenderComponentEntityDreamsParameters;
TRenderComponentEntityParameters tRenderComponentEntityNightmaresParameters;
///Positional parameters
TRenderComponentPositionalParameters tRenderComponentPositionalParameters;
///Physics parameters
TPhysicsComponentCharacterParameters tPhysicsComponentCharacterParameters;
///Logic parameters
TLogicComponentEnemyParameters tLogicComponentEnemyParameters;
};
}
#endif | [
"wyern1@1610d384-d83c-11de-a027-019ae363d039",
"juanj.mostazo@1610d384-d83c-11de-a027-019ae363d039",
"ithiliel@1610d384-d83c-11de-a027-019ae363d039"
] | [
[
[
1,
4
],
[
6,
9
],
[
11,
20
],
[
22,
55
],
[
59,
62
],
[
67,
74
],
[
79,
85
],
[
89,
91
],
[
95,
96
],
[
98,
106
],
[
111,
140
]
],
[
[
5,
5
],
[
10,
10
],
[
21,
21
],
[
56,
58
],
[
63,
66
],
[
75,
78
],
[
97,
97
]
],
[
[
86,
88
],
[
92,
94
],
[
107,
110
]
]
] |
245bd74454f533f7316838457f19214c3e00ddb6 | 2d4221efb0beb3d28118d065261791d431f4518a | /OIDE源代码/OLIDE/CPUWatchWnd.cpp | bb2affc3a70a0df16336c995ddf45db31057001f | [] | no_license | ophyos/olanguage | 3ea9304da44f54110297a5abe31b051a13330db3 | 38d89352e48c2e687fd9410ffc59636f2431f006 | refs/heads/master | 2021-01-10T05:54:10.604301 | 2010-03-23T11:38:51 | 2010-03-23T11:38:51 | 48,682,489 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 13,280 | cpp | // CPUWatchWnd.cpp : 实现文件
//
#include "stdafx.h"
#include "OLIDE.h"
#include "CPUWatchWnd.h"
#include "UserWmMsg.h"
#include "Debugger/DebugData.h"
// CCPUWatchWnd 对话框
IMPLEMENT_DYNAMIC(CCPUWatchWnd, CDialog)
CCPUWatchWnd::CCPUWatchWnd(CWnd* pParent /*=NULL*/)
: CDialog(CCPUWatchWnd::IDD, pParent)
, m_strEAX(_T(""))
, m_strEBX(_T(""))
, m_strECX(_T(""))
, m_strEDX(_T(""))
, m_strEBP(_T(""))
, m_strESP(_T(""))
, m_strESI(_T(""))
, m_strEDI(_T(""))
, m_strEIP(_T(""))
, m_strCS(_T(""))
, m_strDS(_T(""))
, m_strES(_T(""))
, m_strSS(_T(""))
, m_strFS(_T(""))
, m_strGS(_T(""))
,m_strST0(_T(""))
,m_strST1(_T(""))
,m_strST2(_T(""))
,m_strST3(_T(""))
,m_strST4(_T(""))
,m_strST5(_T(""))
,m_strST6(_T(""))
,m_strST7(_T(""))
,m_strXMM0(_T(""))
,m_strXMM1(_T(""))
,m_strXMM2(_T(""))
,m_strXMM3(_T(""))
,m_strXMM4(_T(""))
,m_strXMM5(_T(""))
,m_strXMM6(_T(""))
,m_strXMM7(_T(""))
{
}
CCPUWatchWnd::~CCPUWatchWnd()
{
}
void CCPUWatchWnd::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
DDX_Text(pDX, IDC_EDIT_EAX, m_strEAX);
DDX_Text(pDX, IDC_EDIT_EBX, m_strEBX);
DDX_Text(pDX, IDC_EDIT_ECX, m_strECX);
DDX_Text(pDX, IDC_EDIT_EDX, m_strEDX);
DDX_Text(pDX, IDC_EDIT_EBP, m_strEBP);
DDX_Text(pDX, IDC_EDIT_ESP, m_strESP);
DDX_Text(pDX, IDC_EDIT_ESI, m_strESI);
DDX_Text(pDX, IDC_EDIT_EDI, m_strEDI);
DDX_Text(pDX, IDC_EDIT_EIP, m_strEIP);
DDX_Control(pDX, IDC_LIST_EFLAG32, m_listEFlag32);
DDX_Text(pDX, IDC_EDIT_CS, m_strCS);
DDX_Text(pDX, IDC_EDIT_DS, m_strDS);
DDX_Text(pDX, IDC_EDIT_ES, m_strES);
DDX_Text(pDX, IDC_EDIT_SS, m_strSS);
DDX_Text(pDX, IDC_EDIT_FS, m_strFS);
DDX_Text(pDX, IDC_EDIT_GS, m_strGS);
DDX_Text(pDX, IDC_EDIT_ST0_MMX0, m_strST0);
DDX_Text(pDX, IDC_EDIT_ST1_MMX1, m_strST1);
DDX_Text(pDX, IDC_EDIT_ST2_MMX2, m_strST2);
DDX_Text(pDX, IDC_EDIT_ST3_MMX3, m_strST3);
DDX_Text(pDX, IDC_EDIT_ST4_MMX4, m_strST4);
DDX_Text(pDX, IDC_EDIT_ST5_MMX5, m_strST5);
DDX_Text(pDX, IDC_EDIT_ST6_MMX6, m_strST6);
DDX_Text(pDX, IDC_EDIT_ST7_MMX7, m_strST7);
DDX_Text(pDX, IDC_EDIT_XMM0, m_strXMM0);
DDX_Text(pDX, IDC_EDIT_XMM1, m_strXMM1);
DDX_Text(pDX, IDC_EDIT_XMM2, m_strXMM2);
DDX_Text(pDX, IDC_EDIT_XMM3, m_strXMM3);
DDX_Text(pDX, IDC_EDIT_XMM4, m_strXMM4);
DDX_Text(pDX, IDC_EDIT_XMM5, m_strXMM5);
DDX_Text(pDX, IDC_EDIT_XMM6, m_strXMM6);
DDX_Text(pDX, IDC_EDIT_XMM7, m_strXMM7);
}
BEGIN_MESSAGE_MAP(CCPUWatchWnd, CDialog)
ON_MESSAGE(WM_DEBUGGER_CLEAR_DEBUG_DATA, &CCPUWatchWnd::OnDebuggerClearDebugData)
ON_MESSAGE(WM_DEBUGGER_SHOW_CPU_DATA, &CCPUWatchWnd::OnDebuggerShowCPUData)
END_MESSAGE_MAP()
// CCPUWatchWnd 消息处理程序
LRESULT CCPUWatchWnd::OnDebuggerClearDebugData(WPARAM wParam,LPARAM lParam)
{
m_strEAX.Empty();
m_strEBX.Empty();
m_strECX.Empty();
m_strEDX.Empty();
m_strEBP.Empty();
m_strESP.Empty();
m_strESI.Empty();
m_strEDI.Empty();
m_strEIP.Empty();
int i;
for(i=0;i<16;++i)
{
m_listEFlag32.SetItemText(2,i,m_strEAX);
}
for(i=0;i<16;++i)
{
m_listEFlag32.SetItemText(5,i,m_strEAX);
}
m_strCS.Empty();
m_strDS.Empty();
m_strES.Empty();
m_strSS.Empty();
m_strFS.Empty();
m_strGS.Empty();
m_strST0.Empty();
m_strST1.Empty();
m_strST2.Empty();
m_strST3.Empty();
m_strST4.Empty();
m_strST5.Empty();
m_strST6.Empty();
m_strST7.Empty();
m_strXMM0.Empty();
m_strXMM1.Empty();
m_strXMM2.Empty();
m_strXMM3.Empty();
m_strXMM4.Empty();
m_strXMM5.Empty();
m_strXMM6.Empty();
m_strXMM7.Empty();
UpdateData(FALSE);
return 1;
}
LRESULT CCPUWatchWnd::OnDebuggerShowCPUData(WPARAM wParam,LPARAM lParam)
{
DEBUGGER_CPU_CONTEXT* p_debugger_cpu_context = (DEBUGGER_CPU_CONTEXT*)wParam;
DEBUGGER_CPU* p_debugger_cpu = &p_debugger_cpu_context->m_debug_cpu;
m_strEAX.Format(_T("%08X"),p_debugger_cpu->EAX);
m_strEBX.Format(_T("%08X"),p_debugger_cpu->EBX);
m_strECX.Format(_T("%08X"),p_debugger_cpu->ECX);
m_strEDX.Format(_T("%08X"),p_debugger_cpu->EDX);
m_strEBP.Format(_T("%08X"),p_debugger_cpu->EBP);
m_strESP.Format(_T("%08X"),p_debugger_cpu->ESP);
m_strESI.Format(_T("%08X"),p_debugger_cpu->ESI);
m_strEDI.Format(_T("%08X"),p_debugger_cpu->EDI);
m_strEIP.Format(_T("%08X"),p_debugger_cpu->EIP-1); //显示EIP寄存器值时退回一个0xCC字节
p_debugger_cpu->EFlags;
TCHAR* ptch0 = _T("0");
TCHAR* ptch1 = _T("1");
TCHAR* tchBitData[] =
{
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
tchBitData[0] = ((p_debugger_cpu->EFlags & 0x80000000) == 0x80000000)?ptch1:ptch0;
tchBitData[1] = ((p_debugger_cpu->EFlags & 0x40000000) == 0x40000000)?ptch1:ptch0;
tchBitData[2] = ((p_debugger_cpu->EFlags & 0x20000000) == 0x20000000)?ptch1:ptch0;
tchBitData[3] = ((p_debugger_cpu->EFlags & 0x10000000) == 0x10000000)?ptch1:ptch0;
tchBitData[4] = ((p_debugger_cpu->EFlags & 0x08000000) == 0x08000000)?ptch1:ptch0;
tchBitData[5] = ((p_debugger_cpu->EFlags & 0x04000000) == 0x04000000)?ptch1:ptch0;
tchBitData[6] = ((p_debugger_cpu->EFlags & 0x02000000) == 0x02000000)?ptch1:ptch0;
tchBitData[7] = ((p_debugger_cpu->EFlags & 0x01000000) == 0x01000000)?ptch1:ptch0;
tchBitData[8] = ((p_debugger_cpu->EFlags & 0x00800000) == 0x00800000)?ptch1:ptch0;
tchBitData[9] = ((p_debugger_cpu->EFlags & 0x00400000) == 0x00400000)?ptch1:ptch0;
tchBitData[10] = ((p_debugger_cpu->EFlags & 0x00200000) == 0x00200000)?ptch1:ptch0;
tchBitData[11] = ((p_debugger_cpu->EFlags & 0x00100000) == 0x00100000)?ptch1:ptch0;
tchBitData[12] = ((p_debugger_cpu->EFlags & 0x00080000) == 0x00080000)?ptch1:ptch0;
tchBitData[13] = ((p_debugger_cpu->EFlags & 0x00040000) == 0x00040000)?ptch1:ptch0;
tchBitData[14] = ((p_debugger_cpu->EFlags & 0x00020000) == 0x00020000)?ptch1:ptch0;
tchBitData[15] = ((p_debugger_cpu->EFlags & 0x00010000) == 0x00010000)?ptch1:ptch0;
tchBitData[16] = ((p_debugger_cpu->EFlags & 0x00008000) == 0x00008000)?ptch1:ptch0;
tchBitData[17] = ((p_debugger_cpu->EFlags & 0x00004000) == 0x00004000)?ptch1:ptch0;
tchBitData[18] = ((p_debugger_cpu->EFlags & 0x00002000) == 0x00002000)?ptch1:ptch0;
tchBitData[19] = ((p_debugger_cpu->EFlags & 0x00001000) == 0x00001000)?ptch1:ptch0;
tchBitData[20] = ((p_debugger_cpu->EFlags & 0x00000800) == 0x00000800)?ptch1:ptch0;
tchBitData[21] = ((p_debugger_cpu->EFlags & 0x00000400) == 0x00000400)?ptch1:ptch0;
tchBitData[22] = ((p_debugger_cpu->EFlags & 0x00000200) == 0x00000200)?ptch1:ptch0;
tchBitData[23] = ((p_debugger_cpu->EFlags & 0x00000100) == 0x00000100)?ptch1:ptch0;
tchBitData[24] = ((p_debugger_cpu->EFlags & 0x00000080) == 0x00000080)?ptch1:ptch0;
tchBitData[25] = ((p_debugger_cpu->EFlags & 0x00000040) == 0x00000040)?ptch1:ptch0;
tchBitData[26] = ((p_debugger_cpu->EFlags & 0x00000020) == 0x00000020)?ptch1:ptch0;
tchBitData[27] = ((p_debugger_cpu->EFlags & 0x00000010) == 0x00000010)?ptch1:ptch0;
tchBitData[28] = ((p_debugger_cpu->EFlags & 0x00000008) == 0x00000008)?ptch1:ptch0;
tchBitData[29] = ((p_debugger_cpu->EFlags & 0x00000004) == 0x00000004)?ptch1:ptch0;
tchBitData[30] = ((p_debugger_cpu->EFlags & 0x00000002) == 0x00000002)?ptch1:ptch0;
tchBitData[31] = ((p_debugger_cpu->EFlags & 0x00000001) == 0x00000001)?ptch1:ptch0;
int i;
for(i=0;i<16;++i)
{
m_listEFlag32.SetItemText(2,i,tchBitData[i]);
}
for(i=0;i<16;++i)
{
m_listEFlag32.SetItemText(5,i,tchBitData[16+i]);
}
//段寄存器
m_strCS.Format(_T("%04X"),p_debugger_cpu->CS);
m_strDS.Format(_T("%04X"),p_debugger_cpu->DS);
m_strES.Format(_T("%04X"),p_debugger_cpu->ES);
m_strSS.Format(_T("%04X"),p_debugger_cpu->SS);
m_strFS.Format(_T("%04X"),p_debugger_cpu->FS);
m_strGS.Format(_T("%04X"),p_debugger_cpu->GS);
//浮点寄存器
m_strST0.Format(_T("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"),
p_debugger_cpu->ST0[0],p_debugger_cpu->ST0[1],p_debugger_cpu->ST0[2],p_debugger_cpu->ST0[3],p_debugger_cpu->ST0[4],
p_debugger_cpu->ST0[5],p_debugger_cpu->ST0[6],p_debugger_cpu->ST0[7],p_debugger_cpu->ST0[8],p_debugger_cpu->ST0[9]);
m_strST1.Format(_T("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"),
p_debugger_cpu->ST1[0],p_debugger_cpu->ST1[1],p_debugger_cpu->ST1[2],p_debugger_cpu->ST1[3],p_debugger_cpu->ST1[4],
p_debugger_cpu->ST1[5],p_debugger_cpu->ST1[6],p_debugger_cpu->ST1[7],p_debugger_cpu->ST1[8],p_debugger_cpu->ST1[9]);
m_strST2.Format(_T("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"),
p_debugger_cpu->ST2[0],p_debugger_cpu->ST2[1],p_debugger_cpu->ST2[2],p_debugger_cpu->ST2[3],p_debugger_cpu->ST2[4],
p_debugger_cpu->ST2[5],p_debugger_cpu->ST2[6],p_debugger_cpu->ST2[7],p_debugger_cpu->ST2[8],p_debugger_cpu->ST2[9]);
m_strST3.Format(_T("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"),
p_debugger_cpu->ST3[0],p_debugger_cpu->ST3[1],p_debugger_cpu->ST3[2],p_debugger_cpu->ST3[3],p_debugger_cpu->ST3[4],
p_debugger_cpu->ST3[5],p_debugger_cpu->ST3[6],p_debugger_cpu->ST3[7],p_debugger_cpu->ST3[8],p_debugger_cpu->ST3[9]);
m_strST4.Format(_T("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"),
p_debugger_cpu->ST4[0],p_debugger_cpu->ST4[1],p_debugger_cpu->ST4[2],p_debugger_cpu->ST4[3],p_debugger_cpu->ST4[4],
p_debugger_cpu->ST4[5],p_debugger_cpu->ST4[6],p_debugger_cpu->ST4[7],p_debugger_cpu->ST4[8],p_debugger_cpu->ST4[9]);
m_strST5.Format(_T("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"),
p_debugger_cpu->ST5[0],p_debugger_cpu->ST5[1],p_debugger_cpu->ST5[2],p_debugger_cpu->ST5[3],p_debugger_cpu->ST5[4],
p_debugger_cpu->ST5[5],p_debugger_cpu->ST5[6],p_debugger_cpu->ST5[7],p_debugger_cpu->ST5[8],p_debugger_cpu->ST5[9]);
m_strST6.Format(_T("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"),
p_debugger_cpu->ST6[0],p_debugger_cpu->ST6[1],p_debugger_cpu->ST6[2],p_debugger_cpu->ST6[3],p_debugger_cpu->ST6[4],
p_debugger_cpu->ST6[5],p_debugger_cpu->ST6[6],p_debugger_cpu->ST6[7],p_debugger_cpu->ST6[8],p_debugger_cpu->ST6[9]);
m_strST7.Format(_T("%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"),
p_debugger_cpu->ST7[0],p_debugger_cpu->ST7[1],p_debugger_cpu->ST7[2],p_debugger_cpu->ST7[3],p_debugger_cpu->ST7[4],
p_debugger_cpu->ST7[5],p_debugger_cpu->ST7[6],p_debugger_cpu->ST7[7],p_debugger_cpu->ST7[8],p_debugger_cpu->ST7[9]);
//XMM寄存器
/*m_strXMM0.Format(_T("%016X%016X"),p_debugger_cpu->XMM0.High,p_debugger_cpu->XMM0.Low);
m_strXMM1.Format(_T("%016X%016X"),p_debugger_cpu->XMM1.High,p_debugger_cpu->XMM1.Low);
m_strXMM2.Format(_T("%016X%016X"),p_debugger_cpu->XMM2.High,p_debugger_cpu->XMM2.Low);
m_strXMM3.Format(_T("%016X%016X"),p_debugger_cpu->XMM3.High,p_debugger_cpu->XMM3.Low);
m_strXMM4.Format(_T("%016X%016X"),p_debugger_cpu->XMM4.High,p_debugger_cpu->XMM4.Low);
m_strXMM5.Format(_T("%016X%016X"),p_debugger_cpu->XMM5.High,p_debugger_cpu->XMM5.Low);
m_strXMM6.Format(_T("%016X%016X"),p_debugger_cpu->XMM6.High,p_debugger_cpu->XMM6.Low);
m_strXMM7.Format(_T("%016X%016X"),p_debugger_cpu->XMM7.High,p_debugger_cpu->XMM7.Low);*/
UpdateData(FALSE);
return 1;
}
BOOL CCPUWatchWnd::OnInitDialog()
{
CDialog::OnInitDialog();
// TODO: 在此添加额外的初始化
InitEFlag32List();
return TRUE; // return TRUE unless you set the focus to a control
// 异常: OCX 属性页应返回 FALSE
}
void CCPUWatchWnd::InitEFlag32List()
{
int i;
for(i=0;i<16;++i)
{
m_listEFlag32.InsertColumn(0,_T("a"),LVCFMT_CENTER,25);
}
m_listEFlag32.InsertItem(0,_T(""),0);
m_listEFlag32.InsertItem(1,_T(""),0);
m_listEFlag32.InsertItem(2,_T(""),0);
m_listEFlag32.InsertItem(3,_T(""),0);
m_listEFlag32.InsertItem(4,_T(""),0);
m_listEFlag32.InsertItem(5,_T(""),0);
LOGFONT lf;
memset(&lf,0,sizeof(LOGFONT)); // zero out structure
lf.lfHeight = 12; // request a 12-pixel-heightfont
wcscpy(lf.lfFaceName,_T("宋体")); // request a face name "Arial"
m_listFont.CreateFontIndirect(&lf); // create the font
m_listEFlag32.SetFont(&m_listFont, TRUE);
CString strText;
for(i=0;i<16;++i)
{
strText.Format(_T("%02d"),31-i);
m_listEFlag32.SetItemText(0,i,strText);
}
for(i=0;i<16;++i)
{
strText.Format(_T("%02d"),15-i);
m_listEFlag32.SetItemText(3,i,strText);
}
TCHAR* tchBitName[] =
{
// 31 30 29 28 27 26 25 24
_T("－"),_T("－"),_T("－"),_T("－"),_T("－"),_T("－"),_T("－"),_T("－"),
// 23 22 21 20 19 18 17 16
_T("－"),_T("－"),_T("ID"),_T("VP"),_T("VI"),_T("AC"),_T("VM"),_T("RF"),
// 15 14 13 12 11 10 09 08
_T( "0"),_T("NT"),_T("IO"),_T("PL"),_T("OF"),_T("DF"),_T("IF"),_T("TF"),
// 07 06 05 04 03 02 01 00
_T("SF"),_T("ZF"), _T("0"),_T("AF"), _T("0"),_T("PF"), _T("1"),_T("CF")
};
for(i=0;i<16;++i)
{
m_listEFlag32.SetItemText(1,i,tchBitName[i]);
}
for(i=0;i<16;++i)
{
m_listEFlag32.SetItemText(4,i,tchBitName[16+i]);
}
//显示网格
m_listEFlag32.SetExtendedStyle(m_listEFlag32.GetExtendedStyle()|LVS_EX_GRIDLINES);
} | [
"[email protected]"
] | [
[
[
1,
338
]
]
] |
ea0341dc213fcb5d5216605be9cd149a97dc17cb | f78d9c67f1785c436050d3c1ca40bf4253501717 | /Win.cpp | 363a248486116fb9e3fad9b224c8cde849bfc691 | [] | no_license | elcerdo/pixelcity | 0cdafbd013994475cd1db5919807f4e537d58b4c | aafecd6bd344ec79298d8aaf0c08426934fc2049 | refs/heads/master | 2021-01-10T22:06:18.964202 | 2009-05-13T19:15:40 | 2009-05-13T19:15:40 | 194,478 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 12,250 | cpp | /*-----------------------------------------------------------------------------
Win.cpp
2006 Shamus Young
-------------------------------------------------------------------------------
Create the main window and make it go.
-----------------------------------------------------------------------------*/
#define MOUSE_MOVEMENT 0.5f
#include <cmath>
#include <cstdarg>
#include <cstring>
#include <cstdio>
#include <ctime>
#include <SDL/SDL.h>
#include "Linux.h"
#include "Camera.h"
#include "Car.h"
#include "Entity.h"
#include "Ini.h"
#include "Macro.h"
#include "Random.h"
#include "Render.h"
#include "Texture.h"
#include "Win.h"
#include "World.h"
#include "Visible.h"
#include "glTypes.h"
#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "glu32.lib")
#if SCREENSAVER
#pragma comment (lib, "scrnsave.lib")
#endif
//static HWND hwnd;
//static HINSTANCE module;
static int width;
static int height;
static int half_width;
static int half_height;
static bool lmb;
static bool rmb;
static bool mouse_forced;
static POINT select_pos;
static POINT mouse_pos;
static bool quit;
//static HINSTANCE instance;
///*-----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------*/
//
//static void CenterCursor ()
//{
//
// int center_x;
// int center_y;
// RECT rect;
//
// SetCursor (NULL);
// mouse_forced = true;
// GetWindowRect (hwnd, &rect);
// center_x = rect.left + (rect.right - rect.left) / 2;
// center_y = rect.top + (rect.bottom - rect.top) / 2;
// SetCursorPos (center_x, center_y);
//
//}
///*-----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------*/
//
//static void MoveCursor (int x, int y)
//{
//
// int center_x;
// int center_y;
// RECT rect;
//
// SetCursor (NULL);
// mouse_forced = true;
// GetWindowRect (hwnd, &rect);
// center_x = rect.left + x;
// center_y = rect.top + y;
// SetCursorPos (center_x, center_y);
//
//}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
//LRESULT CALLBACK WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
//{
//
//
// RECT r;
// float delta_x, delta_y;
// POINT p;
// int param;
// int key;
//
// switch (message) {
// case WM_SIZE:
// param = wParam; // resizing flag
// width = LOWORD(lParam); // width of client area
// height = HIWORD(lParam); // height of client area
//
// if (param == SIZE_RESTORED)
// IniIntSet ("WindowMaximized", 0);
// if (param == SIZE_MAXIMIZED) {
// IniIntSet ("WindowMaximized", 1);
// } else {
// IniIntSet ("WindowWidth", width);
// IniIntSet ("WindowHeight", height);
// }
// RenderResize ();
// return 0;
// case WM_MOVE:
// GetClientRect (hwnd, &r);
// height = r.bottom - r.top;
// width = r.right - r.left;
// IniIntSet ("WindowX", r.left);
// IniIntSet ("WindowY", r.top);
// IniIntSet ("WindowWidth", width);
// IniIntSet ("WindowHeight", height);
// half_width = width / 2;
// half_height = height / 2;
// break;
// case WM_KEYDOWN:
// key = (int) wParam;
//
// if (key == 'R')
// WorldReset ();
// if (key == 'C')
// CameraAutoToggle ();
// if (key == 'W')
// RenderWireframeToggle ();
// if (key == 'E')
// RenderEffectCycle ();
// if (key == 'L')
// RenderLetterboxToggle ();
// if (key == 'F')
// RenderFPSToggle ();
// if (key == 'G')
// RenderFogToggle ();
// if (key == 'T')
// RenderFlatToggle ();
// if (key == VK_F1)
// RenderHelpToggle ();
// if (key == 'B')
// CameraNextBehavior ();
// if (key == VK_ESCAPE)
// quit = true;
// if (key == VK_F5)
// CameraReset ();
// return 0;
// case WM_LBUTTONDOWN:
// lmb = true;
// SetCapture (hwnd);
// break;
// case WM_RBUTTONDOWN:
// rmb = true;
// SetCapture (hwnd);
// break;
// case WM_LBUTTONUP:
// lmb = false;
// if (!rmb) {
// ReleaseCapture ();
// MoveCursor (select_pos.x, select_pos.y);
// }
// break;
// case WM_RBUTTONUP:
// rmb = false;
// if (!lmb) {
// ReleaseCapture ();
// MoveCursor (select_pos.x, select_pos.y);
// }
// break;
// case WM_MOUSEMOVE:
// p.x = LOWORD(lParam); // horizontal position of cursor
// p.y = HIWORD(lParam); // vertical position of cursor
// if (p.x < 0 || p.x > width)
// break;
// if (p.y < 0 || p.y > height)
// break;
// if (!mouse_forced && !lmb && !rmb) {
// select_pos = p;
// }
// if (mouse_forced) {
// mouse_forced = false;
// } else if (rmb || lmb) {
// CenterCursor ();
// delta_x = (float)(mouse_pos.x - p.x) * MOUSE_MOVEMENT;
// delta_y = (float)(mouse_pos.y - p.y) * MOUSE_MOVEMENT;
// if (rmb && lmb) {
// GLvector pos;
// CameraPan (delta_x);
// pos = CameraPosition ();
// pos.y += delta_y;
// CameraPositionSet (pos);
// } else if (rmb) {
// CameraPan (delta_x);
// CameraForward (delta_y);
// } else if (lmb) {
// GLvector angle;
// angle = CameraAngle ();
// angle.y -= delta_x;
// angle.x += delta_y;
// CameraAngleSet (angle);
// }
// }
// mouse_pos = p;
// break;
// case WM_CLOSE:
// quit = true;
// return 0;
// }
// return DefWindowProc(hWnd, message, wParam, lParam);
//
//}
/*-----------------------------------------------------------------------------
n o t e
-----------------------------------------------------------------------------*/
void WinPopup (char* message, ...)
{
va_list marker;
char buf[1024];
va_start (marker, message);
vsprintf (buf, message, marker);
va_end (marker);
printf(buf);
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int WinWidth (void)
{
return width;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void WinMousePosition (int* x, int* y)
{
*x = select_pos.x;
*y = select_pos.y;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int WinHeight (void)
{
return height;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void WinTerm (void)
{
}
///*-----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------*/
//
//HWND WinHwnd (void)
//{
//
// return hwnd;
//
//}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
bool WinInit (void)
{
//WNDCLASSEX wcex;
//int x, y;
//int style;
//bool max;
//wcex.cbSize = sizeof(WNDCLASSEX);
//wcex.style = CS_HREDRAW | CS_VREDRAW;
//wcex.lpfnWndProc = (WNDPROC)WndProc;
//wcex.cbClsExtra = 0;
//wcex.cbWndExtra = 0;
//wcex.hInstance = instance;
//wcex.hIcon = NULL;
//wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
//wcex.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
//wcex.lpszMenuName = NULL;
//wcex.lpszClassName = APP_TITLE;
//wcex.hIconSm = NULL;
//if (!RegisterClassEx(&wcex)) {
// WinPopup ("Cannot create window class");
// return false;
//}
//x = IniInt ("WindowX");
//y = IniInt ("WindowY");
//style = WS_TILEDWINDOW;
//style |= WS_MAXIMIZE;
//width = IniInt ("WindowWidth");
//height = IniInt ("WindowHeight");
//width = CLAMP (width, 800, 2048);
//height = CLAMP (height, 600, 2048);
//half_width = width / 2;
//half_height = height / 2;
//max = IniInt ("WindowMaximized") == 1;
//if (!(hwnd = CreateWindowEx (0, APP_TITLE, APP_TITLE, style,
// CW_USEDEFAULT, CW_USEDEFAULT, width, height, NULL, NULL, instance, NULL))) {
// WinPopup ("Cannot create window");
// return false;
//}
//if (max)
// ShowWindow (hwnd, SW_MAXIMIZE);
//else
// ShowWindow (hwnd, SW_SHOW);
//UpdateWindow (hwnd);
//return true;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void AppQuit ()
{
quit = true;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void AppInit (void)
{
RandomInit (time (NULL));
CameraInit ();
RenderInit ();
TextureInit ();
WorldInit ();
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void AppUpdate ()
{
CameraUpdate ();
WorldUpdate ();
TextureUpdate ();
WorldUpdate ();
VisibleUpdate ();
CarUpdate ();
EntityUpdate ();
WorldUpdate ();
RenderUpdate ();
}
/*-----------------------------------------------------------------------------
W i n M a i n
-----------------------------------------------------------------------------*/
void AppTerm (void)
{
TextureTerm ();
WorldTerm ();
RenderTerm ();
CameraTerm ();
WinTerm ();
}
/*-----------------------------------------------------------------------------
W i n M a i n
-----------------------------------------------------------------------------*/
int main() {
WinInit ();
AppInit ();
SDL_Event event;
while (!quit) {
while (SDL_PollEvent(&event)) {
switch(event.type) {
case SDL_QUIT:
quit=true;
break;
default:
break;
}
}
AppUpdate ();
}
AppTerm ();
return 0;
}
| [
"youngshamus@c6164f88-37c5-11de-9d05-31133e6853b1",
"[email protected]"
] | [
[
[
1,
6
],
[
8,
10
],
[
12,
14
],
[
34,
41
],
[
44,
53
],
[
95,
98
],
[
230,
231
],
[
234,
237
],
[
240,
240
],
[
245,
248
],
[
250,
253
],
[
255,
259
],
[
261,
264
],
[
267,
272
],
[
274,
277
],
[
279,
283
],
[
285,
289
],
[
300,
302
],
[
304,
307
],
[
351,
355
],
[
357,
360
],
[
362,
366
],
[
368,
371
],
[
377,
381
],
[
383,
386
],
[
396,
399
],
[
402,
405
],
[
411,
414
],
[
417,
417
],
[
421,
421
],
[
435,
440
]
],
[
[
7,
7
],
[
11,
11
],
[
15,
33
],
[
42,
43
],
[
54,
94
],
[
99,
229
],
[
232,
233
],
[
238,
239
],
[
241,
244
],
[
249,
249
],
[
254,
254
],
[
260,
260
],
[
265,
266
],
[
273,
273
],
[
278,
278
],
[
284,
284
],
[
290,
299
],
[
303,
303
],
[
308,
350
],
[
356,
356
],
[
361,
361
],
[
367,
367
],
[
372,
376
],
[
382,
382
],
[
387,
395
],
[
400,
401
],
[
406,
410
],
[
415,
416
],
[
418,
420
],
[
422,
434
]
]
] |
8ad6165dd244a503149a38b6f27d1c9ae2c7316c | b308f1edaab2be56eb66b7c03b0bf4673621b62f | /Code/CryEngine/CryCommon/LinuxSpecific.h | 845f7dd3bba82175875e4dd13392b4a6baaea1d3 | [] | no_license | blockspacer/project-o | 14e95aa2692930ee90d098980a7595759a8a1f74 | 403ec13c10757d7d948eafe9d0a95a7f59285e90 | refs/heads/master | 2021-05-31T16:46:36.814786 | 2011-09-16T14:34:07 | 2011-09-16T14:34:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,323 | h | ////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2004.
// -------------------------------------------------------------------------
// File name: Linux32Specific.h
// Version: v1.00
// Created: 05/03/2004 by MarcoK.
// Compilers: Visual Studio.NET, GCC 3.2
// Description: Specific to Linux declarations, inline functions etc.
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#ifndef _CRY_COMMON_LINUX_SPECIFIC_HDR_
#define _CRY_COMMON_LINUX_SPECIFIC_HDR_
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#include MATH_H
#include <string.h>
#include <errno.h>
#include </usr/include/ctype.h>
#include <algorithm>
#include <signal.h>
#include <unistd.h>
#ifndef __COUNTER__
#define __COUNTER__ __LINE__
#endif
#ifdef __FUNC__
#undef __FUNC__
#endif
#define __FUNC__ \
({ \
static char __f[sizeof(__PRETTY_FUNCTION__) + 1]; \
strcpy(__f, __PRETTY_FUNCTION__); \
char* __p = (char*)strchr(__f, '('); \
*__p = 0; \
while (*(__p)!=' ' && __p!=(__f-1)) {--__p;} \
(__p + 1); \
})
typedef void* LPVOID;
#define VOID void
#define PVOID void*
typedef unsigned int UINT;
typedef char CHAR;
typedef float FLOAT;
#define PHYSICS_EXPORTS
// MSVC compiler-specific keywords
#define __forceinline inline
#define _inline inline
#define __cdecl
#define _cdecl
#define __stdcall
#define _stdcall
#define __fastcall
#define _fastcall
#define IN
#define OUT
//#if !defined(_LIB)
//# define _LIB 1
//#endif
#ifdef _LIB
#if !defined(USE_STATIC_NAME_TABLE)
#define USE_STATIC_NAME_TABLE 1
#endif
#endif
#if !defined(_STLP_HASH_MAP)
#define _STLP_HASH_MAP 1
#endif
// Enable memory address tracing code.
#if !defined(MM_TRACE_ADDRS) // && !defined(NDEBUG)
#define MM_TRACE_ADDRS 1
#endif
#define _ALIGN(num) __attribute__ ((aligned(num)))
#define _PACK __attribute__ ((packed))
// Safe memory freeing
#ifndef SAFE_DELETE
#define SAFE_DELETE(p) { if(p) { delete (p); (p)=NULL; } }
#endif
#ifndef SAFE_DELETE_ARRAY
#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p); (p)=NULL; } }
#endif
#ifndef SAFE_RELEASE
#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } }
#endif
#ifndef SAFE_RELEASE_FORCE
#define SAFE_RELEASE_FORCE(p) { if(p) { (p)->ReleaseForce(); (p)=NULL; } }
#endif
#define MAKEWORD(a, b) ((WORD)(((BYTE)((DWORD_PTR)(a) & 0xff)) | ((WORD)((BYTE)((DWORD_PTR)(b) & 0xff))) << 8))
#define MAKELONG(a, b) ((LONG)(((WORD)((DWORD_PTR)(a) & 0xffff)) | ((DWORD)((WORD)((DWORD_PTR)(b) & 0xffff))) << 16))
#define LOWORD(l) ((WORD)((DWORD_PTR)(l) & 0xffff))
#define HIWORD(l) ((WORD)((DWORD_PTR)(l) >> 16))
#define LOBYTE(w) ((BYTE)((DWORD_PTR)(w) & 0xff))
#define HIBYTE(w) ((BYTE)((DWORD_PTR)(w) >> 8))
#define CALLBACK
#define WINAPI
#ifndef __cplusplus
#ifndef _WCHAR_T_DEFINED
typedef unsigned short wchar_t;
#define TCHAR wchar_t;
#define _WCHAR_T_DEFINED
#endif
#endif
typedef wchar_t WCHAR; // wc, 16-bit UNICODE character
typedef WCHAR *PWCHAR;
typedef WCHAR *LPWCH, *PWCH;
typedef const WCHAR *LPCWCH, *PCWCH;
typedef WCHAR *NWPSTR;
typedef WCHAR *LPWSTR, *PWSTR;
typedef WCHAR *LPUWSTR, *PUWSTR;
typedef const WCHAR *LPCWSTR, *PCWSTR;
typedef const WCHAR *LPCUWSTR, *PCUWSTR;
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \
((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
#define FILE_ATTRIBUTE_NORMAL 0x00000080
typedef int BOOL;
typedef int LONG;
typedef unsigned int ULONG;
typedef int HRESULT;
typedef int32 __int32;
typedef uint32 __uint32;
typedef int64 __int64;
typedef uint64 __uint64;
#define TRUE 1
#define FALSE 0
#ifndef MAX_PATH
#define MAX_PATH 256
#endif
#ifndef _MAX_PATH
#define _MAX_PATH MAX_PATH
#endif
#define _PTRDIFF_T_DEFINED 1
//-------------------------------------socket stuff------------------------------------------
typedef int SOCKET;
#define INVALID_SOCKET (-1)
#define SOCKET_ERROR (-1)
#define SD_SEND SHUT_WR
#define SD_BOTH SHUT_RDWR
typedef struct in_addr_windows
{
union
{
struct { unsigned char s_b1,s_b2,s_b3,s_b4; } S_un_b;
struct { unsigned short s_w1,s_w2; } S_un_w;
unsigned int S_addr;
} S_un;
}in_addr_windows;
#define WSAEINTR EINTR
#define WSAEBADF EBADF
#define WSAEACCES EACCES
#define WSAEFAULT EFAULT
#define WSAEACCES EACCES
#define WSAEFAULT EFAULT
#define WSAEINVAL EINVAL
#define WSAEMFILE EMFILE
#define WSAEWOULDBLOCK EAGAIN
#define WSAEINPROGRESS EINPROGRESS
#define WSAEALREADY EALREADY
#define WSAENOTSOCK ENOTSOCK
#define WSAEDESTADDRREQ EDESTADDRREQ
#define WSAEMSGSIZE EMSGSIZE
#define WSAEPROTOTYPE EPROTOTYPE
#define WSAENOPROTOOPT ENOPROTOOPT
#define WSAEPROTONOSUPPORT EPROTONOSUPPORT
#define WSAESOCKTNOSUPPORT ESOCKTNOSUPPORT
#define WSAEOPNOTSUPP EOPNOTSUPP
#define WSAEPFNOSUPPORT EPFNOSUPPORT
#define WSAEAFNOSUPPORT EAFNOSUPPORT
#define WSAEADDRINUSE EADDRINUSE
#define WSAEADDRNOTAVAIL EADDRNOTAVAIL
#define WSAENETDOWN ENETDOWN
#define WSAENETUNREACH ENETUNREACH
#define WSAENETRESET ENETRESET
#define WSAECONNABORTED ECONNABORTED
#define WSAECONNRESET ECONNRESET
#define WSAENOBUFS ENOBUFS
#define WSAEISCONN EISCONN
#define WSAENOTCONN ENOTCONN
#define WSAESHUTDOWN ESHUTDOWN
#define WSAETOOMANYREFS ETOOMANYREFS
#define WSAETIMEDOUT ETIMEDOUT
#define WSAECONNREFUSED ECONNREFUSED
#define WSAELOOP ELOOP
#define WSAENAMETOOLONG ENAMETOOLONG
#define WSAEHOSTDOWN EHOSTDOWN
#define WSAEHOSTUNREACH EHOSTUNREACH
#define WSAENOTEMPTY ENOTEMPTY
#define WSAEPROCLIM EPROCLIM
#define WSAEUSERS EUSERS
#define WSAEDQUOT EDQUOT
#define WSAESTALE ESTALE
#define WSAEREMOTE EREMOTE
#define WSAHOST_NOT_FOUND (1024 + 1)
#define WSATRY_AGAIN (1024 + 2)
#define WSANO_RECOVERY (1024 + 3)
#define WSANO_DATA (1024 + 4)
#define WSANO_ADDRESS (WSANO_DATA)
//-------------------------------------end socket stuff------------------------------------------
//#define __TIMESTAMP__ __DATE__" "__TIME__
// function renaming
#define _finite __finite
#define _snprintf snprintf
#define _isnan isnan
#define stricmp strcasecmp
#define _stricmp strcasecmp
#define strnicmp strncasecmp
#define _strnicmp strncasecmp
#define wcsicmp wcscasecmp
#define wcsnicmp wcsncasecmp
#define _vsnprintf vsnprintf
#define _wtof( str ) wcstod( str, 0 )
/*static unsigned char toupper(unsigned char c)
{
return c & ~0x40;
}
*/
typedef union _LARGE_INTEGER
{
struct
{
DWORD LowPart;
LONG HighPart;
};
struct
{
DWORD LowPart;
LONG HighPart;
} u;
long long QuadPart;
} LARGE_INTEGER;
// stdlib.h stuff
#define _MAX_DRIVE 3 // max. length of drive component
#define _MAX_DIR 256 // max. length of path component
#define _MAX_FNAME 256 // max. length of file name component
#define _MAX_EXT 256 // max. length of extension component
// fcntl.h
#define _O_RDONLY 0x0000 /* open for reading only */
#define _O_WRONLY 0x0001 /* open for writing only */
#define _O_RDWR 0x0002 /* open for reading and writing */
#define _O_APPEND 0x0008 /* writes done at eof */
#define _O_CREAT 0x0100 /* create and open file */
#define _O_TRUNC 0x0200 /* open and truncate */
#define _O_EXCL 0x0400 /* open only if file doesn't already exist */
#define _O_TEXT 0x4000 /* file mode is text (translated) */
#define _O_BINARY 0x8000 /* file mode is binary (untranslated) */
#define _O_RAW _O_BINARY
#define _O_NOINHERIT 0x0080 /* child process doesn't inherit file */
#define _O_TEMPORARY 0x0040 /* temporary file bit */
#define _O_SHORT_LIVED 0x1000 /* temporary storage file, try not to flush */
#define _O_SEQUENTIAL 0x0020 /* file access is primarily sequential */
#define _O_RANDOM 0x0010 /* file access is primarily random */
// curses.h stubs for PDcurses keys
#define PADENTER KEY_MAX + 1
#define CTL_HOME KEY_MAX + 2
#define CTL_END KEY_MAX + 3
#define CTL_PGDN KEY_MAX + 4
#define CTL_PGUP KEY_MAX + 5
// stubs for virtual keys, isn't used on Linux
#define VK_UP 0
#define VK_DOWN 0
#define VK_RIGHT 0
#define VK_LEFT 0
#define VK_CONTROL 0
#define VK_SCROLL 0
// io.h stuff
typedef unsigned int _fsize_t;
struct _OVERLAPPED;
typedef void (*LPOVERLAPPED_COMPLETION_ROUTINE)(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, struct _OVERLAPPED *lpOverlapped);
typedef struct _OVERLAPPED
{
void* pCaller;//this is orginally reserved for internal purpose, we store the Caller pointer here
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine; ////this is orginally ULONG_PTR InternalHigh and reserved for internal purpose
union {
struct {
DWORD Offset;
DWORD OffsetHigh;
};
PVOID Pointer;
};
DWORD dwNumberOfBytesTransfered; //additional member temporary speciying the number of bytes to be read
/*HANDLE*/void* hEvent;
} OVERLAPPED, *LPOVERLAPPED;
typedef struct _SECURITY_ATTRIBUTES
{
DWORD nLength;
LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
#ifdef __cplusplus
extern bool QueryPerformanceCounter(LARGE_INTEGER *);
static pthread_mutex_t mutex_t;
template<typename T>
const volatile T InterlockedIncrement(volatile T* pT)
{
pthread_mutex_lock(&mutex_t);
++(*pT);
pthread_mutex_unlock(&mutex_t);
return *pT;
}
template<typename T>
const volatile T InterlockedDecrement(volatile T* pT)
{
pthread_mutex_lock(&mutex_t);
--(*pT);
pthread_mutex_unlock(&mutex_t);
return *pT;
}
template<typename S, typename T>
inline S __min(const S& rS, const T& rT)
{
return min(rS, rT);
}
template<typename S, typename T>
inline S __max(const S& rS, const T& rT)
{
return max(rS, rT);
}
typedef enum {INVALID_HANDLE_VALUE = -1l}INVALID_HANDLE_VALUE_ENUM;
//for compatibility reason we got to create a class which actually contains an int rather than a void* and make sure it does not get mistreated
template <class T, T U>//U is default type for invalid handle value, T the encapsulated handle type to be used instead of void* (as under windows and never linux)
class CHandle
{
public:
typedef T HandleType;
typedef void* PointerType; //for compatibility reason to encapsulate a void* as an int
static const HandleType sciInvalidHandleValue = U;
CHandle(const CHandle<T,U>& cHandle) : m_Value(cHandle.m_Value){}
CHandle(const HandleType cHandle = U) : m_Value(cHandle){}
CHandle(const PointerType cpHandle) : m_Value(reinterpret_cast<HandleType>(cpHandle)){}
CHandle(INVALID_HANDLE_VALUE_ENUM) : m_Value(U){}//to be able to use a common value for all InvalidHandle - types
#if defined(LINUX64)
//treat __null tyope also as invalid handle type
CHandle(typeof(__null)) : m_Value(U){}//to be able to use a common value for all InvalidHandle - types
#endif
operator HandleType(){return m_Value;}
bool operator!() const{return m_Value == sciInvalidHandleValue;}
const CHandle& operator =(const CHandle& crHandle){m_Value = crHandle.m_Value;return *this;}
const CHandle& operator =(const PointerType cpHandle){m_Value = reinterpret_cast<HandleType>(cpHandle);return *this;}
const bool operator ==(const CHandle& crHandle) const{return m_Value == crHandle.m_Value;}
const bool operator ==(const HandleType cHandle) const{return m_Value == cHandle;}
const bool operator ==(const PointerType cpHandle)const{return m_Value == reinterpret_cast<HandleType>(cpHandle);}
const bool operator !=(const HandleType cHandle) const{return m_Value != cHandle;}
const bool operator !=(const CHandle& crHandle) const{return m_Value != crHandle.m_Value;}
const bool operator !=(const PointerType cpHandle)const{return m_Value != reinterpret_cast<HandleType>(cpHandle);}
const bool operator < (const CHandle& crHandle) const{return m_Value < crHandle.m_Value;}
HandleType Handle()const{return m_Value;}
private:
HandleType m_Value; //the actual value, remember that file descriptors are ints under linux
typedef void ReferenceType;//for compatibility reason to encapsulate a void* as an int
//forbid these function which would actually not work on an int
PointerType operator->();
PointerType operator->() const;
ReferenceType operator*();
ReferenceType operator*() const;
operator PointerType();
};
typedef CHandle<int, (int)-1l> HANDLE;
typedef HANDLE EVENT_HANDLE;
typedef HANDLE THREAD_HANDLE;
inline int64 CryGetTicks()
{
LARGE_INTEGER counter;
QueryPerformanceCounter(&counter);
return counter.QuadPart;
}
#endif //__cplusplus
inline int _CrtCheckMemory() { return 1; };
inline char *_fullpath(char *absPath, const char *relPath, size_t maxLength)
{
char path[PATH_MAX];
if (realpath(relPath, path) == NULL)
return NULL;
strncpy(absPath, path, maxLength - 1);
absPath[maxLength - 1] = 0;
return absPath;
}
#ifdef _RELEASE
#define __debugbreak()
#else
#define __debugbreak() raise(SIGTRAP)
#endif
#define __assume(x)
#define _flushall sync
// moved from CryNetwork/StdAfx.h
inline int closesocket(int s) { return ::close(s); }
inline int WSAGetLastError() { return errno; }
typedef void *HGLRC;
typedef void *HDC;
typedef void *PROC;
typedef void *PIXELFORMATDESCRIPTOR;
#define SCOPED_ENABLE_FLOAT_EXCEPTIONS
// Linux_Win32Wrapper.h now included directly by platform.h
//#include "Linux_Win32Wrapper.h"
#define FP16_MESH
#endif //_CRY_COMMON_LINUX_SPECIFIC_HDR_
// vim:ts=2:sw=2:tw=78
| [
"[email protected]"
] | [
[
[
1,
494
]
]
] |
7528df2ce263b7c93bacc59a6993e954cc73106a | df96cbce59e3597f2aecc99ae123311abe7fce94 | /dom/generated_dom/html_js.cpp | 8c5b41d977bd50e1b30fc7c7c4fa60bd843b55d3 | [] | no_license | abhishekbhalani/webapptools | f08b9f62437c81e0682497923d444020d7b319a2 | 93b6034e0a9e314716e072eb6d3379d92014f25a | refs/heads/master | 2021-01-22T17:58:00.860044 | 2011-12-14T10:54:11 | 2011-12-14T10:54:11 | 40,562,019 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,163,383 | cpp |
/*
DO NOT EDIT!
This file has been generated by generate_sources.py script.
$Id$
*/
#include "precomp.h"
using namespace v8;
Handle<Value> js_dom_DOMException::static_get_code(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_DOMException, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_DOMException, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
short unsigned int value = dynamic_cast<js_dom_DOMException*>(ptr)->code;
return v8_wrapper::Set(value);
}
void js_dom_DOMException::static_set_code(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_DOMException, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_DOMException, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_dom_DOMException*>(ptr)->code = v8_wrapper::Get< short unsigned int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_DOMException >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::DOMException"));
instance->SetAccessor(v8::String::New("code"), js_dom_DOMException::static_get_code, js_dom_DOMException::static_set_code);
v8_wrapper::Registrator< js_dom_DOMException >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_dom_DOMImplementation::static_hasFeature(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_feature = v8_wrapper::Get< std::string > ( args[0] );
std::string val_version = v8_wrapper::Get< std::string > ( args[1] );
js_dom_DOMImplementation * el = dynamic_cast<js_dom_DOMImplementation *>(ptr);
retval = v8_wrapper::Set( el->hasFeature(val_feature, val_version) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_DOMImplementation::static_createDocumentType(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_qualifiedName = v8_wrapper::Get< std::string > ( args[0] );
std::string val_publicId = v8_wrapper::Get< std::string > ( args[1] );
std::string val_systemId = v8_wrapper::Get< std::string > ( args[2] );
js_dom_DOMImplementation * el = dynamic_cast<js_dom_DOMImplementation *>(ptr);
retval = v8_wrapper::Set( el->createDocumentType(val_qualifiedName, val_publicId, val_systemId) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_DOMImplementation::static_createDocument(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_qualifiedName = v8_wrapper::Get< std::string > ( args[1] );
v8::Handle<v8::Value> val_doctype = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[2] );
js_dom_DOMImplementation * el = dynamic_cast<js_dom_DOMImplementation *>(ptr);
retval = v8_wrapper::Set( el->createDocument(val_namespaceURI, val_qualifiedName, val_doctype) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_DOMImplementation >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::DOMImplementation"));
proto->Set(v8::String::New("hasFeature"), v8::FunctionTemplate::New(js_dom_DOMImplementation::static_hasFeature));
proto->Set(v8::String::New("createDocumentType"), v8::FunctionTemplate::New(js_dom_DOMImplementation::static_createDocumentType));
proto->Set(v8::String::New("createDocument"), v8::FunctionTemplate::New(js_dom_DOMImplementation::static_createDocument));
v8_wrapper::Registrator< js_dom_DOMImplementation >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_dom_Node::static_insertBefore(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_newChild = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
v8::Handle<v8::Value> val_refChild = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[1] );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->insertBefore(val_newChild, val_refChild) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_replaceChild(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_newChild = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
v8::Handle<v8::Value> val_oldChild = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[1] );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->replaceChild(val_newChild, val_oldChild) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_removeChild(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_oldChild = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->removeChild(val_oldChild) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_appendChild(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_newChild = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->appendChild(val_newChild) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_hasChildNodes(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->hasChildNodes() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_cloneNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
bool val_deep = v8_wrapper::Get< bool > ( args[0] );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->cloneNode(val_deep) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_normalize(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
el->normalize();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_isSupported(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_feature = v8_wrapper::Get< std::string > ( args[0] );
std::string val_version = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->isSupported(val_feature, val_version) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_hasAttributes(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->hasAttributes() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Node::static_compareDocumentPosition(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_other = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_dom_Node * el = dynamic_cast<js_dom_Node *>(ptr);
retval = v8_wrapper::Set( el->compareDocumentPosition(val_other) );
return scope.Close(retval);
}
Handle<Value> js_dom_Node::static_get_nodeName(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Node*>(ptr)->nodeName;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_nodeName(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_nodeValue(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
std::string value = dynamic_cast<js_dom_Node*>(ptr)->nodeValue;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_nodeValue(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 2>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_dom_Node*>(ptr)->nodeValue = v8_wrapper::Get< std::string >(value);
}
Handle<Value> js_dom_Node::static_get_nodeType(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const short unsigned int value = dynamic_cast<js_dom_Node*>(ptr)->nodeType;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_nodeType(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 3>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_parentNode(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Node*>(ptr)->parentNode;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_parentNode(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 4>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_childNodes(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Node*>(ptr)->childNodes;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_childNodes(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 5>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 5>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_firstChild(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Node*>(ptr)->firstChild;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_firstChild(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 6>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 6>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_lastChild(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Node*>(ptr)->lastChild;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_lastChild(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 7>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 7>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_previousSibling(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Node*>(ptr)->previousSibling;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_previousSibling(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 8>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 8>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_nextSibling(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Node*>(ptr)->nextSibling;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_nextSibling(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 9>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 9>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_attributes(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Node*>(ptr)->attributes;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_attributes(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 10>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 10>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_ownerDocument(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Node*>(ptr)->ownerDocument;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_ownerDocument(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 11>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 11>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_namespaceURI(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Node*>(ptr)->namespaceURI;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_namespaceURI(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 12>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 12>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Node::static_get_prefix(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 13>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 13>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
std::string value = dynamic_cast<js_dom_Node*>(ptr)->prefix;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_prefix(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 13>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 13>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_dom_Node*>(ptr)->prefix = v8_wrapper::Get< std::string >(value);
}
Handle<Value> js_dom_Node::static_get_localName(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 14>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Node, 14>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Node*>(ptr)->localName;
return v8_wrapper::Set(value);
}
void js_dom_Node::static_set_localName(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Node, 14>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Node, 14>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_Node >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::Node"));
proto->Set(v8::String::New("insertBefore"), v8::FunctionTemplate::New(js_dom_Node::static_insertBefore));
proto->Set(v8::String::New("replaceChild"), v8::FunctionTemplate::New(js_dom_Node::static_replaceChild));
proto->Set(v8::String::New("removeChild"), v8::FunctionTemplate::New(js_dom_Node::static_removeChild));
proto->Set(v8::String::New("appendChild"), v8::FunctionTemplate::New(js_dom_Node::static_appendChild));
proto->Set(v8::String::New("hasChildNodes"), v8::FunctionTemplate::New(js_dom_Node::static_hasChildNodes));
proto->Set(v8::String::New("cloneNode"), v8::FunctionTemplate::New(js_dom_Node::static_cloneNode));
proto->Set(v8::String::New("normalize"), v8::FunctionTemplate::New(js_dom_Node::static_normalize));
proto->Set(v8::String::New("isSupported"), v8::FunctionTemplate::New(js_dom_Node::static_isSupported));
proto->Set(v8::String::New("hasAttributes"), v8::FunctionTemplate::New(js_dom_Node::static_hasAttributes));
proto->Set(v8::String::New("compareDocumentPosition"), v8::FunctionTemplate::New(js_dom_Node::static_compareDocumentPosition));
instance->SetAccessor(v8::String::New("nodeName"), js_dom_Node::static_get_nodeName, js_dom_Node::static_set_nodeName);
instance->SetAccessor(v8::String::New("nodeValue"), js_dom_Node::static_get_nodeValue, js_dom_Node::static_set_nodeValue);
instance->SetAccessor(v8::String::New("nodeType"), js_dom_Node::static_get_nodeType, js_dom_Node::static_set_nodeType);
instance->SetAccessor(v8::String::New("parentNode"), js_dom_Node::static_get_parentNode, js_dom_Node::static_set_parentNode);
instance->SetAccessor(v8::String::New("childNodes"), js_dom_Node::static_get_childNodes, js_dom_Node::static_set_childNodes);
instance->SetAccessor(v8::String::New("firstChild"), js_dom_Node::static_get_firstChild, js_dom_Node::static_set_firstChild);
instance->SetAccessor(v8::String::New("lastChild"), js_dom_Node::static_get_lastChild, js_dom_Node::static_set_lastChild);
instance->SetAccessor(v8::String::New("previousSibling"), js_dom_Node::static_get_previousSibling, js_dom_Node::static_set_previousSibling);
instance->SetAccessor(v8::String::New("nextSibling"), js_dom_Node::static_get_nextSibling, js_dom_Node::static_set_nextSibling);
instance->SetAccessor(v8::String::New("attributes"), js_dom_Node::static_get_attributes, js_dom_Node::static_set_attributes);
instance->SetAccessor(v8::String::New("ownerDocument"), js_dom_Node::static_get_ownerDocument, js_dom_Node::static_set_ownerDocument);
instance->SetAccessor(v8::String::New("namespaceURI"), js_dom_Node::static_get_namespaceURI, js_dom_Node::static_set_namespaceURI);
instance->SetAccessor(v8::String::New("prefix"), js_dom_Node::static_get_prefix, js_dom_Node::static_set_prefix);
instance->SetAccessor(v8::String::New("localName"), js_dom_Node::static_get_localName, js_dom_Node::static_set_localName);
v8_wrapper::Registrator< js_dom_Node >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_dom_NodeList::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_dom_NodeList * el = dynamic_cast<js_dom_NodeList *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
Handle<Value> js_dom_NodeList::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_NodeList, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_NodeList, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_dom_NodeList*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_dom_NodeList::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_NodeList, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_NodeList, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_NodeList >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::NodeList"));
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_dom_NodeList::static_item));
instance->SetAccessor(v8::String::New("length"), js_dom_NodeList::static_get_length, js_dom_NodeList::static_set_length);
v8_wrapper::Registrator< js_dom_NodeList >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_dom_NamedNodeMap::static_getNamedItem(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_NamedNodeMap * el = dynamic_cast<js_dom_NamedNodeMap *>(ptr);
retval = v8_wrapper::Set( el->getNamedItem(val_name) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_NamedNodeMap::static_setNamedItem(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_arg = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_dom_NamedNodeMap * el = dynamic_cast<js_dom_NamedNodeMap *>(ptr);
retval = v8_wrapper::Set( el->setNamedItem(val_arg) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_NamedNodeMap::static_removeNamedItem(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_NamedNodeMap * el = dynamic_cast<js_dom_NamedNodeMap *>(ptr);
retval = v8_wrapper::Set( el->removeNamedItem(val_name) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_NamedNodeMap::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_dom_NamedNodeMap * el = dynamic_cast<js_dom_NamedNodeMap *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_NamedNodeMap::static_getNamedItemNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_localName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_NamedNodeMap * el = dynamic_cast<js_dom_NamedNodeMap *>(ptr);
retval = v8_wrapper::Set( el->getNamedItemNS(val_namespaceURI, val_localName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_NamedNodeMap::static_setNamedItemNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_arg = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_dom_NamedNodeMap * el = dynamic_cast<js_dom_NamedNodeMap *>(ptr);
retval = v8_wrapper::Set( el->setNamedItemNS(val_arg) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_NamedNodeMap::static_removeNamedItemNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_localName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_NamedNodeMap * el = dynamic_cast<js_dom_NamedNodeMap *>(ptr);
retval = v8_wrapper::Set( el->removeNamedItemNS(val_namespaceURI, val_localName) );
return scope.Close(retval);
}
Handle<Value> js_dom_NamedNodeMap::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_NamedNodeMap, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_NamedNodeMap, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_dom_NamedNodeMap*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_dom_NamedNodeMap::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_NamedNodeMap, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_NamedNodeMap, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_NamedNodeMap >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::NamedNodeMap"));
proto->Set(v8::String::New("getNamedItem"), v8::FunctionTemplate::New(js_dom_NamedNodeMap::static_getNamedItem));
proto->Set(v8::String::New("setNamedItem"), v8::FunctionTemplate::New(js_dom_NamedNodeMap::static_setNamedItem));
proto->Set(v8::String::New("removeNamedItem"), v8::FunctionTemplate::New(js_dom_NamedNodeMap::static_removeNamedItem));
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_dom_NamedNodeMap::static_item));
proto->Set(v8::String::New("getNamedItemNS"), v8::FunctionTemplate::New(js_dom_NamedNodeMap::static_getNamedItemNS));
proto->Set(v8::String::New("setNamedItemNS"), v8::FunctionTemplate::New(js_dom_NamedNodeMap::static_setNamedItemNS));
proto->Set(v8::String::New("removeNamedItemNS"), v8::FunctionTemplate::New(js_dom_NamedNodeMap::static_removeNamedItemNS));
instance->SetAccessor(v8::String::New("length"), js_dom_NamedNodeMap::static_get_length, js_dom_NamedNodeMap::static_set_length);
v8_wrapper::Registrator< js_dom_NamedNodeMap >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_dom_CharacterData::static_substringData(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_offset = v8_wrapper::Get< long unsigned int > ( args[0] );
long unsigned int val_count = v8_wrapper::Get< long unsigned int > ( args[1] );
js_dom_CharacterData * el = dynamic_cast<js_dom_CharacterData *>(ptr);
retval = v8_wrapper::Set( el->substringData(val_offset, val_count) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_CharacterData::static_appendData(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_arg = v8_wrapper::Get< std::string > ( args[0] );
js_dom_CharacterData * el = dynamic_cast<js_dom_CharacterData *>(ptr);
el->appendData(val_arg);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_CharacterData::static_insertData(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_offset = v8_wrapper::Get< long unsigned int > ( args[0] );
std::string val_arg = v8_wrapper::Get< std::string > ( args[1] );
js_dom_CharacterData * el = dynamic_cast<js_dom_CharacterData *>(ptr);
el->insertData(val_offset, val_arg);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_CharacterData::static_deleteData(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_offset = v8_wrapper::Get< long unsigned int > ( args[0] );
long unsigned int val_count = v8_wrapper::Get< long unsigned int > ( args[1] );
js_dom_CharacterData * el = dynamic_cast<js_dom_CharacterData *>(ptr);
el->deleteData(val_offset, val_count);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_CharacterData::static_replaceData(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_offset = v8_wrapper::Get< long unsigned int > ( args[0] );
long unsigned int val_count = v8_wrapper::Get< long unsigned int > ( args[1] );
std::string val_arg = v8_wrapper::Get< std::string > ( args[2] );
js_dom_CharacterData * el = dynamic_cast<js_dom_CharacterData *>(ptr);
el->replaceData(val_offset, val_count, val_arg);
return scope.Close(retval);
}
Handle<Value> js_dom_CharacterData::static_get_data(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_CharacterData, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_CharacterData, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
std::string value = dynamic_cast<js_dom_CharacterData*>(ptr)->data;
return v8_wrapper::Set(value);
}
void js_dom_CharacterData::static_set_data(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_CharacterData, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_CharacterData, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_dom_CharacterData*>(ptr)->data = v8_wrapper::Get< std::string >(value);
}
Handle<Value> js_dom_CharacterData::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_CharacterData, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_CharacterData, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_dom_CharacterData*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_dom_CharacterData::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_CharacterData, 2>::implemented) {
v8_wrapper::CustomAttribute<js_dom_CharacterData, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_CharacterData >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::CharacterData"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
proto->Set(v8::String::New("substringData"), v8::FunctionTemplate::New(js_dom_CharacterData::static_substringData));
proto->Set(v8::String::New("appendData"), v8::FunctionTemplate::New(js_dom_CharacterData::static_appendData));
proto->Set(v8::String::New("insertData"), v8::FunctionTemplate::New(js_dom_CharacterData::static_insertData));
proto->Set(v8::String::New("deleteData"), v8::FunctionTemplate::New(js_dom_CharacterData::static_deleteData));
proto->Set(v8::String::New("replaceData"), v8::FunctionTemplate::New(js_dom_CharacterData::static_replaceData));
instance->SetAccessor(v8::String::New("data"), js_dom_CharacterData::static_get_data, js_dom_CharacterData::static_set_data);
instance->SetAccessor(v8::String::New("length"), js_dom_CharacterData::static_get_length, js_dom_CharacterData::static_set_length);
v8_wrapper::Registrator< js_dom_CharacterData >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_dom_Attr::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Attr, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Attr, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Attr*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_dom_Attr::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Attr, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Attr, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Attr::static_get_specified(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Attr, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Attr, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_dom_Attr*>(ptr)->specified;
return v8_wrapper::Set(value);
}
void js_dom_Attr::static_set_specified(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Attr, 2>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Attr, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Attr::static_get_value(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Attr, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Attr, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
std::string value = dynamic_cast<js_dom_Attr*>(ptr)->value;
return v8_wrapper::Set(value);
}
void js_dom_Attr::static_set_value(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Attr, 3>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Attr, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_dom_Attr*>(ptr)->value = v8_wrapper::Get< std::string >(value);
}
Handle<Value> js_dom_Attr::static_get_ownerElement(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Attr, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Attr, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Attr*>(ptr)->ownerElement;
return v8_wrapper::Set(value);
}
void js_dom_Attr::static_set_ownerElement(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Attr, 4>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Attr, 4>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_Attr >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::Attr"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
instance->SetAccessor(v8::String::New("name"), js_dom_Attr::static_get_name, js_dom_Attr::static_set_name);
instance->SetAccessor(v8::String::New("specified"), js_dom_Attr::static_get_specified, js_dom_Attr::static_set_specified);
instance->SetAccessor(v8::String::New("value"), js_dom_Attr::static_get_value, js_dom_Attr::static_set_value);
instance->SetAccessor(v8::String::New("ownerElement"), js_dom_Attr::static_get_ownerElement, js_dom_Attr::static_set_ownerElement);
v8_wrapper::Registrator< js_dom_Attr >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_dom_Element::static_getAttribute(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->getAttribute(val_name) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_setAttribute(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
std::string val_value = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
el->setAttribute(val_name, val_value);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_removeAttribute(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
el->removeAttribute(val_name);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_getAttributeNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->getAttributeNode(val_name) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_setAttributeNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_newAttr = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->setAttributeNode(val_newAttr) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_removeAttributeNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_oldAttr = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->removeAttributeNode(val_oldAttr) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_getElementsByTagName(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->getElementsByTagName(val_name) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_getAttributeNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_localName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->getAttributeNS(val_namespaceURI, val_localName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_setAttributeNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_qualifiedName = v8_wrapper::Get< std::string > ( args[1] );
std::string val_value = v8_wrapper::Get< std::string > ( args[2] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
el->setAttributeNS(val_namespaceURI, val_qualifiedName, val_value);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_removeAttributeNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_localName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
el->removeAttributeNS(val_namespaceURI, val_localName);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_getAttributeNodeNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_localName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->getAttributeNodeNS(val_namespaceURI, val_localName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_setAttributeNodeNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_newAttr = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->setAttributeNodeNS(val_newAttr) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_getElementsByTagNameNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_localName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->getElementsByTagNameNS(val_namespaceURI, val_localName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_hasAttribute(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->hasAttribute(val_name) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Element::static_hasAttributeNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_localName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Element * el = dynamic_cast<js_dom_Element *>(ptr);
retval = v8_wrapper::Set( el->hasAttributeNS(val_namespaceURI, val_localName) );
return scope.Close(retval);
}
Handle<Value> js_dom_Element::static_get_tagName(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Element, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Element, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Element*>(ptr)->tagName;
return v8_wrapper::Set(value);
}
void js_dom_Element::static_set_tagName(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Element, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Element, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_Element >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::Element"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
proto->Set(v8::String::New("getAttribute"), v8::FunctionTemplate::New(js_dom_Element::static_getAttribute));
proto->Set(v8::String::New("setAttribute"), v8::FunctionTemplate::New(js_dom_Element::static_setAttribute));
proto->Set(v8::String::New("removeAttribute"), v8::FunctionTemplate::New(js_dom_Element::static_removeAttribute));
proto->Set(v8::String::New("getAttributeNode"), v8::FunctionTemplate::New(js_dom_Element::static_getAttributeNode));
proto->Set(v8::String::New("setAttributeNode"), v8::FunctionTemplate::New(js_dom_Element::static_setAttributeNode));
proto->Set(v8::String::New("removeAttributeNode"), v8::FunctionTemplate::New(js_dom_Element::static_removeAttributeNode));
proto->Set(v8::String::New("getElementsByTagName"), v8::FunctionTemplate::New(js_dom_Element::static_getElementsByTagName));
proto->Set(v8::String::New("getAttributeNS"), v8::FunctionTemplate::New(js_dom_Element::static_getAttributeNS));
proto->Set(v8::String::New("setAttributeNS"), v8::FunctionTemplate::New(js_dom_Element::static_setAttributeNS));
proto->Set(v8::String::New("removeAttributeNS"), v8::FunctionTemplate::New(js_dom_Element::static_removeAttributeNS));
proto->Set(v8::String::New("getAttributeNodeNS"), v8::FunctionTemplate::New(js_dom_Element::static_getAttributeNodeNS));
proto->Set(v8::String::New("setAttributeNodeNS"), v8::FunctionTemplate::New(js_dom_Element::static_setAttributeNodeNS));
proto->Set(v8::String::New("getElementsByTagNameNS"), v8::FunctionTemplate::New(js_dom_Element::static_getElementsByTagNameNS));
proto->Set(v8::String::New("hasAttribute"), v8::FunctionTemplate::New(js_dom_Element::static_hasAttribute));
proto->Set(v8::String::New("hasAttributeNS"), v8::FunctionTemplate::New(js_dom_Element::static_hasAttributeNS));
instance->SetAccessor(v8::String::New("tagName"), js_dom_Element::static_get_tagName, js_dom_Element::static_set_tagName);
v8_wrapper::Registrator< js_dom_Element >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_dom_Text::static_splitText(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_offset = v8_wrapper::Get< long unsigned int > ( args[0] );
js_dom_Text * el = dynamic_cast<js_dom_Text *>(ptr);
retval = v8_wrapper::Set( el->splitText(val_offset) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_Text >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::Text"));
result->Inherit(v8_wrapper::Registrator< js_dom_CharacterData >::GetTemplate());
proto->Set(v8::String::New("splitText"), v8::FunctionTemplate::New(js_dom_Text::static_splitText));
v8_wrapper::Registrator< js_dom_Text >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_Comment >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::Comment"));
result->Inherit(v8_wrapper::Registrator< js_dom_CharacterData >::GetTemplate());
v8_wrapper::Registrator< js_dom_Comment >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_CDATASection >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::CDATASection"));
result->Inherit(v8_wrapper::Registrator< js_dom_Text >::GetTemplate());
v8_wrapper::Registrator< js_dom_CDATASection >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_dom_DocumentType::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_DocumentType, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_DocumentType*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_dom_DocumentType::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_DocumentType, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_DocumentType::static_get_entities(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_DocumentType, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_DocumentType*>(ptr)->entities;
return v8_wrapper::Set(value);
}
void js_dom_DocumentType::static_set_entities(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 2>::implemented) {
v8_wrapper::CustomAttribute<js_dom_DocumentType, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_DocumentType::static_get_notations(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_DocumentType, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_DocumentType*>(ptr)->notations;
return v8_wrapper::Set(value);
}
void js_dom_DocumentType::static_set_notations(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 3>::implemented) {
v8_wrapper::CustomAttribute<js_dom_DocumentType, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_DocumentType::static_get_publicId(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_DocumentType, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_DocumentType*>(ptr)->publicId;
return v8_wrapper::Set(value);
}
void js_dom_DocumentType::static_set_publicId(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 4>::implemented) {
v8_wrapper::CustomAttribute<js_dom_DocumentType, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_DocumentType::static_get_systemId(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_DocumentType, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_DocumentType*>(ptr)->systemId;
return v8_wrapper::Set(value);
}
void js_dom_DocumentType::static_set_systemId(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 5>::implemented) {
v8_wrapper::CustomAttribute<js_dom_DocumentType, 5>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_DocumentType::static_get_internalSubset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_DocumentType, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_DocumentType*>(ptr)->internalSubset;
return v8_wrapper::Set(value);
}
void js_dom_DocumentType::static_set_internalSubset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_DocumentType, 6>::implemented) {
v8_wrapper::CustomAttribute<js_dom_DocumentType, 6>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_DocumentType >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::DocumentType"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
instance->SetAccessor(v8::String::New("name"), js_dom_DocumentType::static_get_name, js_dom_DocumentType::static_set_name);
instance->SetAccessor(v8::String::New("entities"), js_dom_DocumentType::static_get_entities, js_dom_DocumentType::static_set_entities);
instance->SetAccessor(v8::String::New("notations"), js_dom_DocumentType::static_get_notations, js_dom_DocumentType::static_set_notations);
instance->SetAccessor(v8::String::New("publicId"), js_dom_DocumentType::static_get_publicId, js_dom_DocumentType::static_set_publicId);
instance->SetAccessor(v8::String::New("systemId"), js_dom_DocumentType::static_get_systemId, js_dom_DocumentType::static_set_systemId);
instance->SetAccessor(v8::String::New("internalSubset"), js_dom_DocumentType::static_get_internalSubset, js_dom_DocumentType::static_set_internalSubset);
v8_wrapper::Registrator< js_dom_DocumentType >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_dom_Notation::static_get_publicId(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Notation, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Notation, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Notation*>(ptr)->publicId;
return v8_wrapper::Set(value);
}
void js_dom_Notation::static_set_publicId(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Notation, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Notation, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Notation::static_get_systemId(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Notation, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Notation, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Notation*>(ptr)->systemId;
return v8_wrapper::Set(value);
}
void js_dom_Notation::static_set_systemId(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Notation, 2>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Notation, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_Notation >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::Notation"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
instance->SetAccessor(v8::String::New("publicId"), js_dom_Notation::static_get_publicId, js_dom_Notation::static_set_publicId);
instance->SetAccessor(v8::String::New("systemId"), js_dom_Notation::static_get_systemId, js_dom_Notation::static_set_systemId);
v8_wrapper::Registrator< js_dom_Notation >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_dom_Entity::static_get_publicId(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Entity, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Entity, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Entity*>(ptr)->publicId;
return v8_wrapper::Set(value);
}
void js_dom_Entity::static_set_publicId(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Entity, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Entity, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Entity::static_get_systemId(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Entity, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Entity, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Entity*>(ptr)->systemId;
return v8_wrapper::Set(value);
}
void js_dom_Entity::static_set_systemId(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Entity, 2>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Entity, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Entity::static_get_notationName(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Entity, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Entity, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_Entity*>(ptr)->notationName;
return v8_wrapper::Set(value);
}
void js_dom_Entity::static_set_notationName(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Entity, 3>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Entity, 3>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_Entity >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::Entity"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
instance->SetAccessor(v8::String::New("publicId"), js_dom_Entity::static_get_publicId, js_dom_Entity::static_set_publicId);
instance->SetAccessor(v8::String::New("systemId"), js_dom_Entity::static_get_systemId, js_dom_Entity::static_set_systemId);
instance->SetAccessor(v8::String::New("notationName"), js_dom_Entity::static_get_notationName, js_dom_Entity::static_set_notationName);
v8_wrapper::Registrator< js_dom_Entity >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_EntityReference >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::EntityReference"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
v8_wrapper::Registrator< js_dom_EntityReference >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_dom_ProcessingInstruction::static_get_target(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_ProcessingInstruction, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_ProcessingInstruction, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const std::string value = dynamic_cast<js_dom_ProcessingInstruction*>(ptr)->target;
return v8_wrapper::Set(value);
}
void js_dom_ProcessingInstruction::static_set_target(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_ProcessingInstruction, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_ProcessingInstruction, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_ProcessingInstruction::static_get_data(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_ProcessingInstruction, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_ProcessingInstruction, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
std::string value = dynamic_cast<js_dom_ProcessingInstruction*>(ptr)->data;
return v8_wrapper::Set(value);
}
void js_dom_ProcessingInstruction::static_set_data(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_ProcessingInstruction, 2>::implemented) {
v8_wrapper::CustomAttribute<js_dom_ProcessingInstruction, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_dom_ProcessingInstruction*>(ptr)->data = v8_wrapper::Get< std::string >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_ProcessingInstruction >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::ProcessingInstruction"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
instance->SetAccessor(v8::String::New("target"), js_dom_ProcessingInstruction::static_get_target, js_dom_ProcessingInstruction::static_set_target);
instance->SetAccessor(v8::String::New("data"), js_dom_ProcessingInstruction::static_get_data, js_dom_ProcessingInstruction::static_set_data);
v8_wrapper::Registrator< js_dom_ProcessingInstruction >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_DocumentFragment >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::DocumentFragment"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
v8_wrapper::Registrator< js_dom_DocumentFragment >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_dom_Document::static_createElement(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_tagName = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createElement(val_tagName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createDocumentFragment(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createDocumentFragment() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createTextNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_data = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createTextNode(val_data) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createComment(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_data = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createComment(val_data) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createCDATASection(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_data = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createCDATASection(val_data) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createProcessingInstruction(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_target = v8_wrapper::Get< std::string > ( args[0] );
std::string val_data = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createProcessingInstruction(val_target, val_data) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createAttribute(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createAttribute(val_name) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createEntityReference(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_name = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createEntityReference(val_name) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_getElementsByTagName(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_tagname = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->getElementsByTagName(val_tagname) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_importNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_importedNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
bool val_deep = v8_wrapper::Get< bool > ( args[1] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->importNode(val_importedNode, val_deep) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createElementNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_qualifiedName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createElementNS(val_namespaceURI, val_qualifiedName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_createAttributeNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_qualifiedName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->createAttributeNS(val_namespaceURI, val_qualifiedName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_getElementsByTagNameNS(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_namespaceURI = v8_wrapper::Get< std::string > ( args[0] );
std::string val_localName = v8_wrapper::Get< std::string > ( args[1] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->getElementsByTagNameNS(val_namespaceURI, val_localName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_dom_Document::static_getElementById(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
std::string val_elementId = v8_wrapper::Get< std::string > ( args[0] );
js_dom_Document * el = dynamic_cast<js_dom_Document *>(ptr);
retval = v8_wrapper::Set( el->getElementById(val_elementId) );
return scope.Close(retval);
}
Handle<Value> js_dom_Document::static_get_doctype(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Document, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Document, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Document*>(ptr)->doctype;
return v8_wrapper::Set(value);
}
void js_dom_Document::static_set_doctype(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Document, 1>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Document, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Document::static_get_implementation(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Document, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Document, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Document*>(ptr)->implementation;
return v8_wrapper::Set(value);
}
void js_dom_Document::static_set_implementation(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Document, 2>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Document, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_dom_Document::static_get_documentElement(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_dom_Document, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_dom_Document, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_dom_Document*>(ptr)->documentElement;
return v8_wrapper::Set(value);
}
void js_dom_Document::static_set_documentElement(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_dom_Document, 3>::implemented) {
v8_wrapper::CustomAttribute<js_dom_Document, 3>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_dom_Document >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("dom::Document"));
result->Inherit(v8_wrapper::Registrator< js_dom_Node >::GetTemplate());
proto->Set(v8::String::New("createElement"), v8::FunctionTemplate::New(js_dom_Document::static_createElement));
proto->Set(v8::String::New("createDocumentFragment"), v8::FunctionTemplate::New(js_dom_Document::static_createDocumentFragment));
proto->Set(v8::String::New("createTextNode"), v8::FunctionTemplate::New(js_dom_Document::static_createTextNode));
proto->Set(v8::String::New("createComment"), v8::FunctionTemplate::New(js_dom_Document::static_createComment));
proto->Set(v8::String::New("createCDATASection"), v8::FunctionTemplate::New(js_dom_Document::static_createCDATASection));
proto->Set(v8::String::New("createProcessingInstruction"), v8::FunctionTemplate::New(js_dom_Document::static_createProcessingInstruction));
proto->Set(v8::String::New("createAttribute"), v8::FunctionTemplate::New(js_dom_Document::static_createAttribute));
proto->Set(v8::String::New("createEntityReference"), v8::FunctionTemplate::New(js_dom_Document::static_createEntityReference));
proto->Set(v8::String::New("getElementsByTagName"), v8::FunctionTemplate::New(js_dom_Document::static_getElementsByTagName));
proto->Set(v8::String::New("importNode"), v8::FunctionTemplate::New(js_dom_Document::static_importNode));
proto->Set(v8::String::New("createElementNS"), v8::FunctionTemplate::New(js_dom_Document::static_createElementNS));
proto->Set(v8::String::New("createAttributeNS"), v8::FunctionTemplate::New(js_dom_Document::static_createAttributeNS));
proto->Set(v8::String::New("getElementsByTagNameNS"), v8::FunctionTemplate::New(js_dom_Document::static_getElementsByTagNameNS));
proto->Set(v8::String::New("getElementById"), v8::FunctionTemplate::New(js_dom_Document::static_getElementById));
instance->SetAccessor(v8::String::New("doctype"), js_dom_Document::static_get_doctype, js_dom_Document::static_set_doctype);
instance->SetAccessor(v8::String::New("implementation"), js_dom_Document::static_get_implementation, js_dom_Document::static_set_implementation);
instance->SetAccessor(v8::String::New("documentElement"), js_dom_Document::static_get_documentElement, js_dom_Document::static_set_documentElement);
v8_wrapper::Registrator< js_dom_Document >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_stylesheets_StyleSheet::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const stylesheets::DOMString value = dynamic_cast<js_stylesheets_StyleSheet*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_stylesheets_StyleSheet::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 1>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_stylesheets_StyleSheet::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_stylesheets_StyleSheet*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_stylesheets_StyleSheet::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 2>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_stylesheets_StyleSheet*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_stylesheets_StyleSheet::static_get_ownerNode(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_stylesheets_StyleSheet*>(ptr)->ownerNode;
return v8_wrapper::Set(value);
}
void js_stylesheets_StyleSheet::static_set_ownerNode(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 3>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_stylesheets_StyleSheet::static_get_parentStyleSheet(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_stylesheets_StyleSheet*>(ptr)->parentStyleSheet;
return v8_wrapper::Set(value);
}
void js_stylesheets_StyleSheet::static_set_parentStyleSheet(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 4>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_stylesheets_StyleSheet::static_get_href(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const stylesheets::DOMString value = dynamic_cast<js_stylesheets_StyleSheet*>(ptr)->href;
return v8_wrapper::Set(value);
}
void js_stylesheets_StyleSheet::static_set_href(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 5>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 5>::static_set(property, value, info);
return;
}
}
Handle<Value> js_stylesheets_StyleSheet::static_get_title(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const stylesheets::DOMString value = dynamic_cast<js_stylesheets_StyleSheet*>(ptr)->title;
return v8_wrapper::Set(value);
}
void js_stylesheets_StyleSheet::static_set_title(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 6>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 6>::static_set(property, value, info);
return;
}
}
Handle<Value> js_stylesheets_StyleSheet::static_get_media(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_stylesheets_StyleSheet*>(ptr)->media;
return v8_wrapper::Set(value);
}
void js_stylesheets_StyleSheet::static_set_media(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 7>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_StyleSheet, 7>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_stylesheets_StyleSheet >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("stylesheets::StyleSheet"));
instance->SetAccessor(v8::String::New("type"), js_stylesheets_StyleSheet::static_get_type, js_stylesheets_StyleSheet::static_set_type);
instance->SetAccessor(v8::String::New("disabled"), js_stylesheets_StyleSheet::static_get_disabled, js_stylesheets_StyleSheet::static_set_disabled);
instance->SetAccessor(v8::String::New("ownerNode"), js_stylesheets_StyleSheet::static_get_ownerNode, js_stylesheets_StyleSheet::static_set_ownerNode);
instance->SetAccessor(v8::String::New("parentStyleSheet"), js_stylesheets_StyleSheet::static_get_parentStyleSheet, js_stylesheets_StyleSheet::static_set_parentStyleSheet);
instance->SetAccessor(v8::String::New("href"), js_stylesheets_StyleSheet::static_get_href, js_stylesheets_StyleSheet::static_set_href);
instance->SetAccessor(v8::String::New("title"), js_stylesheets_StyleSheet::static_get_title, js_stylesheets_StyleSheet::static_set_title);
instance->SetAccessor(v8::String::New("media"), js_stylesheets_StyleSheet::static_get_media, js_stylesheets_StyleSheet::static_set_media);
v8_wrapper::Registrator< js_stylesheets_StyleSheet >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_stylesheets_StyleSheetList::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_stylesheets_StyleSheetList * el = dynamic_cast<js_stylesheets_StyleSheetList *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
Handle<Value> js_stylesheets_StyleSheetList::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheetList, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_StyleSheetList, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_stylesheets_StyleSheetList*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_stylesheets_StyleSheetList::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_StyleSheetList, 1>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_StyleSheetList, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_stylesheets_StyleSheetList >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("stylesheets::StyleSheetList"));
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_stylesheets_StyleSheetList::static_item));
instance->SetAccessor(v8::String::New("length"), js_stylesheets_StyleSheetList::static_get_length, js_stylesheets_StyleSheetList::static_set_length);
v8_wrapper::Registrator< js_stylesheets_StyleSheetList >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_stylesheets_MediaList::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_stylesheets_MediaList * el = dynamic_cast<js_stylesheets_MediaList *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_stylesheets_MediaList::static_deleteMedium(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
stylesheets::DOMString val_oldMedium = v8_wrapper::Get< stylesheets::DOMString > ( args[0] );
js_stylesheets_MediaList * el = dynamic_cast<js_stylesheets_MediaList *>(ptr);
el->deleteMedium(val_oldMedium);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_stylesheets_MediaList::static_appendMedium(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
stylesheets::DOMString val_newMedium = v8_wrapper::Get< stylesheets::DOMString > ( args[0] );
js_stylesheets_MediaList * el = dynamic_cast<js_stylesheets_MediaList *>(ptr);
el->appendMedium(val_newMedium);
return scope.Close(retval);
}
Handle<Value> js_stylesheets_MediaList::static_get_mediaText(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_MediaList, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_MediaList, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
stylesheets::DOMString value = dynamic_cast<js_stylesheets_MediaList*>(ptr)->mediaText;
return v8_wrapper::Set(value);
}
void js_stylesheets_MediaList::static_set_mediaText(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_MediaList, 1>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_MediaList, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_stylesheets_MediaList*>(ptr)->mediaText = v8_wrapper::Get< stylesheets::DOMString >(value);
}
Handle<Value> js_stylesheets_MediaList::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_MediaList, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_MediaList, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_stylesheets_MediaList*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_stylesheets_MediaList::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_MediaList, 2>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_MediaList, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_stylesheets_MediaList >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("stylesheets::MediaList"));
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_stylesheets_MediaList::static_item));
proto->Set(v8::String::New("deleteMedium"), v8::FunctionTemplate::New(js_stylesheets_MediaList::static_deleteMedium));
proto->Set(v8::String::New("appendMedium"), v8::FunctionTemplate::New(js_stylesheets_MediaList::static_appendMedium));
instance->SetAccessor(v8::String::New("mediaText"), js_stylesheets_MediaList::static_get_mediaText, js_stylesheets_MediaList::static_set_mediaText);
instance->SetAccessor(v8::String::New("length"), js_stylesheets_MediaList::static_get_length, js_stylesheets_MediaList::static_set_length);
v8_wrapper::Registrator< js_stylesheets_MediaList >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_stylesheets_LinkStyle::static_get_sheet(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_LinkStyle, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_LinkStyle, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_stylesheets_LinkStyle*>(ptr)->sheet;
return v8_wrapper::Set(value);
}
void js_stylesheets_LinkStyle::static_set_sheet(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_LinkStyle, 1>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_LinkStyle, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_stylesheets_LinkStyle >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("stylesheets::LinkStyle"));
instance->SetAccessor(v8::String::New("sheet"), js_stylesheets_LinkStyle::static_get_sheet, js_stylesheets_LinkStyle::static_set_sheet);
v8_wrapper::Registrator< js_stylesheets_LinkStyle >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_stylesheets_DocumentStyle::static_get_styleSheets(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_DocumentStyle, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_stylesheets_DocumentStyle, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_stylesheets_DocumentStyle*>(ptr)->styleSheets;
return v8_wrapper::Set(value);
}
void js_stylesheets_DocumentStyle::static_set_styleSheets(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_stylesheets_DocumentStyle, 1>::implemented) {
v8_wrapper::CustomAttribute<js_stylesheets_DocumentStyle, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_stylesheets_DocumentStyle >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("stylesheets::DocumentStyle"));
instance->SetAccessor(v8::String::New("styleSheets"), js_stylesheets_DocumentStyle::static_get_styleSheets, js_stylesheets_DocumentStyle::static_set_styleSheets);
v8_wrapper::Registrator< js_stylesheets_DocumentStyle >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_views_AbstractView::static_get_document(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_views_AbstractView, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_views_AbstractView, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_views_AbstractView*>(ptr)->document;
return v8_wrapper::Set(value);
}
void js_views_AbstractView::static_set_document(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_views_AbstractView, 1>::implemented) {
v8_wrapper::CustomAttribute<js_views_AbstractView, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_views_AbstractView >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("views::AbstractView"));
instance->SetAccessor(v8::String::New("document"), js_views_AbstractView::static_get_document, js_views_AbstractView::static_set_document);
v8_wrapper::Registrator< js_views_AbstractView >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_views_DocumentView::static_get_defaultView(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_views_DocumentView, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_views_DocumentView, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_views_DocumentView*>(ptr)->defaultView;
return v8_wrapper::Set(value);
}
void js_views_DocumentView::static_set_defaultView(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_views_DocumentView, 1>::implemented) {
v8_wrapper::CustomAttribute<js_views_DocumentView, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_views_DocumentView >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("views::DocumentView"));
instance->SetAccessor(v8::String::New("defaultView"), js_views_DocumentView::static_get_defaultView, js_views_DocumentView::static_set_defaultView);
v8_wrapper::Registrator< js_views_DocumentView >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_CSSRuleList::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_css_CSSRuleList * el = dynamic_cast<js_css_CSSRuleList *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
Handle<Value> js_css_CSSRuleList::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRuleList, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSRuleList, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_css_CSSRuleList*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_css_CSSRuleList::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRuleList, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSRuleList, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSRuleList >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSRuleList"));
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_css_CSSRuleList::static_item));
instance->SetAccessor(v8::String::New("length"), js_css_CSSRuleList::static_get_length, js_css_CSSRuleList::static_set_length);
v8_wrapper::Registrator< js_css_CSSRuleList >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_CSSRule::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRule, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSRule, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const short unsigned int value = dynamic_cast<js_css_CSSRule*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_css_CSSRule::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRule, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSRule, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_CSSRule::static_get_cssText(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRule, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSRule, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSSRule*>(ptr)->cssText;
return v8_wrapper::Set(value);
}
void js_css_CSSRule::static_set_cssText(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRule, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSRule, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSSRule*>(ptr)->cssText = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSSRule::static_get_parentStyleSheet(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRule, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSRule, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSRule*>(ptr)->parentStyleSheet;
return v8_wrapper::Set(value);
}
void js_css_CSSRule::static_set_parentStyleSheet(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRule, 3>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSRule, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_CSSRule::static_get_parentRule(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRule, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSRule, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSRule*>(ptr)->parentRule;
return v8_wrapper::Set(value);
}
void js_css_CSSRule::static_set_parentRule(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSRule, 4>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSRule, 4>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSRule >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSRule"));
instance->SetAccessor(v8::String::New("type"), js_css_CSSRule::static_get_type, js_css_CSSRule::static_set_type);
instance->SetAccessor(v8::String::New("cssText"), js_css_CSSRule::static_get_cssText, js_css_CSSRule::static_set_cssText);
instance->SetAccessor(v8::String::New("parentStyleSheet"), js_css_CSSRule::static_get_parentStyleSheet, js_css_CSSRule::static_set_parentStyleSheet);
instance->SetAccessor(v8::String::New("parentRule"), js_css_CSSRule::static_get_parentRule, js_css_CSSRule::static_set_parentRule);
v8_wrapper::Registrator< js_css_CSSRule >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_CSSStyleRule::static_get_selectorText(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleRule, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSStyleRule, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSSStyleRule*>(ptr)->selectorText;
return v8_wrapper::Set(value);
}
void js_css_CSSStyleRule::static_set_selectorText(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleRule, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSStyleRule, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSSStyleRule*>(ptr)->selectorText = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSSStyleRule::static_get_style(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleRule, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSStyleRule, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSStyleRule*>(ptr)->style;
return v8_wrapper::Set(value);
}
void js_css_CSSStyleRule::static_set_style(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleRule, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSStyleRule, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSStyleRule >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSStyleRule"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSRule >::GetTemplate());
instance->SetAccessor(v8::String::New("selectorText"), js_css_CSSStyleRule::static_get_selectorText, js_css_CSSStyleRule::static_set_selectorText);
instance->SetAccessor(v8::String::New("style"), js_css_CSSStyleRule::static_get_style, js_css_CSSStyleRule::static_set_style);
v8_wrapper::Registrator< js_css_CSSStyleRule >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_CSSMediaRule::static_insertRule(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
css::DOMString val_rule = v8_wrapper::Get< css::DOMString > ( args[0] );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[1] );
js_css_CSSMediaRule * el = dynamic_cast<js_css_CSSMediaRule *>(ptr);
retval = v8_wrapper::Set( el->insertRule(val_rule, val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSMediaRule::static_deleteRule(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_css_CSSMediaRule * el = dynamic_cast<js_css_CSSMediaRule *>(ptr);
el->deleteRule(val_index);
return scope.Close(retval);
}
Handle<Value> js_css_CSSMediaRule::static_get_media(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSMediaRule, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSMediaRule, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSMediaRule*>(ptr)->media;
return v8_wrapper::Set(value);
}
void js_css_CSSMediaRule::static_set_media(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSMediaRule, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSMediaRule, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_CSSMediaRule::static_get_cssRules(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSMediaRule, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSMediaRule, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSMediaRule*>(ptr)->cssRules;
return v8_wrapper::Set(value);
}
void js_css_CSSMediaRule::static_set_cssRules(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSMediaRule, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSMediaRule, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSMediaRule >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSMediaRule"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSRule >::GetTemplate());
proto->Set(v8::String::New("insertRule"), v8::FunctionTemplate::New(js_css_CSSMediaRule::static_insertRule));
proto->Set(v8::String::New("deleteRule"), v8::FunctionTemplate::New(js_css_CSSMediaRule::static_deleteRule));
instance->SetAccessor(v8::String::New("media"), js_css_CSSMediaRule::static_get_media, js_css_CSSMediaRule::static_set_media);
instance->SetAccessor(v8::String::New("cssRules"), js_css_CSSMediaRule::static_get_cssRules, js_css_CSSMediaRule::static_set_cssRules);
v8_wrapper::Registrator< js_css_CSSMediaRule >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_CSSFontFaceRule::static_get_style(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSFontFaceRule, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSFontFaceRule, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSFontFaceRule*>(ptr)->style;
return v8_wrapper::Set(value);
}
void js_css_CSSFontFaceRule::static_set_style(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSFontFaceRule, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSFontFaceRule, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSFontFaceRule >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSFontFaceRule"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSRule >::GetTemplate());
instance->SetAccessor(v8::String::New("style"), js_css_CSSFontFaceRule::static_get_style, js_css_CSSFontFaceRule::static_set_style);
v8_wrapper::Registrator< js_css_CSSFontFaceRule >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_CSSPageRule::static_get_selectorText(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSPageRule, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSPageRule, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSSPageRule*>(ptr)->selectorText;
return v8_wrapper::Set(value);
}
void js_css_CSSPageRule::static_set_selectorText(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSPageRule, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSPageRule, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSSPageRule*>(ptr)->selectorText = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSSPageRule::static_get_style(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSPageRule, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSPageRule, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSPageRule*>(ptr)->style;
return v8_wrapper::Set(value);
}
void js_css_CSSPageRule::static_set_style(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSPageRule, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSPageRule, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSPageRule >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSPageRule"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSRule >::GetTemplate());
instance->SetAccessor(v8::String::New("selectorText"), js_css_CSSPageRule::static_get_selectorText, js_css_CSSPageRule::static_set_selectorText);
instance->SetAccessor(v8::String::New("style"), js_css_CSSPageRule::static_get_style, js_css_CSSPageRule::static_set_style);
v8_wrapper::Registrator< js_css_CSSPageRule >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_CSSImportRule::static_get_href(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSImportRule, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSImportRule, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const css::DOMString value = dynamic_cast<js_css_CSSImportRule*>(ptr)->href;
return v8_wrapper::Set(value);
}
void js_css_CSSImportRule::static_set_href(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSImportRule, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSImportRule, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_CSSImportRule::static_get_media(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSImportRule, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSImportRule, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSImportRule*>(ptr)->media;
return v8_wrapper::Set(value);
}
void js_css_CSSImportRule::static_set_media(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSImportRule, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSImportRule, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_CSSImportRule::static_get_styleSheet(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSImportRule, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSImportRule, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSImportRule*>(ptr)->styleSheet;
return v8_wrapper::Set(value);
}
void js_css_CSSImportRule::static_set_styleSheet(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSImportRule, 3>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSImportRule, 3>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSImportRule >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSImportRule"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSRule >::GetTemplate());
instance->SetAccessor(v8::String::New("href"), js_css_CSSImportRule::static_get_href, js_css_CSSImportRule::static_set_href);
instance->SetAccessor(v8::String::New("media"), js_css_CSSImportRule::static_get_media, js_css_CSSImportRule::static_set_media);
instance->SetAccessor(v8::String::New("styleSheet"), js_css_CSSImportRule::static_get_styleSheet, js_css_CSSImportRule::static_set_styleSheet);
v8_wrapper::Registrator< js_css_CSSImportRule >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_CSSCharsetRule::static_get_encoding(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSCharsetRule, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSCharsetRule, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSSCharsetRule*>(ptr)->encoding;
return v8_wrapper::Set(value);
}
void js_css_CSSCharsetRule::static_set_encoding(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSCharsetRule, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSCharsetRule, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSSCharsetRule*>(ptr)->encoding = v8_wrapper::Get< css::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSCharsetRule >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSCharsetRule"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSRule >::GetTemplate());
instance->SetAccessor(v8::String::New("encoding"), js_css_CSSCharsetRule::static_get_encoding, js_css_CSSCharsetRule::static_set_encoding);
v8_wrapper::Registrator< js_css_CSSCharsetRule >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSUnknownRule >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSUnknownRule"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSRule >::GetTemplate());
v8_wrapper::Registrator< js_css_CSSUnknownRule >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_CSSStyleDeclaration::static_getPropertyValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
css::DOMString val_propertyName = v8_wrapper::Get< css::DOMString > ( args[0] );
js_css_CSSStyleDeclaration * el = dynamic_cast<js_css_CSSStyleDeclaration *>(ptr);
retval = v8_wrapper::Set( el->getPropertyValue(val_propertyName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSStyleDeclaration::static_getPropertyCSSValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
css::DOMString val_propertyName = v8_wrapper::Get< css::DOMString > ( args[0] );
js_css_CSSStyleDeclaration * el = dynamic_cast<js_css_CSSStyleDeclaration *>(ptr);
retval = v8_wrapper::Set( el->getPropertyCSSValue(val_propertyName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSStyleDeclaration::static_removeProperty(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
css::DOMString val_propertyName = v8_wrapper::Get< css::DOMString > ( args[0] );
js_css_CSSStyleDeclaration * el = dynamic_cast<js_css_CSSStyleDeclaration *>(ptr);
retval = v8_wrapper::Set( el->removeProperty(val_propertyName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSStyleDeclaration::static_getPropertyPriority(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
css::DOMString val_propertyName = v8_wrapper::Get< css::DOMString > ( args[0] );
js_css_CSSStyleDeclaration * el = dynamic_cast<js_css_CSSStyleDeclaration *>(ptr);
retval = v8_wrapper::Set( el->getPropertyPriority(val_propertyName) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSStyleDeclaration::static_setProperty(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
css::DOMString val_propertyName = v8_wrapper::Get< css::DOMString > ( args[0] );
css::DOMString val_value = v8_wrapper::Get< css::DOMString > ( args[1] );
css::DOMString val_priority = v8_wrapper::Get< css::DOMString > ( args[2] );
js_css_CSSStyleDeclaration * el = dynamic_cast<js_css_CSSStyleDeclaration *>(ptr);
el->setProperty(val_propertyName, val_value, val_priority);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSStyleDeclaration::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_css_CSSStyleDeclaration * el = dynamic_cast<js_css_CSSStyleDeclaration *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
Handle<Value> js_css_CSSStyleDeclaration::static_get_cssText(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSSStyleDeclaration*>(ptr)->cssText;
return v8_wrapper::Set(value);
}
void js_css_CSSStyleDeclaration::static_set_cssText(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSSStyleDeclaration*>(ptr)->cssText = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSSStyleDeclaration::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_css_CSSStyleDeclaration*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_css_CSSStyleDeclaration::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_CSSStyleDeclaration::static_get_parentRule(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSStyleDeclaration*>(ptr)->parentRule;
return v8_wrapper::Set(value);
}
void js_css_CSSStyleDeclaration::static_set_parentRule(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 3>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSStyleDeclaration, 3>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSStyleDeclaration >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSStyleDeclaration"));
proto->Set(v8::String::New("getPropertyValue"), v8::FunctionTemplate::New(js_css_CSSStyleDeclaration::static_getPropertyValue));
proto->Set(v8::String::New("getPropertyCSSValue"), v8::FunctionTemplate::New(js_css_CSSStyleDeclaration::static_getPropertyCSSValue));
proto->Set(v8::String::New("removeProperty"), v8::FunctionTemplate::New(js_css_CSSStyleDeclaration::static_removeProperty));
proto->Set(v8::String::New("getPropertyPriority"), v8::FunctionTemplate::New(js_css_CSSStyleDeclaration::static_getPropertyPriority));
proto->Set(v8::String::New("setProperty"), v8::FunctionTemplate::New(js_css_CSSStyleDeclaration::static_setProperty));
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_css_CSSStyleDeclaration::static_item));
instance->SetAccessor(v8::String::New("cssText"), js_css_CSSStyleDeclaration::static_get_cssText, js_css_CSSStyleDeclaration::static_set_cssText);
instance->SetAccessor(v8::String::New("length"), js_css_CSSStyleDeclaration::static_get_length, js_css_CSSStyleDeclaration::static_set_length);
instance->SetAccessor(v8::String::New("parentRule"), js_css_CSSStyleDeclaration::static_get_parentRule, js_css_CSSStyleDeclaration::static_set_parentRule);
v8_wrapper::Registrator< js_css_CSSStyleDeclaration >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_CSSValue::static_get_cssText(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSValue, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSValue, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSSValue*>(ptr)->cssText;
return v8_wrapper::Set(value);
}
void js_css_CSSValue::static_set_cssText(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSValue, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSValue, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSSValue*>(ptr)->cssText = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSSValue::static_get_cssValueType(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSValue, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSValue, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const short unsigned int value = dynamic_cast<js_css_CSSValue*>(ptr)->cssValueType;
return v8_wrapper::Set(value);
}
void js_css_CSSValue::static_set_cssValueType(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSValue, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSValue, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSValue >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSValue"));
instance->SetAccessor(v8::String::New("cssText"), js_css_CSSValue::static_get_cssText, js_css_CSSValue::static_set_cssText);
instance->SetAccessor(v8::String::New("cssValueType"), js_css_CSSValue::static_get_cssValueType, js_css_CSSValue::static_set_cssValueType);
v8_wrapper::Registrator< js_css_CSSValue >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_CSSPrimitiveValue::static_setFloatValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
short unsigned int val_unitType = v8_wrapper::Get< short unsigned int > ( args[0] );
double val_floatValue = v8_wrapper::Get< double > ( args[1] );
js_css_CSSPrimitiveValue * el = dynamic_cast<js_css_CSSPrimitiveValue *>(ptr);
el->setFloatValue(val_unitType, val_floatValue);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSPrimitiveValue::static_getFloatValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
short unsigned int val_unitType = v8_wrapper::Get< short unsigned int > ( args[0] );
js_css_CSSPrimitiveValue * el = dynamic_cast<js_css_CSSPrimitiveValue *>(ptr);
retval = v8_wrapper::Set( el->getFloatValue(val_unitType) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSPrimitiveValue::static_setStringValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
short unsigned int val_stringType = v8_wrapper::Get< short unsigned int > ( args[0] );
css::DOMString val_stringValue = v8_wrapper::Get< css::DOMString > ( args[1] );
js_css_CSSPrimitiveValue * el = dynamic_cast<js_css_CSSPrimitiveValue *>(ptr);
el->setStringValue(val_stringType, val_stringValue);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSPrimitiveValue::static_getStringValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_css_CSSPrimitiveValue * el = dynamic_cast<js_css_CSSPrimitiveValue *>(ptr);
retval = v8_wrapper::Set( el->getStringValue() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSPrimitiveValue::static_getCounterValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_css_CSSPrimitiveValue * el = dynamic_cast<js_css_CSSPrimitiveValue *>(ptr);
retval = v8_wrapper::Set( el->getCounterValue() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSPrimitiveValue::static_getRectValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_css_CSSPrimitiveValue * el = dynamic_cast<js_css_CSSPrimitiveValue *>(ptr);
retval = v8_wrapper::Set( el->getRectValue() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSPrimitiveValue::static_getRGBColorValue(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_css_CSSPrimitiveValue * el = dynamic_cast<js_css_CSSPrimitiveValue *>(ptr);
retval = v8_wrapper::Set( el->getRGBColorValue() );
return scope.Close(retval);
}
Handle<Value> js_css_CSSPrimitiveValue::static_get_primitiveType(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSPrimitiveValue, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSPrimitiveValue, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const short unsigned int value = dynamic_cast<js_css_CSSPrimitiveValue*>(ptr)->primitiveType;
return v8_wrapper::Set(value);
}
void js_css_CSSPrimitiveValue::static_set_primitiveType(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSPrimitiveValue, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSPrimitiveValue, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSPrimitiveValue >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSPrimitiveValue"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSValue >::GetTemplate());
proto->Set(v8::String::New("setFloatValue"), v8::FunctionTemplate::New(js_css_CSSPrimitiveValue::static_setFloatValue));
proto->Set(v8::String::New("getFloatValue"), v8::FunctionTemplate::New(js_css_CSSPrimitiveValue::static_getFloatValue));
proto->Set(v8::String::New("setStringValue"), v8::FunctionTemplate::New(js_css_CSSPrimitiveValue::static_setStringValue));
proto->Set(v8::String::New("getStringValue"), v8::FunctionTemplate::New(js_css_CSSPrimitiveValue::static_getStringValue));
proto->Set(v8::String::New("getCounterValue"), v8::FunctionTemplate::New(js_css_CSSPrimitiveValue::static_getCounterValue));
proto->Set(v8::String::New("getRectValue"), v8::FunctionTemplate::New(js_css_CSSPrimitiveValue::static_getRectValue));
proto->Set(v8::String::New("getRGBColorValue"), v8::FunctionTemplate::New(js_css_CSSPrimitiveValue::static_getRGBColorValue));
instance->SetAccessor(v8::String::New("primitiveType"), js_css_CSSPrimitiveValue::static_get_primitiveType, js_css_CSSPrimitiveValue::static_set_primitiveType);
v8_wrapper::Registrator< js_css_CSSPrimitiveValue >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_CSSValueList::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_css_CSSValueList * el = dynamic_cast<js_css_CSSValueList *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
Handle<Value> js_css_CSSValueList::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSValueList, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSValueList, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_css_CSSValueList*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_css_CSSValueList::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSValueList, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSValueList, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSValueList >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSValueList"));
result->Inherit(v8_wrapper::Registrator< js_css_CSSValue >::GetTemplate());
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_css_CSSValueList::static_item));
instance->SetAccessor(v8::String::New("length"), js_css_CSSValueList::static_get_length, js_css_CSSValueList::static_set_length);
v8_wrapper::Registrator< js_css_CSSValueList >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_RGBColor::static_get_red(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_RGBColor, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_RGBColor, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_RGBColor*>(ptr)->red;
return v8_wrapper::Set(value);
}
void js_css_RGBColor::static_set_red(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_RGBColor, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_RGBColor, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_RGBColor::static_get_green(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_RGBColor, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_RGBColor, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_RGBColor*>(ptr)->green;
return v8_wrapper::Set(value);
}
void js_css_RGBColor::static_set_green(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_RGBColor, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_RGBColor, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_RGBColor::static_get_blue(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_RGBColor, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_css_RGBColor, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_RGBColor*>(ptr)->blue;
return v8_wrapper::Set(value);
}
void js_css_RGBColor::static_set_blue(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_RGBColor, 3>::implemented) {
v8_wrapper::CustomAttribute<js_css_RGBColor, 3>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_RGBColor >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::RGBColor"));
instance->SetAccessor(v8::String::New("red"), js_css_RGBColor::static_get_red, js_css_RGBColor::static_set_red);
instance->SetAccessor(v8::String::New("green"), js_css_RGBColor::static_get_green, js_css_RGBColor::static_set_green);
instance->SetAccessor(v8::String::New("blue"), js_css_RGBColor::static_get_blue, js_css_RGBColor::static_set_blue);
v8_wrapper::Registrator< js_css_RGBColor >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_Rect::static_get_top(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_Rect, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_Rect, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_Rect*>(ptr)->top;
return v8_wrapper::Set(value);
}
void js_css_Rect::static_set_top(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_Rect, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_Rect, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_Rect::static_get_right(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_Rect, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_Rect, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_Rect*>(ptr)->right;
return v8_wrapper::Set(value);
}
void js_css_Rect::static_set_right(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_Rect, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_Rect, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_Rect::static_get_bottom(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_Rect, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_css_Rect, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_Rect*>(ptr)->bottom;
return v8_wrapper::Set(value);
}
void js_css_Rect::static_set_bottom(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_Rect, 3>::implemented) {
v8_wrapper::CustomAttribute<js_css_Rect, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_Rect::static_get_left(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_Rect, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_css_Rect, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_Rect*>(ptr)->left;
return v8_wrapper::Set(value);
}
void js_css_Rect::static_set_left(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_Rect, 4>::implemented) {
v8_wrapper::CustomAttribute<js_css_Rect, 4>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_Rect >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::Rect"));
instance->SetAccessor(v8::String::New("top"), js_css_Rect::static_get_top, js_css_Rect::static_set_top);
instance->SetAccessor(v8::String::New("right"), js_css_Rect::static_get_right, js_css_Rect::static_set_right);
instance->SetAccessor(v8::String::New("bottom"), js_css_Rect::static_get_bottom, js_css_Rect::static_set_bottom);
instance->SetAccessor(v8::String::New("left"), js_css_Rect::static_get_left, js_css_Rect::static_set_left);
v8_wrapper::Registrator< js_css_Rect >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_Counter::static_get_identifier(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_Counter, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_Counter, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const css::DOMString value = dynamic_cast<js_css_Counter*>(ptr)->identifier;
return v8_wrapper::Set(value);
}
void js_css_Counter::static_set_identifier(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_Counter, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_Counter, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_Counter::static_get_listStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_Counter, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_Counter, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const css::DOMString value = dynamic_cast<js_css_Counter*>(ptr)->listStyle;
return v8_wrapper::Set(value);
}
void js_css_Counter::static_set_listStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_Counter, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_Counter, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_Counter::static_get_separator(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_Counter, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_css_Counter, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const css::DOMString value = dynamic_cast<js_css_Counter*>(ptr)->separator;
return v8_wrapper::Set(value);
}
void js_css_Counter::static_set_separator(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_Counter, 3>::implemented) {
v8_wrapper::CustomAttribute<js_css_Counter, 3>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_Counter >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::Counter"));
instance->SetAccessor(v8::String::New("identifier"), js_css_Counter::static_get_identifier, js_css_Counter::static_set_identifier);
instance->SetAccessor(v8::String::New("listStyle"), js_css_Counter::static_get_listStyle, js_css_Counter::static_set_listStyle);
instance->SetAccessor(v8::String::New("separator"), js_css_Counter::static_get_separator, js_css_Counter::static_set_separator);
v8_wrapper::Registrator< js_css_Counter >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_ElementCSSInlineStyle::static_get_style(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_ElementCSSInlineStyle, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_ElementCSSInlineStyle, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_ElementCSSInlineStyle*>(ptr)->style;
return v8_wrapper::Set(value);
}
void js_css_ElementCSSInlineStyle::static_set_style(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_ElementCSSInlineStyle, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_ElementCSSInlineStyle, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_ElementCSSInlineStyle >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::ElementCSSInlineStyle"));
instance->SetAccessor(v8::String::New("style"), js_css_ElementCSSInlineStyle::static_get_style, js_css_ElementCSSInlineStyle::static_set_style);
v8_wrapper::Registrator< js_css_ElementCSSInlineStyle >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_css_CSS2Properties::static_get_azimuth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->azimuth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_azimuth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->azimuth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_background(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->background;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_background(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->background = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_backgroundAttachment(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundAttachment;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_backgroundAttachment(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 3>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundAttachment = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_backgroundColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundColor;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_backgroundColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 4>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundColor = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_backgroundImage(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundImage;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_backgroundImage(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 5>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundImage = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_backgroundPosition(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundPosition;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_backgroundPosition(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 6>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundPosition = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_backgroundRepeat(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundRepeat;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_backgroundRepeat(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 7>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->backgroundRepeat = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_border(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->border;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_border(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 8>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->border = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderCollapse(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderCollapse;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderCollapse(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 9>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderCollapse = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderColor;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 10>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderColor = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderSpacing(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderSpacing;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderSpacing(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 11>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderSpacing = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderStyle;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 12>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 12>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderStyle = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderTop(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 13>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 13>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderTop;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderTop(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 13>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 13>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderTop = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderRight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 14>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 14>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderRight;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderRight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 14>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 14>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderRight = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderBottom(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 15>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 15>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderBottom;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderBottom(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 15>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 15>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderBottom = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderLeft(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 16>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 16>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderLeft;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderLeft(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 16>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 16>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderLeft = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderTopColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 17>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 17>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderTopColor;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderTopColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 17>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 17>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderTopColor = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderRightColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 18>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 18>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderRightColor;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderRightColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 18>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 18>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderRightColor = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderBottomColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 19>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 19>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderBottomColor;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderBottomColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 19>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 19>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderBottomColor = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderLeftColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 20>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 20>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderLeftColor;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderLeftColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 20>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 20>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderLeftColor = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderTopStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 21>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 21>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderTopStyle;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderTopStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 21>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 21>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderTopStyle = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderRightStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 22>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 22>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderRightStyle;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderRightStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 22>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 22>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderRightStyle = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderBottomStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 23>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 23>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderBottomStyle;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderBottomStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 23>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 23>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderBottomStyle = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderLeftStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 24>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 24>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderLeftStyle;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderLeftStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 24>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 24>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderLeftStyle = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderTopWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 25>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 25>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderTopWidth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderTopWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 25>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 25>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderTopWidth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderRightWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 26>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 26>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderRightWidth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderRightWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 26>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 26>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderRightWidth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderBottomWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 27>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 27>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderBottomWidth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderBottomWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 27>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 27>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderBottomWidth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderLeftWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 28>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 28>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderLeftWidth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderLeftWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 28>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 28>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderLeftWidth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_borderWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 29>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 29>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->borderWidth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_borderWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 29>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 29>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->borderWidth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_bottom(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 30>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 30>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->bottom;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_bottom(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 30>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 30>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->bottom = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_captionSide(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 31>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 31>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->captionSide;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_captionSide(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 31>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 31>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->captionSide = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_clear(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 32>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 32>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->clear;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_clear(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 32>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 32>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->clear = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_clip(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 33>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 33>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->clip;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_clip(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 33>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 33>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->clip = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_color(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 34>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 34>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->color;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_color(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 34>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 34>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->color = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_content(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 35>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 35>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->content;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_content(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 35>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 35>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->content = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_counterIncrement(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 36>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 36>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->counterIncrement;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_counterIncrement(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 36>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 36>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->counterIncrement = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_counterReset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 37>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 37>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->counterReset;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_counterReset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 37>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 37>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->counterReset = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_cue(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 38>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 38>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->cue;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_cue(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 38>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 38>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->cue = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_cueAfter(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 39>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 39>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->cueAfter;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_cueAfter(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 39>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 39>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->cueAfter = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_cueBefore(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 40>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 40>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->cueBefore;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_cueBefore(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 40>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 40>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->cueBefore = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_cursor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 41>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 41>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->cursor;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_cursor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 41>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 41>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->cursor = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_direction(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 42>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 42>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->direction;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_direction(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 42>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 42>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->direction = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_display(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 43>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 43>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->display;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_display(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 43>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 43>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->display = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_elevation(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 44>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 44>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->elevation;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_elevation(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 44>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 44>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->elevation = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_emptyCells(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 45>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 45>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->emptyCells;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_emptyCells(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 45>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 45>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->emptyCells = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_cssFloat(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 46>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 46>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->cssFloat;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_cssFloat(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 46>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 46>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->cssFloat = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_font(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 47>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 47>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->font;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_font(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 47>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 47>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->font = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_fontFamily(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 48>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 48>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->fontFamily;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_fontFamily(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 48>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 48>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->fontFamily = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_fontSize(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 49>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 49>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->fontSize;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_fontSize(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 49>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 49>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->fontSize = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_fontSizeAdjust(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 50>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 50>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->fontSizeAdjust;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_fontSizeAdjust(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 50>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 50>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->fontSizeAdjust = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_fontStretch(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 51>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 51>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->fontStretch;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_fontStretch(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 51>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 51>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->fontStretch = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_fontStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 52>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 52>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->fontStyle;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_fontStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 52>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 52>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->fontStyle = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_fontVariant(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 53>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 53>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->fontVariant;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_fontVariant(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 53>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 53>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->fontVariant = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_fontWeight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 54>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 54>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->fontWeight;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_fontWeight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 54>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 54>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->fontWeight = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_height(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 55>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 55>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->height;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_height(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 55>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 55>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->height = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_left(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 56>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 56>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->left;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_left(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 56>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 56>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->left = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_letterSpacing(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 57>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 57>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->letterSpacing;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_letterSpacing(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 57>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 57>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->letterSpacing = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_lineHeight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 58>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 58>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->lineHeight;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_lineHeight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 58>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 58>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->lineHeight = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_listStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 59>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 59>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->listStyle;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_listStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 59>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 59>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->listStyle = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_listStyleImage(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 60>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 60>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->listStyleImage;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_listStyleImage(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 60>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 60>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->listStyleImage = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_listStylePosition(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 61>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 61>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->listStylePosition;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_listStylePosition(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 61>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 61>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->listStylePosition = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_listStyleType(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 62>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 62>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->listStyleType;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_listStyleType(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 62>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 62>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->listStyleType = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_margin(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 63>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 63>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->margin;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_margin(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 63>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 63>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->margin = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_marginTop(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 64>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 64>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->marginTop;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_marginTop(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 64>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 64>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->marginTop = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_marginRight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 65>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 65>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->marginRight;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_marginRight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 65>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 65>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->marginRight = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_marginBottom(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 66>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 66>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->marginBottom;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_marginBottom(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 66>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 66>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->marginBottom = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_marginLeft(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 67>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 67>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->marginLeft;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_marginLeft(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 67>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 67>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->marginLeft = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_markerOffset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 68>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 68>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->markerOffset;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_markerOffset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 68>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 68>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->markerOffset = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_marks(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 69>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 69>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->marks;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_marks(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 69>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 69>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->marks = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_maxHeight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 70>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 70>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->maxHeight;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_maxHeight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 70>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 70>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->maxHeight = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_maxWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 71>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 71>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->maxWidth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_maxWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 71>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 71>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->maxWidth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_minHeight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 72>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 72>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->minHeight;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_minHeight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 72>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 72>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->minHeight = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_minWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 73>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 73>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->minWidth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_minWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 73>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 73>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->minWidth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_orphans(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 74>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 74>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->orphans;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_orphans(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 74>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 74>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->orphans = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_outline(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 75>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 75>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->outline;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_outline(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 75>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 75>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->outline = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_outlineColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 76>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 76>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->outlineColor;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_outlineColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 76>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 76>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->outlineColor = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_outlineStyle(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 77>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 77>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->outlineStyle;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_outlineStyle(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 77>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 77>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->outlineStyle = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_outlineWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 78>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 78>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->outlineWidth;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_outlineWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 78>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 78>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->outlineWidth = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_overflow(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 79>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 79>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->overflow;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_overflow(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 79>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 79>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->overflow = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_padding(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 80>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 80>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->padding;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_padding(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 80>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 80>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->padding = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_paddingTop(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 81>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 81>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->paddingTop;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_paddingTop(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 81>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 81>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->paddingTop = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_paddingRight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 82>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 82>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->paddingRight;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_paddingRight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 82>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 82>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->paddingRight = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_paddingBottom(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 83>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 83>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->paddingBottom;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_paddingBottom(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 83>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 83>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->paddingBottom = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_paddingLeft(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 84>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 84>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->paddingLeft;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_paddingLeft(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 84>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 84>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->paddingLeft = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_page(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 85>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 85>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->page;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_page(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 85>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 85>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->page = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_pageBreakAfter(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 86>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 86>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->pageBreakAfter;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_pageBreakAfter(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 86>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 86>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->pageBreakAfter = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_pageBreakBefore(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 87>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 87>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->pageBreakBefore;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_pageBreakBefore(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 87>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 87>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->pageBreakBefore = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_pageBreakInside(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 88>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 88>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->pageBreakInside;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_pageBreakInside(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 88>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 88>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->pageBreakInside = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_pause(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 89>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 89>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->pause;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_pause(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 89>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 89>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->pause = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_pauseAfter(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 90>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 90>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->pauseAfter;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_pauseAfter(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 90>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 90>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->pauseAfter = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_pauseBefore(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 91>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 91>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->pauseBefore;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_pauseBefore(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 91>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 91>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->pauseBefore = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_pitch(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 92>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 92>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->pitch;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_pitch(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 92>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 92>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->pitch = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_pitchRange(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 93>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 93>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->pitchRange;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_pitchRange(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 93>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 93>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->pitchRange = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_playDuring(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 94>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 94>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->playDuring;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_playDuring(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 94>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 94>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->playDuring = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_position(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 95>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 95>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->position;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_position(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 95>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 95>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->position = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_quotes(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 96>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 96>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->quotes;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_quotes(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 96>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 96>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->quotes = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_richness(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 97>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 97>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->richness;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_richness(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 97>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 97>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->richness = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_right(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 98>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 98>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->right;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_right(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 98>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 98>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->right = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_size(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 99>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 99>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->size;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_size(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 99>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 99>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->size = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_speak(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 100>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 100>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->speak;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_speak(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 100>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 100>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->speak = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_speakHeader(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 101>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 101>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->speakHeader;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_speakHeader(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 101>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 101>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->speakHeader = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_speakNumeral(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 102>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 102>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->speakNumeral;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_speakNumeral(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 102>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 102>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->speakNumeral = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_speakPunctuation(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 103>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 103>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->speakPunctuation;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_speakPunctuation(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 103>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 103>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->speakPunctuation = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_speechRate(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 104>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 104>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->speechRate;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_speechRate(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 104>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 104>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->speechRate = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_stress(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 105>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 105>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->stress;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_stress(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 105>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 105>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->stress = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_tableLayout(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 106>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 106>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->tableLayout;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_tableLayout(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 106>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 106>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->tableLayout = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_textAlign(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 107>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 107>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->textAlign;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_textAlign(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 107>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 107>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->textAlign = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_textDecoration(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 108>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 108>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->textDecoration;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_textDecoration(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 108>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 108>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->textDecoration = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_textIndent(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 109>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 109>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->textIndent;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_textIndent(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 109>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 109>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->textIndent = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_textShadow(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 110>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 110>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->textShadow;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_textShadow(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 110>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 110>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->textShadow = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_textTransform(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 111>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 111>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->textTransform;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_textTransform(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 111>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 111>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->textTransform = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_top(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 112>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 112>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->top;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_top(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 112>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 112>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->top = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_unicodeBidi(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 113>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 113>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->unicodeBidi;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_unicodeBidi(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 113>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 113>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->unicodeBidi = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_verticalAlign(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 114>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 114>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->verticalAlign;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_verticalAlign(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 114>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 114>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->verticalAlign = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_visibility(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 115>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 115>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->visibility;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_visibility(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 115>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 115>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->visibility = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_voiceFamily(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 116>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 116>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->voiceFamily;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_voiceFamily(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 116>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 116>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->voiceFamily = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_volume(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 117>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 117>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->volume;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_volume(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 117>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 117>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->volume = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_whiteSpace(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 118>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 118>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->whiteSpace;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_whiteSpace(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 118>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 118>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->whiteSpace = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_widows(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 119>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 119>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->widows;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_widows(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 119>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 119>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->widows = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 120>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 120>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 120>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 120>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->width = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_wordSpacing(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 121>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 121>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->wordSpacing;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_wordSpacing(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 121>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 121>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->wordSpacing = v8_wrapper::Get< css::DOMString >(value);
}
Handle<Value> js_css_CSS2Properties::static_get_zIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 122>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSS2Properties, 122>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
css::DOMString value = dynamic_cast<js_css_CSS2Properties*>(ptr)->zIndex;
return v8_wrapper::Set(value);
}
void js_css_CSS2Properties::static_set_zIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSS2Properties, 122>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSS2Properties, 122>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_css_CSS2Properties*>(ptr)->zIndex = v8_wrapper::Get< css::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSS2Properties >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSS2Properties"));
instance->SetAccessor(v8::String::New("azimuth"), js_css_CSS2Properties::static_get_azimuth, js_css_CSS2Properties::static_set_azimuth);
instance->SetAccessor(v8::String::New("background"), js_css_CSS2Properties::static_get_background, js_css_CSS2Properties::static_set_background);
instance->SetAccessor(v8::String::New("backgroundAttachment"), js_css_CSS2Properties::static_get_backgroundAttachment, js_css_CSS2Properties::static_set_backgroundAttachment);
instance->SetAccessor(v8::String::New("backgroundColor"), js_css_CSS2Properties::static_get_backgroundColor, js_css_CSS2Properties::static_set_backgroundColor);
instance->SetAccessor(v8::String::New("backgroundImage"), js_css_CSS2Properties::static_get_backgroundImage, js_css_CSS2Properties::static_set_backgroundImage);
instance->SetAccessor(v8::String::New("backgroundPosition"), js_css_CSS2Properties::static_get_backgroundPosition, js_css_CSS2Properties::static_set_backgroundPosition);
instance->SetAccessor(v8::String::New("backgroundRepeat"), js_css_CSS2Properties::static_get_backgroundRepeat, js_css_CSS2Properties::static_set_backgroundRepeat);
instance->SetAccessor(v8::String::New("border"), js_css_CSS2Properties::static_get_border, js_css_CSS2Properties::static_set_border);
instance->SetAccessor(v8::String::New("borderCollapse"), js_css_CSS2Properties::static_get_borderCollapse, js_css_CSS2Properties::static_set_borderCollapse);
instance->SetAccessor(v8::String::New("borderColor"), js_css_CSS2Properties::static_get_borderColor, js_css_CSS2Properties::static_set_borderColor);
instance->SetAccessor(v8::String::New("borderSpacing"), js_css_CSS2Properties::static_get_borderSpacing, js_css_CSS2Properties::static_set_borderSpacing);
instance->SetAccessor(v8::String::New("borderStyle"), js_css_CSS2Properties::static_get_borderStyle, js_css_CSS2Properties::static_set_borderStyle);
instance->SetAccessor(v8::String::New("borderTop"), js_css_CSS2Properties::static_get_borderTop, js_css_CSS2Properties::static_set_borderTop);
instance->SetAccessor(v8::String::New("borderRight"), js_css_CSS2Properties::static_get_borderRight, js_css_CSS2Properties::static_set_borderRight);
instance->SetAccessor(v8::String::New("borderBottom"), js_css_CSS2Properties::static_get_borderBottom, js_css_CSS2Properties::static_set_borderBottom);
instance->SetAccessor(v8::String::New("borderLeft"), js_css_CSS2Properties::static_get_borderLeft, js_css_CSS2Properties::static_set_borderLeft);
instance->SetAccessor(v8::String::New("borderTopColor"), js_css_CSS2Properties::static_get_borderTopColor, js_css_CSS2Properties::static_set_borderTopColor);
instance->SetAccessor(v8::String::New("borderRightColor"), js_css_CSS2Properties::static_get_borderRightColor, js_css_CSS2Properties::static_set_borderRightColor);
instance->SetAccessor(v8::String::New("borderBottomColor"), js_css_CSS2Properties::static_get_borderBottomColor, js_css_CSS2Properties::static_set_borderBottomColor);
instance->SetAccessor(v8::String::New("borderLeftColor"), js_css_CSS2Properties::static_get_borderLeftColor, js_css_CSS2Properties::static_set_borderLeftColor);
instance->SetAccessor(v8::String::New("borderTopStyle"), js_css_CSS2Properties::static_get_borderTopStyle, js_css_CSS2Properties::static_set_borderTopStyle);
instance->SetAccessor(v8::String::New("borderRightStyle"), js_css_CSS2Properties::static_get_borderRightStyle, js_css_CSS2Properties::static_set_borderRightStyle);
instance->SetAccessor(v8::String::New("borderBottomStyle"), js_css_CSS2Properties::static_get_borderBottomStyle, js_css_CSS2Properties::static_set_borderBottomStyle);
instance->SetAccessor(v8::String::New("borderLeftStyle"), js_css_CSS2Properties::static_get_borderLeftStyle, js_css_CSS2Properties::static_set_borderLeftStyle);
instance->SetAccessor(v8::String::New("borderTopWidth"), js_css_CSS2Properties::static_get_borderTopWidth, js_css_CSS2Properties::static_set_borderTopWidth);
instance->SetAccessor(v8::String::New("borderRightWidth"), js_css_CSS2Properties::static_get_borderRightWidth, js_css_CSS2Properties::static_set_borderRightWidth);
instance->SetAccessor(v8::String::New("borderBottomWidth"), js_css_CSS2Properties::static_get_borderBottomWidth, js_css_CSS2Properties::static_set_borderBottomWidth);
instance->SetAccessor(v8::String::New("borderLeftWidth"), js_css_CSS2Properties::static_get_borderLeftWidth, js_css_CSS2Properties::static_set_borderLeftWidth);
instance->SetAccessor(v8::String::New("borderWidth"), js_css_CSS2Properties::static_get_borderWidth, js_css_CSS2Properties::static_set_borderWidth);
instance->SetAccessor(v8::String::New("bottom"), js_css_CSS2Properties::static_get_bottom, js_css_CSS2Properties::static_set_bottom);
instance->SetAccessor(v8::String::New("captionSide"), js_css_CSS2Properties::static_get_captionSide, js_css_CSS2Properties::static_set_captionSide);
instance->SetAccessor(v8::String::New("clear"), js_css_CSS2Properties::static_get_clear, js_css_CSS2Properties::static_set_clear);
instance->SetAccessor(v8::String::New("clip"), js_css_CSS2Properties::static_get_clip, js_css_CSS2Properties::static_set_clip);
instance->SetAccessor(v8::String::New("color"), js_css_CSS2Properties::static_get_color, js_css_CSS2Properties::static_set_color);
instance->SetAccessor(v8::String::New("content"), js_css_CSS2Properties::static_get_content, js_css_CSS2Properties::static_set_content);
instance->SetAccessor(v8::String::New("counterIncrement"), js_css_CSS2Properties::static_get_counterIncrement, js_css_CSS2Properties::static_set_counterIncrement);
instance->SetAccessor(v8::String::New("counterReset"), js_css_CSS2Properties::static_get_counterReset, js_css_CSS2Properties::static_set_counterReset);
instance->SetAccessor(v8::String::New("cue"), js_css_CSS2Properties::static_get_cue, js_css_CSS2Properties::static_set_cue);
instance->SetAccessor(v8::String::New("cueAfter"), js_css_CSS2Properties::static_get_cueAfter, js_css_CSS2Properties::static_set_cueAfter);
instance->SetAccessor(v8::String::New("cueBefore"), js_css_CSS2Properties::static_get_cueBefore, js_css_CSS2Properties::static_set_cueBefore);
instance->SetAccessor(v8::String::New("cursor"), js_css_CSS2Properties::static_get_cursor, js_css_CSS2Properties::static_set_cursor);
instance->SetAccessor(v8::String::New("direction"), js_css_CSS2Properties::static_get_direction, js_css_CSS2Properties::static_set_direction);
instance->SetAccessor(v8::String::New("display"), js_css_CSS2Properties::static_get_display, js_css_CSS2Properties::static_set_display);
instance->SetAccessor(v8::String::New("elevation"), js_css_CSS2Properties::static_get_elevation, js_css_CSS2Properties::static_set_elevation);
instance->SetAccessor(v8::String::New("emptyCells"), js_css_CSS2Properties::static_get_emptyCells, js_css_CSS2Properties::static_set_emptyCells);
instance->SetAccessor(v8::String::New("cssFloat"), js_css_CSS2Properties::static_get_cssFloat, js_css_CSS2Properties::static_set_cssFloat);
instance->SetAccessor(v8::String::New("font"), js_css_CSS2Properties::static_get_font, js_css_CSS2Properties::static_set_font);
instance->SetAccessor(v8::String::New("fontFamily"), js_css_CSS2Properties::static_get_fontFamily, js_css_CSS2Properties::static_set_fontFamily);
instance->SetAccessor(v8::String::New("fontSize"), js_css_CSS2Properties::static_get_fontSize, js_css_CSS2Properties::static_set_fontSize);
instance->SetAccessor(v8::String::New("fontSizeAdjust"), js_css_CSS2Properties::static_get_fontSizeAdjust, js_css_CSS2Properties::static_set_fontSizeAdjust);
instance->SetAccessor(v8::String::New("fontStretch"), js_css_CSS2Properties::static_get_fontStretch, js_css_CSS2Properties::static_set_fontStretch);
instance->SetAccessor(v8::String::New("fontStyle"), js_css_CSS2Properties::static_get_fontStyle, js_css_CSS2Properties::static_set_fontStyle);
instance->SetAccessor(v8::String::New("fontVariant"), js_css_CSS2Properties::static_get_fontVariant, js_css_CSS2Properties::static_set_fontVariant);
instance->SetAccessor(v8::String::New("fontWeight"), js_css_CSS2Properties::static_get_fontWeight, js_css_CSS2Properties::static_set_fontWeight);
instance->SetAccessor(v8::String::New("height"), js_css_CSS2Properties::static_get_height, js_css_CSS2Properties::static_set_height);
instance->SetAccessor(v8::String::New("left"), js_css_CSS2Properties::static_get_left, js_css_CSS2Properties::static_set_left);
instance->SetAccessor(v8::String::New("letterSpacing"), js_css_CSS2Properties::static_get_letterSpacing, js_css_CSS2Properties::static_set_letterSpacing);
instance->SetAccessor(v8::String::New("lineHeight"), js_css_CSS2Properties::static_get_lineHeight, js_css_CSS2Properties::static_set_lineHeight);
instance->SetAccessor(v8::String::New("listStyle"), js_css_CSS2Properties::static_get_listStyle, js_css_CSS2Properties::static_set_listStyle);
instance->SetAccessor(v8::String::New("listStyleImage"), js_css_CSS2Properties::static_get_listStyleImage, js_css_CSS2Properties::static_set_listStyleImage);
instance->SetAccessor(v8::String::New("listStylePosition"), js_css_CSS2Properties::static_get_listStylePosition, js_css_CSS2Properties::static_set_listStylePosition);
instance->SetAccessor(v8::String::New("listStyleType"), js_css_CSS2Properties::static_get_listStyleType, js_css_CSS2Properties::static_set_listStyleType);
instance->SetAccessor(v8::String::New("margin"), js_css_CSS2Properties::static_get_margin, js_css_CSS2Properties::static_set_margin);
instance->SetAccessor(v8::String::New("marginTop"), js_css_CSS2Properties::static_get_marginTop, js_css_CSS2Properties::static_set_marginTop);
instance->SetAccessor(v8::String::New("marginRight"), js_css_CSS2Properties::static_get_marginRight, js_css_CSS2Properties::static_set_marginRight);
instance->SetAccessor(v8::String::New("marginBottom"), js_css_CSS2Properties::static_get_marginBottom, js_css_CSS2Properties::static_set_marginBottom);
instance->SetAccessor(v8::String::New("marginLeft"), js_css_CSS2Properties::static_get_marginLeft, js_css_CSS2Properties::static_set_marginLeft);
instance->SetAccessor(v8::String::New("markerOffset"), js_css_CSS2Properties::static_get_markerOffset, js_css_CSS2Properties::static_set_markerOffset);
instance->SetAccessor(v8::String::New("marks"), js_css_CSS2Properties::static_get_marks, js_css_CSS2Properties::static_set_marks);
instance->SetAccessor(v8::String::New("maxHeight"), js_css_CSS2Properties::static_get_maxHeight, js_css_CSS2Properties::static_set_maxHeight);
instance->SetAccessor(v8::String::New("maxWidth"), js_css_CSS2Properties::static_get_maxWidth, js_css_CSS2Properties::static_set_maxWidth);
instance->SetAccessor(v8::String::New("minHeight"), js_css_CSS2Properties::static_get_minHeight, js_css_CSS2Properties::static_set_minHeight);
instance->SetAccessor(v8::String::New("minWidth"), js_css_CSS2Properties::static_get_minWidth, js_css_CSS2Properties::static_set_minWidth);
instance->SetAccessor(v8::String::New("orphans"), js_css_CSS2Properties::static_get_orphans, js_css_CSS2Properties::static_set_orphans);
instance->SetAccessor(v8::String::New("outline"), js_css_CSS2Properties::static_get_outline, js_css_CSS2Properties::static_set_outline);
instance->SetAccessor(v8::String::New("outlineColor"), js_css_CSS2Properties::static_get_outlineColor, js_css_CSS2Properties::static_set_outlineColor);
instance->SetAccessor(v8::String::New("outlineStyle"), js_css_CSS2Properties::static_get_outlineStyle, js_css_CSS2Properties::static_set_outlineStyle);
instance->SetAccessor(v8::String::New("outlineWidth"), js_css_CSS2Properties::static_get_outlineWidth, js_css_CSS2Properties::static_set_outlineWidth);
instance->SetAccessor(v8::String::New("overflow"), js_css_CSS2Properties::static_get_overflow, js_css_CSS2Properties::static_set_overflow);
instance->SetAccessor(v8::String::New("padding"), js_css_CSS2Properties::static_get_padding, js_css_CSS2Properties::static_set_padding);
instance->SetAccessor(v8::String::New("paddingTop"), js_css_CSS2Properties::static_get_paddingTop, js_css_CSS2Properties::static_set_paddingTop);
instance->SetAccessor(v8::String::New("paddingRight"), js_css_CSS2Properties::static_get_paddingRight, js_css_CSS2Properties::static_set_paddingRight);
instance->SetAccessor(v8::String::New("paddingBottom"), js_css_CSS2Properties::static_get_paddingBottom, js_css_CSS2Properties::static_set_paddingBottom);
instance->SetAccessor(v8::String::New("paddingLeft"), js_css_CSS2Properties::static_get_paddingLeft, js_css_CSS2Properties::static_set_paddingLeft);
instance->SetAccessor(v8::String::New("page"), js_css_CSS2Properties::static_get_page, js_css_CSS2Properties::static_set_page);
instance->SetAccessor(v8::String::New("pageBreakAfter"), js_css_CSS2Properties::static_get_pageBreakAfter, js_css_CSS2Properties::static_set_pageBreakAfter);
instance->SetAccessor(v8::String::New("pageBreakBefore"), js_css_CSS2Properties::static_get_pageBreakBefore, js_css_CSS2Properties::static_set_pageBreakBefore);
instance->SetAccessor(v8::String::New("pageBreakInside"), js_css_CSS2Properties::static_get_pageBreakInside, js_css_CSS2Properties::static_set_pageBreakInside);
instance->SetAccessor(v8::String::New("pause"), js_css_CSS2Properties::static_get_pause, js_css_CSS2Properties::static_set_pause);
instance->SetAccessor(v8::String::New("pauseAfter"), js_css_CSS2Properties::static_get_pauseAfter, js_css_CSS2Properties::static_set_pauseAfter);
instance->SetAccessor(v8::String::New("pauseBefore"), js_css_CSS2Properties::static_get_pauseBefore, js_css_CSS2Properties::static_set_pauseBefore);
instance->SetAccessor(v8::String::New("pitch"), js_css_CSS2Properties::static_get_pitch, js_css_CSS2Properties::static_set_pitch);
instance->SetAccessor(v8::String::New("pitchRange"), js_css_CSS2Properties::static_get_pitchRange, js_css_CSS2Properties::static_set_pitchRange);
instance->SetAccessor(v8::String::New("playDuring"), js_css_CSS2Properties::static_get_playDuring, js_css_CSS2Properties::static_set_playDuring);
instance->SetAccessor(v8::String::New("position"), js_css_CSS2Properties::static_get_position, js_css_CSS2Properties::static_set_position);
instance->SetAccessor(v8::String::New("quotes"), js_css_CSS2Properties::static_get_quotes, js_css_CSS2Properties::static_set_quotes);
instance->SetAccessor(v8::String::New("richness"), js_css_CSS2Properties::static_get_richness, js_css_CSS2Properties::static_set_richness);
instance->SetAccessor(v8::String::New("right"), js_css_CSS2Properties::static_get_right, js_css_CSS2Properties::static_set_right);
instance->SetAccessor(v8::String::New("size"), js_css_CSS2Properties::static_get_size, js_css_CSS2Properties::static_set_size);
instance->SetAccessor(v8::String::New("speak"), js_css_CSS2Properties::static_get_speak, js_css_CSS2Properties::static_set_speak);
instance->SetAccessor(v8::String::New("speakHeader"), js_css_CSS2Properties::static_get_speakHeader, js_css_CSS2Properties::static_set_speakHeader);
instance->SetAccessor(v8::String::New("speakNumeral"), js_css_CSS2Properties::static_get_speakNumeral, js_css_CSS2Properties::static_set_speakNumeral);
instance->SetAccessor(v8::String::New("speakPunctuation"), js_css_CSS2Properties::static_get_speakPunctuation, js_css_CSS2Properties::static_set_speakPunctuation);
instance->SetAccessor(v8::String::New("speechRate"), js_css_CSS2Properties::static_get_speechRate, js_css_CSS2Properties::static_set_speechRate);
instance->SetAccessor(v8::String::New("stress"), js_css_CSS2Properties::static_get_stress, js_css_CSS2Properties::static_set_stress);
instance->SetAccessor(v8::String::New("tableLayout"), js_css_CSS2Properties::static_get_tableLayout, js_css_CSS2Properties::static_set_tableLayout);
instance->SetAccessor(v8::String::New("textAlign"), js_css_CSS2Properties::static_get_textAlign, js_css_CSS2Properties::static_set_textAlign);
instance->SetAccessor(v8::String::New("textDecoration"), js_css_CSS2Properties::static_get_textDecoration, js_css_CSS2Properties::static_set_textDecoration);
instance->SetAccessor(v8::String::New("textIndent"), js_css_CSS2Properties::static_get_textIndent, js_css_CSS2Properties::static_set_textIndent);
instance->SetAccessor(v8::String::New("textShadow"), js_css_CSS2Properties::static_get_textShadow, js_css_CSS2Properties::static_set_textShadow);
instance->SetAccessor(v8::String::New("textTransform"), js_css_CSS2Properties::static_get_textTransform, js_css_CSS2Properties::static_set_textTransform);
instance->SetAccessor(v8::String::New("top"), js_css_CSS2Properties::static_get_top, js_css_CSS2Properties::static_set_top);
instance->SetAccessor(v8::String::New("unicodeBidi"), js_css_CSS2Properties::static_get_unicodeBidi, js_css_CSS2Properties::static_set_unicodeBidi);
instance->SetAccessor(v8::String::New("verticalAlign"), js_css_CSS2Properties::static_get_verticalAlign, js_css_CSS2Properties::static_set_verticalAlign);
instance->SetAccessor(v8::String::New("visibility"), js_css_CSS2Properties::static_get_visibility, js_css_CSS2Properties::static_set_visibility);
instance->SetAccessor(v8::String::New("voiceFamily"), js_css_CSS2Properties::static_get_voiceFamily, js_css_CSS2Properties::static_set_voiceFamily);
instance->SetAccessor(v8::String::New("volume"), js_css_CSS2Properties::static_get_volume, js_css_CSS2Properties::static_set_volume);
instance->SetAccessor(v8::String::New("whiteSpace"), js_css_CSS2Properties::static_get_whiteSpace, js_css_CSS2Properties::static_set_whiteSpace);
instance->SetAccessor(v8::String::New("widows"), js_css_CSS2Properties::static_get_widows, js_css_CSS2Properties::static_set_widows);
instance->SetAccessor(v8::String::New("width"), js_css_CSS2Properties::static_get_width, js_css_CSS2Properties::static_set_width);
instance->SetAccessor(v8::String::New("wordSpacing"), js_css_CSS2Properties::static_get_wordSpacing, js_css_CSS2Properties::static_set_wordSpacing);
instance->SetAccessor(v8::String::New("zIndex"), js_css_CSS2Properties::static_get_zIndex, js_css_CSS2Properties::static_set_zIndex);
v8_wrapper::Registrator< js_css_CSS2Properties >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_CSSStyleSheet::static_insertRule(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
css::DOMString val_rule = v8_wrapper::Get< css::DOMString > ( args[0] );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[1] );
js_css_CSSStyleSheet * el = dynamic_cast<js_css_CSSStyleSheet *>(ptr);
retval = v8_wrapper::Set( el->insertRule(val_rule, val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_css_CSSStyleSheet::static_deleteRule(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_css_CSSStyleSheet * el = dynamic_cast<js_css_CSSStyleSheet *>(ptr);
el->deleteRule(val_index);
return scope.Close(retval);
}
Handle<Value> js_css_CSSStyleSheet::static_get_ownerRule(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleSheet, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSStyleSheet, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSStyleSheet*>(ptr)->ownerRule;
return v8_wrapper::Set(value);
}
void js_css_CSSStyleSheet::static_set_ownerRule(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleSheet, 1>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSStyleSheet, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_css_CSSStyleSheet::static_get_cssRules(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleSheet, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_css_CSSStyleSheet, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_css_CSSStyleSheet*>(ptr)->cssRules;
return v8_wrapper::Set(value);
}
void js_css_CSSStyleSheet::static_set_cssRules(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_css_CSSStyleSheet, 2>::implemented) {
v8_wrapper::CustomAttribute<js_css_CSSStyleSheet, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_CSSStyleSheet >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::CSSStyleSheet"));
result->Inherit(v8_wrapper::Registrator< js_stylesheets_StyleSheet >::GetTemplate());
proto->Set(v8::String::New("insertRule"), v8::FunctionTemplate::New(js_css_CSSStyleSheet::static_insertRule));
proto->Set(v8::String::New("deleteRule"), v8::FunctionTemplate::New(js_css_CSSStyleSheet::static_deleteRule));
instance->SetAccessor(v8::String::New("ownerRule"), js_css_CSSStyleSheet::static_get_ownerRule, js_css_CSSStyleSheet::static_set_ownerRule);
instance->SetAccessor(v8::String::New("cssRules"), js_css_CSSStyleSheet::static_get_cssRules, js_css_CSSStyleSheet::static_set_cssRules);
v8_wrapper::Registrator< js_css_CSSStyleSheet >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_ViewCSS::static_getComputedStyle(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_elt = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
css::DOMString val_pseudoElt = v8_wrapper::Get< css::DOMString > ( args[1] );
js_css_ViewCSS * el = dynamic_cast<js_css_ViewCSS *>(ptr);
retval = v8_wrapper::Set( el->getComputedStyle(val_elt, val_pseudoElt) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_ViewCSS >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::ViewCSS"));
result->Inherit(v8_wrapper::Registrator< js_views_AbstractView >::GetTemplate());
proto->Set(v8::String::New("getComputedStyle"), v8::FunctionTemplate::New(js_css_ViewCSS::static_getComputedStyle));
v8_wrapper::Registrator< js_css_ViewCSS >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_DocumentCSS::static_getOverrideStyle(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_elt = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
css::DOMString val_pseudoElt = v8_wrapper::Get< css::DOMString > ( args[1] );
js_css_DocumentCSS * el = dynamic_cast<js_css_DocumentCSS *>(ptr);
retval = v8_wrapper::Set( el->getOverrideStyle(val_elt, val_pseudoElt) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_DocumentCSS >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::DocumentCSS"));
result->Inherit(v8_wrapper::Registrator< js_stylesheets_DocumentStyle >::GetTemplate());
proto->Set(v8::String::New("getOverrideStyle"), v8::FunctionTemplate::New(js_css_DocumentCSS::static_getOverrideStyle));
v8_wrapper::Registrator< js_css_DocumentCSS >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_css_DOMImplementationCSS::static_createCSSStyleSheet(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
css::DOMString val_title = v8_wrapper::Get< css::DOMString > ( args[0] );
css::DOMString val_media = v8_wrapper::Get< css::DOMString > ( args[1] );
js_css_DOMImplementationCSS * el = dynamic_cast<js_css_DOMImplementationCSS *>(ptr);
retval = v8_wrapper::Set( el->createCSSStyleSheet(val_title, val_media) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_css_DOMImplementationCSS >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("css::DOMImplementationCSS"));
result->Inherit(v8_wrapper::Registrator< js_dom_DOMImplementation >::GetTemplate());
proto->Set(v8::String::New("createCSSStyleSheet"), v8::FunctionTemplate::New(js_css_DOMImplementationCSS::static_createCSSStyleSheet));
v8_wrapper::Registrator< js_css_DOMImplementationCSS >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_events_EventException::static_get_code(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_EventException, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_events_EventException, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
short unsigned int value = dynamic_cast<js_events_EventException*>(ptr)->code;
return v8_wrapper::Set(value);
}
void js_events_EventException::static_set_code(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_EventException, 1>::implemented) {
v8_wrapper::CustomAttribute<js_events_EventException, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_events_EventException*>(ptr)->code = v8_wrapper::Get< short unsigned int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_events_EventException >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("events::EventException"));
instance->SetAccessor(v8::String::New("code"), js_events_EventException::static_get_code, js_events_EventException::static_set_code);
v8_wrapper::Registrator< js_events_EventException >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_events_EventTarget::static_addEventListener(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
events::DOMString val_type = v8_wrapper::Get< events::DOMString > ( args[0] );
v8::Handle<v8::Value> val_listener = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[1] );
bool val_useCapture = v8_wrapper::Get< bool > ( args[2] );
js_events_EventTarget * el = dynamic_cast<js_events_EventTarget *>(ptr);
el->addEventListener(val_type, val_listener, val_useCapture);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_events_EventTarget::static_removeEventListener(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
events::DOMString val_type = v8_wrapper::Get< events::DOMString > ( args[0] );
v8::Handle<v8::Value> val_listener = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[1] );
bool val_useCapture = v8_wrapper::Get< bool > ( args[2] );
js_events_EventTarget * el = dynamic_cast<js_events_EventTarget *>(ptr);
el->removeEventListener(val_type, val_listener, val_useCapture);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_events_EventTarget::static_dispatchEvent(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_evt = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_events_EventTarget * el = dynamic_cast<js_events_EventTarget *>(ptr);
retval = v8_wrapper::Set( el->dispatchEvent(val_evt) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_events_EventTarget >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("events::EventTarget"));
proto->Set(v8::String::New("addEventListener"), v8::FunctionTemplate::New(js_events_EventTarget::static_addEventListener));
proto->Set(v8::String::New("removeEventListener"), v8::FunctionTemplate::New(js_events_EventTarget::static_removeEventListener));
proto->Set(v8::String::New("dispatchEvent"), v8::FunctionTemplate::New(js_events_EventTarget::static_dispatchEvent));
v8_wrapper::Registrator< js_events_EventTarget >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_events_EventListener::static_handleEvent(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_evt = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_events_EventListener * el = dynamic_cast<js_events_EventListener *>(ptr);
el->handleEvent(val_evt);
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_events_EventListener >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("events::EventListener"));
proto->Set(v8::String::New("handleEvent"), v8::FunctionTemplate::New(js_events_EventListener::static_handleEvent));
v8_wrapper::Registrator< js_events_EventListener >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_events_Event::static_stopPropagation(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_events_Event * el = dynamic_cast<js_events_Event *>(ptr);
el->stopPropagation();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_events_Event::static_preventDefault(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_events_Event * el = dynamic_cast<js_events_Event *>(ptr);
el->preventDefault();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_events_Event::static_initEvent(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
events::DOMString val_eventTypeArg = v8_wrapper::Get< events::DOMString > ( args[0] );
bool val_canBubbleArg = v8_wrapper::Get< bool > ( args[1] );
bool val_cancelableArg = v8_wrapper::Get< bool > ( args[2] );
js_events_Event * el = dynamic_cast<js_events_Event *>(ptr);
el->initEvent(val_eventTypeArg, val_canBubbleArg, val_cancelableArg);
return scope.Close(retval);
}
Handle<Value> js_events_Event::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_events_Event, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const events::DOMString value = dynamic_cast<js_events_Event*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_events_Event::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 1>::implemented) {
v8_wrapper::CustomAttribute<js_events_Event, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_Event::static_get_target(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_events_Event, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_events_Event*>(ptr)->target;
return v8_wrapper::Set(value);
}
void js_events_Event::static_set_target(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 2>::implemented) {
v8_wrapper::CustomAttribute<js_events_Event, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_Event::static_get_currentTarget(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_events_Event, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_events_Event*>(ptr)->currentTarget;
return v8_wrapper::Set(value);
}
void js_events_Event::static_set_currentTarget(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 3>::implemented) {
v8_wrapper::CustomAttribute<js_events_Event, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_Event::static_get_eventPhase(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_events_Event, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const short unsigned int value = dynamic_cast<js_events_Event*>(ptr)->eventPhase;
return v8_wrapper::Set(value);
}
void js_events_Event::static_set_eventPhase(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 4>::implemented) {
v8_wrapper::CustomAttribute<js_events_Event, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_Event::static_get_bubbles(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_events_Event, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_events_Event*>(ptr)->bubbles;
return v8_wrapper::Set(value);
}
void js_events_Event::static_set_bubbles(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 5>::implemented) {
v8_wrapper::CustomAttribute<js_events_Event, 5>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_Event::static_get_cancelable(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_events_Event, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_events_Event*>(ptr)->cancelable;
return v8_wrapper::Set(value);
}
void js_events_Event::static_set_cancelable(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 6>::implemented) {
v8_wrapper::CustomAttribute<js_events_Event, 6>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_Event::static_get_timeStamp(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_events_Event, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_events_Event*>(ptr)->timeStamp;
return v8_wrapper::Set(value);
}
void js_events_Event::static_set_timeStamp(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_Event, 7>::implemented) {
v8_wrapper::CustomAttribute<js_events_Event, 7>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_events_Event >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("events::Event"));
proto->Set(v8::String::New("stopPropagation"), v8::FunctionTemplate::New(js_events_Event::static_stopPropagation));
proto->Set(v8::String::New("preventDefault"), v8::FunctionTemplate::New(js_events_Event::static_preventDefault));
proto->Set(v8::String::New("initEvent"), v8::FunctionTemplate::New(js_events_Event::static_initEvent));
instance->SetAccessor(v8::String::New("type"), js_events_Event::static_get_type, js_events_Event::static_set_type);
instance->SetAccessor(v8::String::New("target"), js_events_Event::static_get_target, js_events_Event::static_set_target);
instance->SetAccessor(v8::String::New("currentTarget"), js_events_Event::static_get_currentTarget, js_events_Event::static_set_currentTarget);
instance->SetAccessor(v8::String::New("eventPhase"), js_events_Event::static_get_eventPhase, js_events_Event::static_set_eventPhase);
instance->SetAccessor(v8::String::New("bubbles"), js_events_Event::static_get_bubbles, js_events_Event::static_set_bubbles);
instance->SetAccessor(v8::String::New("cancelable"), js_events_Event::static_get_cancelable, js_events_Event::static_set_cancelable);
instance->SetAccessor(v8::String::New("timeStamp"), js_events_Event::static_get_timeStamp, js_events_Event::static_set_timeStamp);
v8_wrapper::Registrator< js_events_Event >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_events_DocumentEvent::static_createEvent(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
events::DOMString val_eventType = v8_wrapper::Get< events::DOMString > ( args[0] );
js_events_DocumentEvent * el = dynamic_cast<js_events_DocumentEvent *>(ptr);
retval = v8_wrapper::Set( el->createEvent(val_eventType) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_events_DocumentEvent >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("events::DocumentEvent"));
proto->Set(v8::String::New("createEvent"), v8::FunctionTemplate::New(js_events_DocumentEvent::static_createEvent));
v8_wrapper::Registrator< js_events_DocumentEvent >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_events_UIEvent::static_initUIEvent(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
events::DOMString val_typeArg = v8_wrapper::Get< events::DOMString > ( args[0] );
bool val_canBubbleArg = v8_wrapper::Get< bool > ( args[1] );
bool val_cancelableArg = v8_wrapper::Get< bool > ( args[2] );
v8::Handle<v8::Value> val_viewArg = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[3] );
long int val_detailArg = v8_wrapper::Get< long int > ( args[4] );
js_events_UIEvent * el = dynamic_cast<js_events_UIEvent *>(ptr);
el->initUIEvent(val_typeArg, val_canBubbleArg, val_cancelableArg, val_viewArg, val_detailArg);
return scope.Close(retval);
}
Handle<Value> js_events_UIEvent::static_get_view(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_UIEvent, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_events_UIEvent, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_events_UIEvent*>(ptr)->view;
return v8_wrapper::Set(value);
}
void js_events_UIEvent::static_set_view(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_UIEvent, 1>::implemented) {
v8_wrapper::CustomAttribute<js_events_UIEvent, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_UIEvent::static_get_detail(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_UIEvent, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_events_UIEvent, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_events_UIEvent*>(ptr)->detail;
return v8_wrapper::Set(value);
}
void js_events_UIEvent::static_set_detail(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_UIEvent, 2>::implemented) {
v8_wrapper::CustomAttribute<js_events_UIEvent, 2>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_events_UIEvent >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("events::UIEvent"));
result->Inherit(v8_wrapper::Registrator< js_events_Event >::GetTemplate());
proto->Set(v8::String::New("initUIEvent"), v8::FunctionTemplate::New(js_events_UIEvent::static_initUIEvent));
instance->SetAccessor(v8::String::New("view"), js_events_UIEvent::static_get_view, js_events_UIEvent::static_set_view);
instance->SetAccessor(v8::String::New("detail"), js_events_UIEvent::static_get_detail, js_events_UIEvent::static_set_detail);
v8_wrapper::Registrator< js_events_UIEvent >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_events_MouseEvent::static_initMouseEvent(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
events::DOMString val_typeArg = v8_wrapper::Get< events::DOMString > ( args[0] );
bool val_canBubbleArg = v8_wrapper::Get< bool > ( args[1] );
bool val_cancelableArg = v8_wrapper::Get< bool > ( args[2] );
v8::Handle<v8::Value> val_viewArg = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[3] );
long int val_detailArg = v8_wrapper::Get< long int > ( args[4] );
long int val_screenXArg = v8_wrapper::Get< long int > ( args[5] );
long int val_screenYArg = v8_wrapper::Get< long int > ( args[6] );
long int val_clientXArg = v8_wrapper::Get< long int > ( args[7] );
long int val_clientYArg = v8_wrapper::Get< long int > ( args[8] );
bool val_ctrlKeyArg = v8_wrapper::Get< bool > ( args[9] );
bool val_altKeyArg = v8_wrapper::Get< bool > ( args[10] );
bool val_shiftKeyArg = v8_wrapper::Get< bool > ( args[11] );
bool val_metaKeyArg = v8_wrapper::Get< bool > ( args[12] );
short unsigned int val_buttonArg = v8_wrapper::Get< short unsigned int > ( args[13] );
v8::Handle<v8::Value> val_relatedTargetArg = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[14] );
js_events_MouseEvent * el = dynamic_cast<js_events_MouseEvent *>(ptr);
el->initMouseEvent(val_typeArg, val_canBubbleArg, val_cancelableArg, val_viewArg, val_detailArg, val_screenXArg, val_screenYArg, val_clientXArg, val_clientYArg, val_ctrlKeyArg, val_altKeyArg, val_shiftKeyArg, val_metaKeyArg, val_buttonArg, val_relatedTargetArg);
return scope.Close(retval);
}
Handle<Value> js_events_MouseEvent::static_get_screenX(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_events_MouseEvent*>(ptr)->screenX;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_screenX(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 1>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_screenY(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_events_MouseEvent*>(ptr)->screenY;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_screenY(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 2>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_clientX(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_events_MouseEvent*>(ptr)->clientX;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_clientX(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 3>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_clientY(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_events_MouseEvent*>(ptr)->clientY;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_clientY(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 4>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_ctrlKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_events_MouseEvent*>(ptr)->ctrlKey;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_ctrlKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 5>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 5>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_shiftKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_events_MouseEvent*>(ptr)->shiftKey;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_shiftKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 6>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 6>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_altKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_events_MouseEvent*>(ptr)->altKey;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_altKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 7>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 7>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_metaKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_events_MouseEvent*>(ptr)->metaKey;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_metaKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 8>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 8>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_button(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const short unsigned int value = dynamic_cast<js_events_MouseEvent*>(ptr)->button;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_button(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 9>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 9>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MouseEvent::static_get_relatedTarget(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MouseEvent, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_events_MouseEvent*>(ptr)->relatedTarget;
return v8_wrapper::Set(value);
}
void js_events_MouseEvent::static_set_relatedTarget(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MouseEvent, 10>::implemented) {
v8_wrapper::CustomAttribute<js_events_MouseEvent, 10>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_events_MouseEvent >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("events::MouseEvent"));
result->Inherit(v8_wrapper::Registrator< js_events_UIEvent >::GetTemplate());
proto->Set(v8::String::New("initMouseEvent"), v8::FunctionTemplate::New(js_events_MouseEvent::static_initMouseEvent));
instance->SetAccessor(v8::String::New("screenX"), js_events_MouseEvent::static_get_screenX, js_events_MouseEvent::static_set_screenX);
instance->SetAccessor(v8::String::New("screenY"), js_events_MouseEvent::static_get_screenY, js_events_MouseEvent::static_set_screenY);
instance->SetAccessor(v8::String::New("clientX"), js_events_MouseEvent::static_get_clientX, js_events_MouseEvent::static_set_clientX);
instance->SetAccessor(v8::String::New("clientY"), js_events_MouseEvent::static_get_clientY, js_events_MouseEvent::static_set_clientY);
instance->SetAccessor(v8::String::New("ctrlKey"), js_events_MouseEvent::static_get_ctrlKey, js_events_MouseEvent::static_set_ctrlKey);
instance->SetAccessor(v8::String::New("shiftKey"), js_events_MouseEvent::static_get_shiftKey, js_events_MouseEvent::static_set_shiftKey);
instance->SetAccessor(v8::String::New("altKey"), js_events_MouseEvent::static_get_altKey, js_events_MouseEvent::static_set_altKey);
instance->SetAccessor(v8::String::New("metaKey"), js_events_MouseEvent::static_get_metaKey, js_events_MouseEvent::static_set_metaKey);
instance->SetAccessor(v8::String::New("button"), js_events_MouseEvent::static_get_button, js_events_MouseEvent::static_set_button);
instance->SetAccessor(v8::String::New("relatedTarget"), js_events_MouseEvent::static_get_relatedTarget, js_events_MouseEvent::static_set_relatedTarget);
v8_wrapper::Registrator< js_events_MouseEvent >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_events_MutationEvent::static_initMutationEvent(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
events::DOMString val_typeArg = v8_wrapper::Get< events::DOMString > ( args[0] );
bool val_canBubbleArg = v8_wrapper::Get< bool > ( args[1] );
bool val_cancelableArg = v8_wrapper::Get< bool > ( args[2] );
v8::Handle<v8::Value> val_relatedNodeArg = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[3] );
events::DOMString val_prevValueArg = v8_wrapper::Get< events::DOMString > ( args[4] );
events::DOMString val_newValueArg = v8_wrapper::Get< events::DOMString > ( args[5] );
events::DOMString val_attrNameArg = v8_wrapper::Get< events::DOMString > ( args[6] );
short unsigned int val_attrChangeArg = v8_wrapper::Get< short unsigned int > ( args[7] );
js_events_MutationEvent * el = dynamic_cast<js_events_MutationEvent *>(ptr);
el->initMutationEvent(val_typeArg, val_canBubbleArg, val_cancelableArg, val_relatedNodeArg, val_prevValueArg, val_newValueArg, val_attrNameArg, val_attrChangeArg);
return scope.Close(retval);
}
Handle<Value> js_events_MutationEvent::static_get_relatedNode(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MutationEvent, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_events_MutationEvent*>(ptr)->relatedNode;
return v8_wrapper::Set(value);
}
void js_events_MutationEvent::static_set_relatedNode(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 1>::implemented) {
v8_wrapper::CustomAttribute<js_events_MutationEvent, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MutationEvent::static_get_prevValue(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MutationEvent, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const events::DOMString value = dynamic_cast<js_events_MutationEvent*>(ptr)->prevValue;
return v8_wrapper::Set(value);
}
void js_events_MutationEvent::static_set_prevValue(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 2>::implemented) {
v8_wrapper::CustomAttribute<js_events_MutationEvent, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MutationEvent::static_get_newValue(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MutationEvent, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const events::DOMString value = dynamic_cast<js_events_MutationEvent*>(ptr)->newValue;
return v8_wrapper::Set(value);
}
void js_events_MutationEvent::static_set_newValue(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 3>::implemented) {
v8_wrapper::CustomAttribute<js_events_MutationEvent, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MutationEvent::static_get_attrName(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MutationEvent, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const events::DOMString value = dynamic_cast<js_events_MutationEvent*>(ptr)->attrName;
return v8_wrapper::Set(value);
}
void js_events_MutationEvent::static_set_attrName(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 4>::implemented) {
v8_wrapper::CustomAttribute<js_events_MutationEvent, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_events_MutationEvent::static_get_attrChange(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_events_MutationEvent, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const short unsigned int value = dynamic_cast<js_events_MutationEvent*>(ptr)->attrChange;
return v8_wrapper::Set(value);
}
void js_events_MutationEvent::static_set_attrChange(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_events_MutationEvent, 5>::implemented) {
v8_wrapper::CustomAttribute<js_events_MutationEvent, 5>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_events_MutationEvent >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("events::MutationEvent"));
result->Inherit(v8_wrapper::Registrator< js_events_Event >::GetTemplate());
proto->Set(v8::String::New("initMutationEvent"), v8::FunctionTemplate::New(js_events_MutationEvent::static_initMutationEvent));
instance->SetAccessor(v8::String::New("relatedNode"), js_events_MutationEvent::static_get_relatedNode, js_events_MutationEvent::static_set_relatedNode);
instance->SetAccessor(v8::String::New("prevValue"), js_events_MutationEvent::static_get_prevValue, js_events_MutationEvent::static_set_prevValue);
instance->SetAccessor(v8::String::New("newValue"), js_events_MutationEvent::static_get_newValue, js_events_MutationEvent::static_set_newValue);
instance->SetAccessor(v8::String::New("attrName"), js_events_MutationEvent::static_get_attrName, js_events_MutationEvent::static_set_attrName);
instance->SetAccessor(v8::String::New("attrChange"), js_events_MutationEvent::static_get_attrChange, js_events_MutationEvent::static_set_attrChange);
v8_wrapper::Registrator< js_events_MutationEvent >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLCollection::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_html2_HTMLCollection * el = dynamic_cast<js_html2_HTMLCollection *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLCollection::static_namedItem(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
html2::DOMString val_name = v8_wrapper::Get< html2::DOMString > ( args[0] );
js_html2_HTMLCollection * el = dynamic_cast<js_html2_HTMLCollection *>(ptr);
retval = v8_wrapper::Set( el->namedItem(val_name) );
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLCollection::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLCollection, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLCollection, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_html2_HTMLCollection*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_html2_HTMLCollection::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLCollection, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLCollection, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLCollection >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLCollection"));
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_html2_HTMLCollection::static_item));
proto->Set(v8::String::New("namedItem"), v8::FunctionTemplate::New(js_html2_HTMLCollection::static_namedItem));
instance->SetAccessor(v8::String::New("length"), js_html2_HTMLCollection::static_get_length, js_html2_HTMLCollection::static_set_length);
v8_wrapper::Registrator< js_html2_HTMLCollection >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLOptionsCollection::static_item(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long unsigned int val_index = v8_wrapper::Get< long unsigned int > ( args[0] );
js_html2_HTMLOptionsCollection * el = dynamic_cast<js_html2_HTMLOptionsCollection *>(ptr);
retval = v8_wrapper::Set( el->item(val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLOptionsCollection::static_namedItem(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
html2::DOMString val_name = v8_wrapper::Get< html2::DOMString > ( args[0] );
js_html2_HTMLOptionsCollection * el = dynamic_cast<js_html2_HTMLOptionsCollection *>(ptr);
retval = v8_wrapper::Set( el->namedItem(val_name) );
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLOptionsCollection::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionsCollection, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionsCollection, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long unsigned int value = dynamic_cast<js_html2_HTMLOptionsCollection*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionsCollection::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionsCollection, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionsCollection, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOptionsCollection*>(ptr)->length = v8_wrapper::Get< long unsigned int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLOptionsCollection >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLOptionsCollection"));
proto->Set(v8::String::New("item"), v8::FunctionTemplate::New(js_html2_HTMLOptionsCollection::static_item));
proto->Set(v8::String::New("namedItem"), v8::FunctionTemplate::New(js_html2_HTMLOptionsCollection::static_namedItem));
instance->SetAccessor(v8::String::New("length"), js_html2_HTMLOptionsCollection::static_get_length, js_html2_HTMLOptionsCollection::static_set_length);
v8_wrapper::Registrator< js_html2_HTMLOptionsCollection >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLDocument::static_open(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLDocument * el = dynamic_cast<js_html2_HTMLDocument *>(ptr);
el->open();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLDocument::static_close(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLDocument * el = dynamic_cast<js_html2_HTMLDocument *>(ptr);
el->close();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLDocument::static_write(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
html2::DOMString val_text = v8_wrapper::Get< html2::DOMString > ( args[0] );
js_html2_HTMLDocument * el = dynamic_cast<js_html2_HTMLDocument *>(ptr);
el->write(val_text);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLDocument::static_writeln(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
html2::DOMString val_text = v8_wrapper::Get< html2::DOMString > ( args[0] );
js_html2_HTMLDocument * el = dynamic_cast<js_html2_HTMLDocument *>(ptr);
el->writeln(val_text);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLDocument::static_getElementsByName(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
html2::DOMString val_elementName = v8_wrapper::Get< html2::DOMString > ( args[0] );
js_html2_HTMLDocument * el = dynamic_cast<js_html2_HTMLDocument *>(ptr);
retval = v8_wrapper::Set( el->getElementsByName(val_elementName) );
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLDocument::static_get_title(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->title;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_title(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLDocument*>(ptr)->title = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLDocument::static_get_referrer(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const html2::DOMString value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->referrer;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_referrer(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLDocument::static_get_domain(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const html2::DOMString value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->domain;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_domain(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLDocument::static_get_URL(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const html2::DOMString value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->URL;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_URL(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLDocument::static_get_body(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->body;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_body(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLDocument*>(ptr)->body = v8_wrapper::Get< v8::Handle<v8::Value> >(value);
}
Handle<Value> js_html2_HTMLDocument::static_get_images(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->images;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_images(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 6>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLDocument::static_get_applets(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->applets;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_applets(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 7>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLDocument::static_get_links(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->links;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_links(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 8>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLDocument::static_get_forms(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->forms;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_forms(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 9>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLDocument::static_get_anchors(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->anchors;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_anchors(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 10>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLDocument::static_get_cookie(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->cookie;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_cookie(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLDocument*>(ptr)->cookie = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLDocument::static_get_innerHTML(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLDocument*>(ptr)->innerHTML;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDocument::static_set_innerHTML(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 12>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDocument, 12>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLDocument*>(ptr)->innerHTML = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLDocument >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLDocument"));
result->Inherit(v8_wrapper::Registrator< js_dom_Document >::GetTemplate());
proto->Set(v8::String::New("open"), v8::FunctionTemplate::New(js_html2_HTMLDocument::static_open));
proto->Set(v8::String::New("close"), v8::FunctionTemplate::New(js_html2_HTMLDocument::static_close));
proto->Set(v8::String::New("write"), v8::FunctionTemplate::New(js_html2_HTMLDocument::static_write));
proto->Set(v8::String::New("writeln"), v8::FunctionTemplate::New(js_html2_HTMLDocument::static_writeln));
proto->Set(v8::String::New("getElementsByName"), v8::FunctionTemplate::New(js_html2_HTMLDocument::static_getElementsByName));
instance->SetAccessor(v8::String::New("title"), js_html2_HTMLDocument::static_get_title, js_html2_HTMLDocument::static_set_title);
instance->SetAccessor(v8::String::New("referrer"), js_html2_HTMLDocument::static_get_referrer, js_html2_HTMLDocument::static_set_referrer);
instance->SetAccessor(v8::String::New("domain"), js_html2_HTMLDocument::static_get_domain, js_html2_HTMLDocument::static_set_domain);
instance->SetAccessor(v8::String::New("URL"), js_html2_HTMLDocument::static_get_URL, js_html2_HTMLDocument::static_set_URL);
instance->SetAccessor(v8::String::New("body"), js_html2_HTMLDocument::static_get_body, js_html2_HTMLDocument::static_set_body);
instance->SetAccessor(v8::String::New("images"), js_html2_HTMLDocument::static_get_images, js_html2_HTMLDocument::static_set_images);
instance->SetAccessor(v8::String::New("applets"), js_html2_HTMLDocument::static_get_applets, js_html2_HTMLDocument::static_set_applets);
instance->SetAccessor(v8::String::New("links"), js_html2_HTMLDocument::static_get_links, js_html2_HTMLDocument::static_set_links);
instance->SetAccessor(v8::String::New("forms"), js_html2_HTMLDocument::static_get_forms, js_html2_HTMLDocument::static_set_forms);
instance->SetAccessor(v8::String::New("anchors"), js_html2_HTMLDocument::static_get_anchors, js_html2_HTMLDocument::static_set_anchors);
instance->SetAccessor(v8::String::New("cookie"), js_html2_HTMLDocument::static_get_cookie, js_html2_HTMLDocument::static_set_cookie);
instance->SetAccessor(v8::String::New("innerHTML"), js_html2_HTMLDocument::static_get_innerHTML, js_html2_HTMLDocument::static_set_innerHTML);
v8_wrapper::Registrator< js_html2_HTMLDocument >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLElement::static_get_id(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLElement*>(ptr)->id;
return v8_wrapper::Set(value);
}
void js_html2_HTMLElement::static_set_id(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLElement*>(ptr)->id = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLElement::static_get_title(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLElement*>(ptr)->title;
return v8_wrapper::Set(value);
}
void js_html2_HTMLElement::static_set_title(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLElement*>(ptr)->title = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLElement::static_get_lang(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLElement*>(ptr)->lang;
return v8_wrapper::Set(value);
}
void js_html2_HTMLElement::static_set_lang(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLElement*>(ptr)->lang = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLElement::static_get_dir(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLElement*>(ptr)->dir;
return v8_wrapper::Set(value);
}
void js_html2_HTMLElement::static_set_dir(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLElement*>(ptr)->dir = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLElement::static_get_className(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLElement*>(ptr)->className;
return v8_wrapper::Set(value);
}
void js_html2_HTMLElement::static_set_className(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLElement*>(ptr)->className = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLElement::static_get_style(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLElement*>(ptr)->style;
return v8_wrapper::Set(value);
}
void js_html2_HTMLElement::static_set_style(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLElement*>(ptr)->style = v8_wrapper::Get< v8::Handle<v8::Value> >(value);
}
Handle<Value> js_html2_HTMLElement::static_get_innerHTML(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLElement*>(ptr)->innerHTML;
return v8_wrapper::Set(value);
}
void js_html2_HTMLElement::static_set_innerHTML(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLElement*>(ptr)->innerHTML = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLElement"));
result->Inherit(v8_wrapper::Registrator< js_dom_Element >::GetTemplate());
instance->SetAccessor(v8::String::New("id"), js_html2_HTMLElement::static_get_id, js_html2_HTMLElement::static_set_id);
instance->SetAccessor(v8::String::New("title"), js_html2_HTMLElement::static_get_title, js_html2_HTMLElement::static_set_title);
instance->SetAccessor(v8::String::New("lang"), js_html2_HTMLElement::static_get_lang, js_html2_HTMLElement::static_set_lang);
instance->SetAccessor(v8::String::New("dir"), js_html2_HTMLElement::static_get_dir, js_html2_HTMLElement::static_set_dir);
instance->SetAccessor(v8::String::New("className"), js_html2_HTMLElement::static_get_className, js_html2_HTMLElement::static_set_className);
instance->SetAccessor(v8::String::New("style"), js_html2_HTMLElement::static_get_style, js_html2_HTMLElement::static_set_style);
instance->SetAccessor(v8::String::New("innerHTML"), js_html2_HTMLElement::static_get_innerHTML, js_html2_HTMLElement::static_set_innerHTML);
v8_wrapper::Registrator< js_html2_HTMLElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLHtmlElement::static_get_version(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHtmlElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLHtmlElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLHtmlElement*>(ptr)->version;
return v8_wrapper::Set(value);
}
void js_html2_HTMLHtmlElement::static_set_version(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHtmlElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLHtmlElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLHtmlElement*>(ptr)->version = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLHtmlElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLHtmlElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("version"), js_html2_HTMLHtmlElement::static_get_version, js_html2_HTMLHtmlElement::static_set_version);
v8_wrapper::Registrator< js_html2_HTMLHtmlElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLHeadElement::static_get_profile(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHeadElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLHeadElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLHeadElement*>(ptr)->profile;
return v8_wrapper::Set(value);
}
void js_html2_HTMLHeadElement::static_set_profile(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHeadElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLHeadElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLHeadElement*>(ptr)->profile = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLHeadElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLHeadElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("profile"), js_html2_HTMLHeadElement::static_get_profile, js_html2_HTMLHeadElement::static_set_profile);
v8_wrapper::Registrator< js_html2_HTMLHeadElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLLinkElement::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLLinkElement::static_get_charset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->charset;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_charset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->charset = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLinkElement::static_get_href(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->href;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_href(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->href = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLinkElement::static_get_hreflang(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->hreflang;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_hreflang(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->hreflang = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLinkElement::static_get_media(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->media;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_media(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->media = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLinkElement::static_get_rel(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->rel;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_rel(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->rel = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLinkElement::static_get_rev(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->rev;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_rev(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->rev = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLinkElement::static_get_target(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->target;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_target(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->target = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLinkElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLinkElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLinkElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLinkElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLLinkElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLLinkElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("disabled"), js_html2_HTMLLinkElement::static_get_disabled, js_html2_HTMLLinkElement::static_set_disabled);
instance->SetAccessor(v8::String::New("charset"), js_html2_HTMLLinkElement::static_get_charset, js_html2_HTMLLinkElement::static_set_charset);
instance->SetAccessor(v8::String::New("href"), js_html2_HTMLLinkElement::static_get_href, js_html2_HTMLLinkElement::static_set_href);
instance->SetAccessor(v8::String::New("hreflang"), js_html2_HTMLLinkElement::static_get_hreflang, js_html2_HTMLLinkElement::static_set_hreflang);
instance->SetAccessor(v8::String::New("media"), js_html2_HTMLLinkElement::static_get_media, js_html2_HTMLLinkElement::static_set_media);
instance->SetAccessor(v8::String::New("rel"), js_html2_HTMLLinkElement::static_get_rel, js_html2_HTMLLinkElement::static_set_rel);
instance->SetAccessor(v8::String::New("rev"), js_html2_HTMLLinkElement::static_get_rev, js_html2_HTMLLinkElement::static_set_rev);
instance->SetAccessor(v8::String::New("target"), js_html2_HTMLLinkElement::static_get_target, js_html2_HTMLLinkElement::static_set_target);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLLinkElement::static_get_type, js_html2_HTMLLinkElement::static_set_type);
v8_wrapper::Registrator< js_html2_HTMLLinkElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLTitleElement::static_get_text(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTitleElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTitleElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTitleElement*>(ptr)->text;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTitleElement::static_set_text(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTitleElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTitleElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTitleElement*>(ptr)->text = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLTitleElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLTitleElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("text"), js_html2_HTMLTitleElement::static_get_text, js_html2_HTMLTitleElement::static_set_text);
v8_wrapper::Registrator< js_html2_HTMLTitleElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLMetaElement::static_get_content(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLMetaElement*>(ptr)->content;
return v8_wrapper::Set(value);
}
void js_html2_HTMLMetaElement::static_set_content(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLMetaElement*>(ptr)->content = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLMetaElement::static_get_httpEquiv(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLMetaElement*>(ptr)->httpEquiv;
return v8_wrapper::Set(value);
}
void js_html2_HTMLMetaElement::static_set_httpEquiv(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLMetaElement*>(ptr)->httpEquiv = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLMetaElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLMetaElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLMetaElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLMetaElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLMetaElement::static_get_scheme(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLMetaElement*>(ptr)->scheme;
return v8_wrapper::Set(value);
}
void js_html2_HTMLMetaElement::static_set_scheme(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLMetaElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLMetaElement*>(ptr)->scheme = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLMetaElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLMetaElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("content"), js_html2_HTMLMetaElement::static_get_content, js_html2_HTMLMetaElement::static_set_content);
instance->SetAccessor(v8::String::New("httpEquiv"), js_html2_HTMLMetaElement::static_get_httpEquiv, js_html2_HTMLMetaElement::static_set_httpEquiv);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLMetaElement::static_get_name, js_html2_HTMLMetaElement::static_set_name);
instance->SetAccessor(v8::String::New("scheme"), js_html2_HTMLMetaElement::static_get_scheme, js_html2_HTMLMetaElement::static_set_scheme);
v8_wrapper::Registrator< js_html2_HTMLMetaElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLBaseElement::static_get_href(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBaseElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBaseElement*>(ptr)->href;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBaseElement::static_set_href(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBaseElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBaseElement*>(ptr)->href = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLBaseElement::static_get_target(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBaseElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBaseElement*>(ptr)->target;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBaseElement::static_set_target(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBaseElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBaseElement*>(ptr)->target = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLBaseElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLBaseElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("href"), js_html2_HTMLBaseElement::static_get_href, js_html2_HTMLBaseElement::static_set_href);
instance->SetAccessor(v8::String::New("target"), js_html2_HTMLBaseElement::static_get_target, js_html2_HTMLBaseElement::static_set_target);
v8_wrapper::Registrator< js_html2_HTMLBaseElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLIsIndexElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIsIndexElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIsIndexElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLIsIndexElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIsIndexElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIsIndexElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIsIndexElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLIsIndexElement::static_get_prompt(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIsIndexElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIsIndexElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIsIndexElement*>(ptr)->prompt;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIsIndexElement::static_set_prompt(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIsIndexElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIsIndexElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIsIndexElement*>(ptr)->prompt = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLIsIndexElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLIsIndexElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLIsIndexElement::static_get_form, js_html2_HTMLIsIndexElement::static_set_form);
instance->SetAccessor(v8::String::New("prompt"), js_html2_HTMLIsIndexElement::static_get_prompt, js_html2_HTMLIsIndexElement::static_set_prompt);
v8_wrapper::Registrator< js_html2_HTMLIsIndexElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLStyleElement::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLStyleElement*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_html2_HTMLStyleElement::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLStyleElement*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLStyleElement::static_get_media(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLStyleElement*>(ptr)->media;
return v8_wrapper::Set(value);
}
void js_html2_HTMLStyleElement::static_set_media(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLStyleElement*>(ptr)->media = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLStyleElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLStyleElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLStyleElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLStyleElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLStyleElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLStyleElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLStyleElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("disabled"), js_html2_HTMLStyleElement::static_get_disabled, js_html2_HTMLStyleElement::static_set_disabled);
instance->SetAccessor(v8::String::New("media"), js_html2_HTMLStyleElement::static_get_media, js_html2_HTMLStyleElement::static_set_media);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLStyleElement::static_get_type, js_html2_HTMLStyleElement::static_set_type);
v8_wrapper::Registrator< js_html2_HTMLStyleElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLBodyElement::static_get_aLink(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->aLink;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBodyElement::static_set_aLink(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->aLink = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLBodyElement::static_get_background(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->background;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBodyElement::static_set_background(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->background = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLBodyElement::static_get_bgColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->bgColor;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBodyElement::static_set_bgColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->bgColor = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLBodyElement::static_get_link(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->link;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBodyElement::static_set_link(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->link = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLBodyElement::static_get_text(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->text;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBodyElement::static_set_text(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->text = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLBodyElement::static_get_vLink(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->vLink;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBodyElement::static_set_vLink(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBodyElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBodyElement*>(ptr)->vLink = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLBodyElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLBodyElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("aLink"), js_html2_HTMLBodyElement::static_get_aLink, js_html2_HTMLBodyElement::static_set_aLink);
instance->SetAccessor(v8::String::New("background"), js_html2_HTMLBodyElement::static_get_background, js_html2_HTMLBodyElement::static_set_background);
instance->SetAccessor(v8::String::New("bgColor"), js_html2_HTMLBodyElement::static_get_bgColor, js_html2_HTMLBodyElement::static_set_bgColor);
instance->SetAccessor(v8::String::New("link"), js_html2_HTMLBodyElement::static_get_link, js_html2_HTMLBodyElement::static_set_link);
instance->SetAccessor(v8::String::New("text"), js_html2_HTMLBodyElement::static_get_text, js_html2_HTMLBodyElement::static_set_text);
instance->SetAccessor(v8::String::New("vLink"), js_html2_HTMLBodyElement::static_get_vLink, js_html2_HTMLBodyElement::static_set_vLink);
v8_wrapper::Registrator< js_html2_HTMLBodyElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLFormElement::static_submit(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLFormElement * el = dynamic_cast<js_html2_HTMLFormElement *>(ptr);
el->submit();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLFormElement::static_reset(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLFormElement * el = dynamic_cast<js_html2_HTMLFormElement *>(ptr);
el->reset();
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLFormElement::static_get_elements(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLFormElement*>(ptr)->elements;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFormElement::static_set_elements(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLFormElement::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_html2_HTMLFormElement*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFormElement::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLFormElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFormElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFormElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFormElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFormElement::static_get_acceptCharset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFormElement*>(ptr)->acceptCharset;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFormElement::static_set_acceptCharset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFormElement*>(ptr)->acceptCharset = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFormElement::static_get_action(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFormElement*>(ptr)->action;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFormElement::static_set_action(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFormElement*>(ptr)->action = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFormElement::static_get_enctype(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFormElement*>(ptr)->enctype;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFormElement::static_set_enctype(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFormElement*>(ptr)->enctype = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFormElement::static_get_method(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFormElement*>(ptr)->method;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFormElement::static_set_method(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFormElement*>(ptr)->method = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFormElement::static_get_target(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFormElement*>(ptr)->target;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFormElement::static_set_target(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFormElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFormElement*>(ptr)->target = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLFormElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLFormElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
proto->Set(v8::String::New("submit"), v8::FunctionTemplate::New(js_html2_HTMLFormElement::static_submit));
proto->Set(v8::String::New("reset"), v8::FunctionTemplate::New(js_html2_HTMLFormElement::static_reset));
instance->SetAccessor(v8::String::New("elements"), js_html2_HTMLFormElement::static_get_elements, js_html2_HTMLFormElement::static_set_elements);
instance->SetAccessor(v8::String::New("length"), js_html2_HTMLFormElement::static_get_length, js_html2_HTMLFormElement::static_set_length);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLFormElement::static_get_name, js_html2_HTMLFormElement::static_set_name);
instance->SetAccessor(v8::String::New("acceptCharset"), js_html2_HTMLFormElement::static_get_acceptCharset, js_html2_HTMLFormElement::static_set_acceptCharset);
instance->SetAccessor(v8::String::New("action"), js_html2_HTMLFormElement::static_get_action, js_html2_HTMLFormElement::static_set_action);
instance->SetAccessor(v8::String::New("enctype"), js_html2_HTMLFormElement::static_get_enctype, js_html2_HTMLFormElement::static_set_enctype);
instance->SetAccessor(v8::String::New("method"), js_html2_HTMLFormElement::static_get_method, js_html2_HTMLFormElement::static_set_method);
instance->SetAccessor(v8::String::New("target"), js_html2_HTMLFormElement::static_get_target, js_html2_HTMLFormElement::static_set_target);
v8_wrapper::Registrator< js_html2_HTMLFormElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLSelectElement::static_add(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_element = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
v8::Handle<v8::Value> val_before = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[1] );
js_html2_HTMLSelectElement * el = dynamic_cast<js_html2_HTMLSelectElement *>(ptr);
el->add(val_element, val_before);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLSelectElement::static_remove(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long int val_index = v8_wrapper::Get< long int > ( args[0] );
js_html2_HTMLSelectElement * el = dynamic_cast<js_html2_HTMLSelectElement *>(ptr);
el->remove(val_index);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLSelectElement::static_blur(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLSelectElement * el = dynamic_cast<js_html2_HTMLSelectElement *>(ptr);
el->blur();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLSelectElement::static_focus(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLSelectElement * el = dynamic_cast<js_html2_HTMLSelectElement *>(ptr);
el->focus();
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLSelectElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const html2::DOMString value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLSelectElement::static_get_selectedIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->selectedIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_selectedIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->selectedIndex = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLSelectElement::static_get_value(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->value;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_value(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->value = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLSelectElement::static_get_length(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long unsigned int value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->length;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_length(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->length = v8_wrapper::Get< long unsigned int >(value);
}
Handle<Value> js_html2_HTMLSelectElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 5>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLSelectElement::static_get_options(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->options;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_options(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 6>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLSelectElement::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLSelectElement::static_get_multiple(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->multiple;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_multiple(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->multiple = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLSelectElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLSelectElement::static_get_size(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->size;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_size(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->size = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLSelectElement::static_get_tabIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->tabIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLSelectElement::static_set_tabIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLSelectElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLSelectElement*>(ptr)->tabIndex = v8_wrapper::Get< long int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLSelectElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLSelectElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
proto->Set(v8::String::New("add"), v8::FunctionTemplate::New(js_html2_HTMLSelectElement::static_add));
proto->Set(v8::String::New("remove"), v8::FunctionTemplate::New(js_html2_HTMLSelectElement::static_remove));
proto->Set(v8::String::New("blur"), v8::FunctionTemplate::New(js_html2_HTMLSelectElement::static_blur));
proto->Set(v8::String::New("focus"), v8::FunctionTemplate::New(js_html2_HTMLSelectElement::static_focus));
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLSelectElement::static_get_type, js_html2_HTMLSelectElement::static_set_type);
instance->SetAccessor(v8::String::New("selectedIndex"), js_html2_HTMLSelectElement::static_get_selectedIndex, js_html2_HTMLSelectElement::static_set_selectedIndex);
instance->SetAccessor(v8::String::New("value"), js_html2_HTMLSelectElement::static_get_value, js_html2_HTMLSelectElement::static_set_value);
instance->SetAccessor(v8::String::New("length"), js_html2_HTMLSelectElement::static_get_length, js_html2_HTMLSelectElement::static_set_length);
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLSelectElement::static_get_form, js_html2_HTMLSelectElement::static_set_form);
instance->SetAccessor(v8::String::New("options"), js_html2_HTMLSelectElement::static_get_options, js_html2_HTMLSelectElement::static_set_options);
instance->SetAccessor(v8::String::New("disabled"), js_html2_HTMLSelectElement::static_get_disabled, js_html2_HTMLSelectElement::static_set_disabled);
instance->SetAccessor(v8::String::New("multiple"), js_html2_HTMLSelectElement::static_get_multiple, js_html2_HTMLSelectElement::static_set_multiple);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLSelectElement::static_get_name, js_html2_HTMLSelectElement::static_set_name);
instance->SetAccessor(v8::String::New("size"), js_html2_HTMLSelectElement::static_get_size, js_html2_HTMLSelectElement::static_set_size);
instance->SetAccessor(v8::String::New("tabIndex"), js_html2_HTMLSelectElement::static_get_tabIndex, js_html2_HTMLSelectElement::static_set_tabIndex);
v8_wrapper::Registrator< js_html2_HTMLSelectElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLOptGroupElement::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptGroupElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptGroupElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLOptGroupElement*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptGroupElement::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptGroupElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptGroupElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOptGroupElement*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLOptGroupElement::static_get_label(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptGroupElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptGroupElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLOptGroupElement*>(ptr)->label;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptGroupElement::static_set_label(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptGroupElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptGroupElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOptGroupElement*>(ptr)->label = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLOptGroupElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLOptGroupElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("disabled"), js_html2_HTMLOptGroupElement::static_get_disabled, js_html2_HTMLOptGroupElement::static_set_disabled);
instance->SetAccessor(v8::String::New("label"), js_html2_HTMLOptGroupElement::static_get_label, js_html2_HTMLOptGroupElement::static_set_label);
v8_wrapper::Registrator< js_html2_HTMLOptGroupElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLOptionElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLOptionElement::static_get_defaultSelected(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->defaultSelected;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionElement::static_set_defaultSelected(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->defaultSelected = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLOptionElement::static_get_text(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const html2::DOMString value = dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->text;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionElement::static_set_text(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLOptionElement::static_get_index(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->index;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionElement::static_set_index(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLOptionElement::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionElement::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLOptionElement::static_get_label(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->label;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionElement::static_set_label(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->label = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLOptionElement::static_get_selected(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->selected;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionElement::static_set_selected(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->selected = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLOptionElement::static_get_value(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->value;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOptionElement::static_set_value(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOptionElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOptionElement*>(ptr)->value = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLOptionElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLOptionElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLOptionElement::static_get_form, js_html2_HTMLOptionElement::static_set_form);
instance->SetAccessor(v8::String::New("defaultSelected"), js_html2_HTMLOptionElement::static_get_defaultSelected, js_html2_HTMLOptionElement::static_set_defaultSelected);
instance->SetAccessor(v8::String::New("text"), js_html2_HTMLOptionElement::static_get_text, js_html2_HTMLOptionElement::static_set_text);
instance->SetAccessor(v8::String::New("index"), js_html2_HTMLOptionElement::static_get_index, js_html2_HTMLOptionElement::static_set_index);
instance->SetAccessor(v8::String::New("disabled"), js_html2_HTMLOptionElement::static_get_disabled, js_html2_HTMLOptionElement::static_set_disabled);
instance->SetAccessor(v8::String::New("label"), js_html2_HTMLOptionElement::static_get_label, js_html2_HTMLOptionElement::static_set_label);
instance->SetAccessor(v8::String::New("selected"), js_html2_HTMLOptionElement::static_get_selected, js_html2_HTMLOptionElement::static_set_selected);
instance->SetAccessor(v8::String::New("value"), js_html2_HTMLOptionElement::static_get_value, js_html2_HTMLOptionElement::static_set_value);
v8_wrapper::Registrator< js_html2_HTMLOptionElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLInputElement::static_blur(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLInputElement * el = dynamic_cast<js_html2_HTMLInputElement *>(ptr);
el->blur();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLInputElement::static_focus(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLInputElement * el = dynamic_cast<js_html2_HTMLInputElement *>(ptr);
el->focus();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLInputElement::static_select(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLInputElement * el = dynamic_cast<js_html2_HTMLInputElement *>(ptr);
el->select();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLInputElement::static_click(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLInputElement * el = dynamic_cast<js_html2_HTMLInputElement *>(ptr);
el->click();
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLInputElement::static_get_defaultValue(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->defaultValue;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_defaultValue(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->defaultValue = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_defaultChecked(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->defaultChecked;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_defaultChecked(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->defaultChecked = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLInputElement::static_get_accept(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->accept;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_accept(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->accept = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_accessKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->accessKey;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_accessKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->accessKey = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_alt(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->alt;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_alt(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->alt = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_checked(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->checked;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_checked(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->checked = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_maxLength(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->maxLength;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_maxLength(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->maxLength = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_readOnly(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->readOnly;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_readOnly(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 12>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 12>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->readOnly = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_size(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 13>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 13>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long unsigned int value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->size;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_size(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 13>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 13>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->size = v8_wrapper::Get< long unsigned int >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_src(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 14>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 14>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->src;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_src(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 14>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 14>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->src = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_tabIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 15>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 15>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->tabIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_tabIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 15>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 15>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->tabIndex = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 16>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 16>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 16>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 16>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_useMap(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 17>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 17>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->useMap;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_useMap(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 17>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 17>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->useMap = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLInputElement::static_get_value(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 18>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 18>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLInputElement*>(ptr)->value;
return v8_wrapper::Set(value);
}
void js_html2_HTMLInputElement::static_set_value(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 18>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLInputElement, 18>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLInputElement*>(ptr)->value = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLInputElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLInputElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
proto->Set(v8::String::New("blur"), v8::FunctionTemplate::New(js_html2_HTMLInputElement::static_blur));
proto->Set(v8::String::New("focus"), v8::FunctionTemplate::New(js_html2_HTMLInputElement::static_focus));
proto->Set(v8::String::New("select"), v8::FunctionTemplate::New(js_html2_HTMLInputElement::static_select));
proto->Set(v8::String::New("click"), v8::FunctionTemplate::New(js_html2_HTMLInputElement::static_click));
instance->SetAccessor(v8::String::New("defaultValue"), js_html2_HTMLInputElement::static_get_defaultValue, js_html2_HTMLInputElement::static_set_defaultValue);
instance->SetAccessor(v8::String::New("defaultChecked"), js_html2_HTMLInputElement::static_get_defaultChecked, js_html2_HTMLInputElement::static_set_defaultChecked);
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLInputElement::static_get_form, js_html2_HTMLInputElement::static_set_form);
instance->SetAccessor(v8::String::New("accept"), js_html2_HTMLInputElement::static_get_accept, js_html2_HTMLInputElement::static_set_accept);
instance->SetAccessor(v8::String::New("accessKey"), js_html2_HTMLInputElement::static_get_accessKey, js_html2_HTMLInputElement::static_set_accessKey);
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLInputElement::static_get_align, js_html2_HTMLInputElement::static_set_align);
instance->SetAccessor(v8::String::New("alt"), js_html2_HTMLInputElement::static_get_alt, js_html2_HTMLInputElement::static_set_alt);
instance->SetAccessor(v8::String::New("checked"), js_html2_HTMLInputElement::static_get_checked, js_html2_HTMLInputElement::static_set_checked);
instance->SetAccessor(v8::String::New("disabled"), js_html2_HTMLInputElement::static_get_disabled, js_html2_HTMLInputElement::static_set_disabled);
instance->SetAccessor(v8::String::New("maxLength"), js_html2_HTMLInputElement::static_get_maxLength, js_html2_HTMLInputElement::static_set_maxLength);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLInputElement::static_get_name, js_html2_HTMLInputElement::static_set_name);
instance->SetAccessor(v8::String::New("readOnly"), js_html2_HTMLInputElement::static_get_readOnly, js_html2_HTMLInputElement::static_set_readOnly);
instance->SetAccessor(v8::String::New("size"), js_html2_HTMLInputElement::static_get_size, js_html2_HTMLInputElement::static_set_size);
instance->SetAccessor(v8::String::New("src"), js_html2_HTMLInputElement::static_get_src, js_html2_HTMLInputElement::static_set_src);
instance->SetAccessor(v8::String::New("tabIndex"), js_html2_HTMLInputElement::static_get_tabIndex, js_html2_HTMLInputElement::static_set_tabIndex);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLInputElement::static_get_type, js_html2_HTMLInputElement::static_set_type);
instance->SetAccessor(v8::String::New("useMap"), js_html2_HTMLInputElement::static_get_useMap, js_html2_HTMLInputElement::static_set_useMap);
instance->SetAccessor(v8::String::New("value"), js_html2_HTMLInputElement::static_get_value, js_html2_HTMLInputElement::static_set_value);
v8_wrapper::Registrator< js_html2_HTMLInputElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLTextAreaElement::static_blur(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTextAreaElement * el = dynamic_cast<js_html2_HTMLTextAreaElement *>(ptr);
el->blur();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTextAreaElement::static_focus(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTextAreaElement * el = dynamic_cast<js_html2_HTMLTextAreaElement *>(ptr);
el->focus();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTextAreaElement::static_select(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTextAreaElement * el = dynamic_cast<js_html2_HTMLTextAreaElement *>(ptr);
el->select();
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_defaultValue(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->defaultValue;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_defaultValue(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->defaultValue = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_accessKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->accessKey;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_accessKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->accessKey = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_cols(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->cols;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_cols(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->cols = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_readOnly(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->readOnly;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_readOnly(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->readOnly = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_rows(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->rows;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_rows(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->rows = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_tabIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->tabIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_tabIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->tabIndex = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const html2::DOMString value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 10>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLTextAreaElement::static_get_value(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->value;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTextAreaElement::static_set_value(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTextAreaElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTextAreaElement*>(ptr)->value = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLTextAreaElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLTextAreaElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
proto->Set(v8::String::New("blur"), v8::FunctionTemplate::New(js_html2_HTMLTextAreaElement::static_blur));
proto->Set(v8::String::New("focus"), v8::FunctionTemplate::New(js_html2_HTMLTextAreaElement::static_focus));
proto->Set(v8::String::New("select"), v8::FunctionTemplate::New(js_html2_HTMLTextAreaElement::static_select));
instance->SetAccessor(v8::String::New("defaultValue"), js_html2_HTMLTextAreaElement::static_get_defaultValue, js_html2_HTMLTextAreaElement::static_set_defaultValue);
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLTextAreaElement::static_get_form, js_html2_HTMLTextAreaElement::static_set_form);
instance->SetAccessor(v8::String::New("accessKey"), js_html2_HTMLTextAreaElement::static_get_accessKey, js_html2_HTMLTextAreaElement::static_set_accessKey);
instance->SetAccessor(v8::String::New("cols"), js_html2_HTMLTextAreaElement::static_get_cols, js_html2_HTMLTextAreaElement::static_set_cols);
instance->SetAccessor(v8::String::New("disabled"), js_html2_HTMLTextAreaElement::static_get_disabled, js_html2_HTMLTextAreaElement::static_set_disabled);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLTextAreaElement::static_get_name, js_html2_HTMLTextAreaElement::static_set_name);
instance->SetAccessor(v8::String::New("readOnly"), js_html2_HTMLTextAreaElement::static_get_readOnly, js_html2_HTMLTextAreaElement::static_set_readOnly);
instance->SetAccessor(v8::String::New("rows"), js_html2_HTMLTextAreaElement::static_get_rows, js_html2_HTMLTextAreaElement::static_set_rows);
instance->SetAccessor(v8::String::New("tabIndex"), js_html2_HTMLTextAreaElement::static_get_tabIndex, js_html2_HTMLTextAreaElement::static_set_tabIndex);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLTextAreaElement::static_get_type, js_html2_HTMLTextAreaElement::static_set_type);
instance->SetAccessor(v8::String::New("value"), js_html2_HTMLTextAreaElement::static_get_value, js_html2_HTMLTextAreaElement::static_set_value);
v8_wrapper::Registrator< js_html2_HTMLTextAreaElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLButtonElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLButtonElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLButtonElement::static_get_accessKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->accessKey;
return v8_wrapper::Set(value);
}
void js_html2_HTMLButtonElement::static_set_accessKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->accessKey = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLButtonElement::static_get_disabled(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->disabled;
return v8_wrapper::Set(value);
}
void js_html2_HTMLButtonElement::static_set_disabled(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->disabled = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLButtonElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLButtonElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLButtonElement::static_get_tabIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->tabIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLButtonElement::static_set_tabIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->tabIndex = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLButtonElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const html2::DOMString value = dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLButtonElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 6>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLButtonElement::static_get_value(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->value;
return v8_wrapper::Set(value);
}
void js_html2_HTMLButtonElement::static_set_value(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLButtonElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLButtonElement*>(ptr)->value = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLButtonElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLButtonElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLButtonElement::static_get_form, js_html2_HTMLButtonElement::static_set_form);
instance->SetAccessor(v8::String::New("accessKey"), js_html2_HTMLButtonElement::static_get_accessKey, js_html2_HTMLButtonElement::static_set_accessKey);
instance->SetAccessor(v8::String::New("disabled"), js_html2_HTMLButtonElement::static_get_disabled, js_html2_HTMLButtonElement::static_set_disabled);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLButtonElement::static_get_name, js_html2_HTMLButtonElement::static_set_name);
instance->SetAccessor(v8::String::New("tabIndex"), js_html2_HTMLButtonElement::static_get_tabIndex, js_html2_HTMLButtonElement::static_set_tabIndex);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLButtonElement::static_get_type, js_html2_HTMLButtonElement::static_set_type);
instance->SetAccessor(v8::String::New("value"), js_html2_HTMLButtonElement::static_get_value, js_html2_HTMLButtonElement::static_set_value);
v8_wrapper::Registrator< js_html2_HTMLButtonElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLLabelElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLLabelElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLabelElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLLabelElement::static_get_accessKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLabelElement*>(ptr)->accessKey;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLabelElement::static_set_accessKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLabelElement*>(ptr)->accessKey = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLabelElement::static_get_htmlFor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLabelElement*>(ptr)->htmlFor;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLabelElement::static_set_htmlFor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLabelElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLabelElement*>(ptr)->htmlFor = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLLabelElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLLabelElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLLabelElement::static_get_form, js_html2_HTMLLabelElement::static_set_form);
instance->SetAccessor(v8::String::New("accessKey"), js_html2_HTMLLabelElement::static_get_accessKey, js_html2_HTMLLabelElement::static_set_accessKey);
instance->SetAccessor(v8::String::New("htmlFor"), js_html2_HTMLLabelElement::static_get_htmlFor, js_html2_HTMLLabelElement::static_set_htmlFor);
v8_wrapper::Registrator< js_html2_HTMLLabelElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLFieldSetElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFieldSetElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFieldSetElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLFieldSetElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFieldSetElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFieldSetElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFieldSetElement, 1>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLFieldSetElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLFieldSetElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLFieldSetElement::static_get_form, js_html2_HTMLFieldSetElement::static_set_form);
v8_wrapper::Registrator< js_html2_HTMLFieldSetElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLLegendElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLLegendElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLegendElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLLegendElement::static_get_accessKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLegendElement*>(ptr)->accessKey;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLegendElement::static_set_accessKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLegendElement*>(ptr)->accessKey = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLegendElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLegendElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLegendElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLegendElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLegendElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLLegendElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLLegendElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLLegendElement::static_get_form, js_html2_HTMLLegendElement::static_set_form);
instance->SetAccessor(v8::String::New("accessKey"), js_html2_HTMLLegendElement::static_get_accessKey, js_html2_HTMLLegendElement::static_set_accessKey);
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLLegendElement::static_get_align, js_html2_HTMLLegendElement::static_set_align);
v8_wrapper::Registrator< js_html2_HTMLLegendElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLUListElement::static_get_compact(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLUListElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLUListElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLUListElement*>(ptr)->compact;
return v8_wrapper::Set(value);
}
void js_html2_HTMLUListElement::static_set_compact(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLUListElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLUListElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLUListElement*>(ptr)->compact = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLUListElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLUListElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLUListElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLUListElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLUListElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLUListElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLUListElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLUListElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLUListElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLUListElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("compact"), js_html2_HTMLUListElement::static_get_compact, js_html2_HTMLUListElement::static_set_compact);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLUListElement::static_get_type, js_html2_HTMLUListElement::static_set_type);
v8_wrapper::Registrator< js_html2_HTMLUListElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLOListElement::static_get_compact(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLOListElement*>(ptr)->compact;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOListElement::static_set_compact(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOListElement*>(ptr)->compact = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLOListElement::static_get_start(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLOListElement*>(ptr)->start;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOListElement::static_set_start(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOListElement*>(ptr)->start = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLOListElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLOListElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLOListElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLOListElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLOListElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLOListElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLOListElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("compact"), js_html2_HTMLOListElement::static_get_compact, js_html2_HTMLOListElement::static_set_compact);
instance->SetAccessor(v8::String::New("start"), js_html2_HTMLOListElement::static_get_start, js_html2_HTMLOListElement::static_set_start);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLOListElement::static_get_type, js_html2_HTMLOListElement::static_set_type);
v8_wrapper::Registrator< js_html2_HTMLOListElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLDListElement::static_get_compact(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDListElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDListElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLDListElement*>(ptr)->compact;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDListElement::static_set_compact(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDListElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDListElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLDListElement*>(ptr)->compact = v8_wrapper::Get< bool >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLDListElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLDListElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("compact"), js_html2_HTMLDListElement::static_get_compact, js_html2_HTMLDListElement::static_set_compact);
v8_wrapper::Registrator< js_html2_HTMLDListElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLDirectoryElement::static_get_compact(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDirectoryElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDirectoryElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLDirectoryElement*>(ptr)->compact;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDirectoryElement::static_set_compact(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDirectoryElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDirectoryElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLDirectoryElement*>(ptr)->compact = v8_wrapper::Get< bool >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLDirectoryElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLDirectoryElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("compact"), js_html2_HTMLDirectoryElement::static_get_compact, js_html2_HTMLDirectoryElement::static_set_compact);
v8_wrapper::Registrator< js_html2_HTMLDirectoryElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLMenuElement::static_get_compact(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMenuElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLMenuElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLMenuElement*>(ptr)->compact;
return v8_wrapper::Set(value);
}
void js_html2_HTMLMenuElement::static_set_compact(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMenuElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLMenuElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLMenuElement*>(ptr)->compact = v8_wrapper::Get< bool >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLMenuElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLMenuElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("compact"), js_html2_HTMLMenuElement::static_get_compact, js_html2_HTMLMenuElement::static_set_compact);
v8_wrapper::Registrator< js_html2_HTMLMenuElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLLIElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLIElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLIElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLLIElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLIElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLIElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLIElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLIElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLLIElement::static_get_value(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLIElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLLIElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLLIElement*>(ptr)->value;
return v8_wrapper::Set(value);
}
void js_html2_HTMLLIElement::static_set_value(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLLIElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLLIElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLLIElement*>(ptr)->value = v8_wrapper::Get< long int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLLIElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLLIElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLLIElement::static_get_type, js_html2_HTMLLIElement::static_set_type);
instance->SetAccessor(v8::String::New("value"), js_html2_HTMLLIElement::static_get_value, js_html2_HTMLLIElement::static_set_value);
v8_wrapper::Registrator< js_html2_HTMLLIElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLDivElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDivElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLDivElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLDivElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLDivElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLDivElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLDivElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLDivElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLDivElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLDivElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLDivElement::static_get_align, js_html2_HTMLDivElement::static_set_align);
v8_wrapper::Registrator< js_html2_HTMLDivElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLParagraphElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParagraphElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLParagraphElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLParagraphElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLParagraphElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParagraphElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLParagraphElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLParagraphElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLParagraphElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLParagraphElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLParagraphElement::static_get_align, js_html2_HTMLParagraphElement::static_set_align);
v8_wrapper::Registrator< js_html2_HTMLParagraphElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLHeadingElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHeadingElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLHeadingElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLHeadingElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLHeadingElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHeadingElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLHeadingElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLHeadingElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLHeadingElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLHeadingElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLHeadingElement::static_get_align, js_html2_HTMLHeadingElement::static_set_align);
v8_wrapper::Registrator< js_html2_HTMLHeadingElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLQuoteElement::static_get_cite(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLQuoteElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLQuoteElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLQuoteElement*>(ptr)->cite;
return v8_wrapper::Set(value);
}
void js_html2_HTMLQuoteElement::static_set_cite(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLQuoteElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLQuoteElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLQuoteElement*>(ptr)->cite = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLQuoteElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLQuoteElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("cite"), js_html2_HTMLQuoteElement::static_get_cite, js_html2_HTMLQuoteElement::static_set_cite);
v8_wrapper::Registrator< js_html2_HTMLQuoteElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLPreElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLPreElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLPreElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLPreElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLPreElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLPreElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLPreElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLPreElement*>(ptr)->width = v8_wrapper::Get< long int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLPreElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLPreElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLPreElement::static_get_width, js_html2_HTMLPreElement::static_set_width);
v8_wrapper::Registrator< js_html2_HTMLPreElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLBRElement::static_get_clear(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBRElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBRElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBRElement*>(ptr)->clear;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBRElement::static_set_clear(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBRElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBRElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBRElement*>(ptr)->clear = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLBRElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLBRElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("clear"), js_html2_HTMLBRElement::static_get_clear, js_html2_HTMLBRElement::static_set_clear);
v8_wrapper::Registrator< js_html2_HTMLBRElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLBaseFontElement::static_get_color(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBaseFontElement*>(ptr)->color;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBaseFontElement::static_set_color(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBaseFontElement*>(ptr)->color = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLBaseFontElement::static_get_face(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLBaseFontElement*>(ptr)->face;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBaseFontElement::static_set_face(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBaseFontElement*>(ptr)->face = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLBaseFontElement::static_get_size(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLBaseFontElement*>(ptr)->size;
return v8_wrapper::Set(value);
}
void js_html2_HTMLBaseFontElement::static_set_size(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLBaseFontElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLBaseFontElement*>(ptr)->size = v8_wrapper::Get< long int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLBaseFontElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLBaseFontElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("color"), js_html2_HTMLBaseFontElement::static_get_color, js_html2_HTMLBaseFontElement::static_set_color);
instance->SetAccessor(v8::String::New("face"), js_html2_HTMLBaseFontElement::static_get_face, js_html2_HTMLBaseFontElement::static_set_face);
instance->SetAccessor(v8::String::New("size"), js_html2_HTMLBaseFontElement::static_get_size, js_html2_HTMLBaseFontElement::static_set_size);
v8_wrapper::Registrator< js_html2_HTMLBaseFontElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLFontElement::static_get_color(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFontElement*>(ptr)->color;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFontElement::static_set_color(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFontElement*>(ptr)->color = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFontElement::static_get_face(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFontElement*>(ptr)->face;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFontElement::static_set_face(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFontElement*>(ptr)->face = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFontElement::static_get_size(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFontElement*>(ptr)->size;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFontElement::static_set_size(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFontElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFontElement*>(ptr)->size = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLFontElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLFontElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("color"), js_html2_HTMLFontElement::static_get_color, js_html2_HTMLFontElement::static_set_color);
instance->SetAccessor(v8::String::New("face"), js_html2_HTMLFontElement::static_get_face, js_html2_HTMLFontElement::static_set_face);
instance->SetAccessor(v8::String::New("size"), js_html2_HTMLFontElement::static_get_size, js_html2_HTMLFontElement::static_set_size);
v8_wrapper::Registrator< js_html2_HTMLFontElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLHRElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLHRElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLHRElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLHRElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLHRElement::static_get_noShade(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLHRElement*>(ptr)->noShade;
return v8_wrapper::Set(value);
}
void js_html2_HTMLHRElement::static_set_noShade(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLHRElement*>(ptr)->noShade = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLHRElement::static_get_size(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLHRElement*>(ptr)->size;
return v8_wrapper::Set(value);
}
void js_html2_HTMLHRElement::static_set_size(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLHRElement*>(ptr)->size = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLHRElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLHRElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLHRElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLHRElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLHRElement*>(ptr)->width = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLHRElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLHRElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLHRElement::static_get_align, js_html2_HTMLHRElement::static_set_align);
instance->SetAccessor(v8::String::New("noShade"), js_html2_HTMLHRElement::static_get_noShade, js_html2_HTMLHRElement::static_set_noShade);
instance->SetAccessor(v8::String::New("size"), js_html2_HTMLHRElement::static_get_size, js_html2_HTMLHRElement::static_set_size);
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLHRElement::static_get_width, js_html2_HTMLHRElement::static_set_width);
v8_wrapper::Registrator< js_html2_HTMLHRElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLModElement::static_get_cite(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLModElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLModElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLModElement*>(ptr)->cite;
return v8_wrapper::Set(value);
}
void js_html2_HTMLModElement::static_set_cite(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLModElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLModElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLModElement*>(ptr)->cite = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLModElement::static_get_dateTime(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLModElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLModElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLModElement*>(ptr)->dateTime;
return v8_wrapper::Set(value);
}
void js_html2_HTMLModElement::static_set_dateTime(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLModElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLModElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLModElement*>(ptr)->dateTime = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLModElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLModElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("cite"), js_html2_HTMLModElement::static_get_cite, js_html2_HTMLModElement::static_set_cite);
instance->SetAccessor(v8::String::New("dateTime"), js_html2_HTMLModElement::static_get_dateTime, js_html2_HTMLModElement::static_set_dateTime);
v8_wrapper::Registrator< js_html2_HTMLModElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLAnchorElement::static_blur(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLAnchorElement * el = dynamic_cast<js_html2_HTMLAnchorElement *>(ptr);
el->blur();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLAnchorElement::static_focus(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLAnchorElement * el = dynamic_cast<js_html2_HTMLAnchorElement *>(ptr);
el->focus();
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_accessKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->accessKey;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_accessKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->accessKey = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_charset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->charset;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_charset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->charset = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_coords(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->coords;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_coords(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->coords = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_href(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->href;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_href(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->href = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_hreflang(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->hreflang;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_hreflang(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->hreflang = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_rel(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->rel;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_rel(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->rel = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_rev(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->rev;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_rev(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->rev = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_shape(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->shape;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_shape(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->shape = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_tabIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->tabIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_tabIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->tabIndex = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_target(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->target;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_target(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->target = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAnchorElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAnchorElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 12>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAnchorElement, 12>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAnchorElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLAnchorElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLAnchorElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
proto->Set(v8::String::New("blur"), v8::FunctionTemplate::New(js_html2_HTMLAnchorElement::static_blur));
proto->Set(v8::String::New("focus"), v8::FunctionTemplate::New(js_html2_HTMLAnchorElement::static_focus));
instance->SetAccessor(v8::String::New("accessKey"), js_html2_HTMLAnchorElement::static_get_accessKey, js_html2_HTMLAnchorElement::static_set_accessKey);
instance->SetAccessor(v8::String::New("charset"), js_html2_HTMLAnchorElement::static_get_charset, js_html2_HTMLAnchorElement::static_set_charset);
instance->SetAccessor(v8::String::New("coords"), js_html2_HTMLAnchorElement::static_get_coords, js_html2_HTMLAnchorElement::static_set_coords);
instance->SetAccessor(v8::String::New("href"), js_html2_HTMLAnchorElement::static_get_href, js_html2_HTMLAnchorElement::static_set_href);
instance->SetAccessor(v8::String::New("hreflang"), js_html2_HTMLAnchorElement::static_get_hreflang, js_html2_HTMLAnchorElement::static_set_hreflang);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLAnchorElement::static_get_name, js_html2_HTMLAnchorElement::static_set_name);
instance->SetAccessor(v8::String::New("rel"), js_html2_HTMLAnchorElement::static_get_rel, js_html2_HTMLAnchorElement::static_set_rel);
instance->SetAccessor(v8::String::New("rev"), js_html2_HTMLAnchorElement::static_get_rev, js_html2_HTMLAnchorElement::static_set_rev);
instance->SetAccessor(v8::String::New("shape"), js_html2_HTMLAnchorElement::static_get_shape, js_html2_HTMLAnchorElement::static_set_shape);
instance->SetAccessor(v8::String::New("tabIndex"), js_html2_HTMLAnchorElement::static_get_tabIndex, js_html2_HTMLAnchorElement::static_set_tabIndex);
instance->SetAccessor(v8::String::New("target"), js_html2_HTMLAnchorElement::static_get_target, js_html2_HTMLAnchorElement::static_set_target);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLAnchorElement::static_get_type, js_html2_HTMLAnchorElement::static_set_type);
v8_wrapper::Registrator< js_html2_HTMLAnchorElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLImageElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_alt(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->alt;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_alt(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->alt = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_border(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->border;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_border(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->border = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_height(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->height;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_height(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->height = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_hspace(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->hspace;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_hspace(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->hspace = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_isMap(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->isMap;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_isMap(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->isMap = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_longDesc(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->longDesc;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_longDesc(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->longDesc = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_src(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->src;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_src(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->src = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_useMap(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->useMap;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_useMap(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->useMap = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_vspace(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->vspace;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_vspace(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->vspace = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLImageElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLImageElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLImageElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 12>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLImageElement, 12>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLImageElement*>(ptr)->width = v8_wrapper::Get< long int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLImageElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLImageElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLImageElement::static_get_name, js_html2_HTMLImageElement::static_set_name);
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLImageElement::static_get_align, js_html2_HTMLImageElement::static_set_align);
instance->SetAccessor(v8::String::New("alt"), js_html2_HTMLImageElement::static_get_alt, js_html2_HTMLImageElement::static_set_alt);
instance->SetAccessor(v8::String::New("border"), js_html2_HTMLImageElement::static_get_border, js_html2_HTMLImageElement::static_set_border);
instance->SetAccessor(v8::String::New("height"), js_html2_HTMLImageElement::static_get_height, js_html2_HTMLImageElement::static_set_height);
instance->SetAccessor(v8::String::New("hspace"), js_html2_HTMLImageElement::static_get_hspace, js_html2_HTMLImageElement::static_set_hspace);
instance->SetAccessor(v8::String::New("isMap"), js_html2_HTMLImageElement::static_get_isMap, js_html2_HTMLImageElement::static_set_isMap);
instance->SetAccessor(v8::String::New("longDesc"), js_html2_HTMLImageElement::static_get_longDesc, js_html2_HTMLImageElement::static_set_longDesc);
instance->SetAccessor(v8::String::New("src"), js_html2_HTMLImageElement::static_get_src, js_html2_HTMLImageElement::static_set_src);
instance->SetAccessor(v8::String::New("useMap"), js_html2_HTMLImageElement::static_get_useMap, js_html2_HTMLImageElement::static_set_useMap);
instance->SetAccessor(v8::String::New("vspace"), js_html2_HTMLImageElement::static_get_vspace, js_html2_HTMLImageElement::static_set_vspace);
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLImageElement::static_get_width, js_html2_HTMLImageElement::static_set_width);
v8_wrapper::Registrator< js_html2_HTMLImageElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLObjectElement::static_get_form(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->form;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_form(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLObjectElement::static_get_code(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->code;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_code(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->code = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_archive(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->archive;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_archive(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->archive = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_border(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->border;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_border(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->border = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_codeBase(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->codeBase;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_codeBase(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->codeBase = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_codeType(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->codeType;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_codeType(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->codeType = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_data(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->data;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_data(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->data = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_declare(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->declare;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_declare(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->declare = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_height(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->height;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_height(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->height = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_hspace(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->hspace;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_hspace(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->hspace = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 12>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 12>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_standby(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 13>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 13>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->standby;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_standby(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 13>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 13>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->standby = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_tabIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 14>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 14>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->tabIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_tabIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 14>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 14>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->tabIndex = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 15>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 15>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 15>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 15>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_useMap(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 16>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 16>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->useMap;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_useMap(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 16>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 16>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->useMap = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_vspace(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 17>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 17>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->vspace;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_vspace(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 17>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 17>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->vspace = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 18>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 18>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 18>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 18>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->width = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLObjectElement::static_get_contentDocument(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 19>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 19>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLObjectElement*>(ptr)->contentDocument;
return v8_wrapper::Set(value);
}
void js_html2_HTMLObjectElement::static_set_contentDocument(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 19>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLObjectElement, 19>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLObjectElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLObjectElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("form"), js_html2_HTMLObjectElement::static_get_form, js_html2_HTMLObjectElement::static_set_form);
instance->SetAccessor(v8::String::New("code"), js_html2_HTMLObjectElement::static_get_code, js_html2_HTMLObjectElement::static_set_code);
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLObjectElement::static_get_align, js_html2_HTMLObjectElement::static_set_align);
instance->SetAccessor(v8::String::New("archive"), js_html2_HTMLObjectElement::static_get_archive, js_html2_HTMLObjectElement::static_set_archive);
instance->SetAccessor(v8::String::New("border"), js_html2_HTMLObjectElement::static_get_border, js_html2_HTMLObjectElement::static_set_border);
instance->SetAccessor(v8::String::New("codeBase"), js_html2_HTMLObjectElement::static_get_codeBase, js_html2_HTMLObjectElement::static_set_codeBase);
instance->SetAccessor(v8::String::New("codeType"), js_html2_HTMLObjectElement::static_get_codeType, js_html2_HTMLObjectElement::static_set_codeType);
instance->SetAccessor(v8::String::New("data"), js_html2_HTMLObjectElement::static_get_data, js_html2_HTMLObjectElement::static_set_data);
instance->SetAccessor(v8::String::New("declare"), js_html2_HTMLObjectElement::static_get_declare, js_html2_HTMLObjectElement::static_set_declare);
instance->SetAccessor(v8::String::New("height"), js_html2_HTMLObjectElement::static_get_height, js_html2_HTMLObjectElement::static_set_height);
instance->SetAccessor(v8::String::New("hspace"), js_html2_HTMLObjectElement::static_get_hspace, js_html2_HTMLObjectElement::static_set_hspace);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLObjectElement::static_get_name, js_html2_HTMLObjectElement::static_set_name);
instance->SetAccessor(v8::String::New("standby"), js_html2_HTMLObjectElement::static_get_standby, js_html2_HTMLObjectElement::static_set_standby);
instance->SetAccessor(v8::String::New("tabIndex"), js_html2_HTMLObjectElement::static_get_tabIndex, js_html2_HTMLObjectElement::static_set_tabIndex);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLObjectElement::static_get_type, js_html2_HTMLObjectElement::static_set_type);
instance->SetAccessor(v8::String::New("useMap"), js_html2_HTMLObjectElement::static_get_useMap, js_html2_HTMLObjectElement::static_set_useMap);
instance->SetAccessor(v8::String::New("vspace"), js_html2_HTMLObjectElement::static_get_vspace, js_html2_HTMLObjectElement::static_set_vspace);
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLObjectElement::static_get_width, js_html2_HTMLObjectElement::static_set_width);
instance->SetAccessor(v8::String::New("contentDocument"), js_html2_HTMLObjectElement::static_get_contentDocument, js_html2_HTMLObjectElement::static_set_contentDocument);
v8_wrapper::Registrator< js_html2_HTMLObjectElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLParamElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLParamElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLParamElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLParamElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLParamElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLParamElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLParamElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLParamElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLParamElement::static_get_value(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLParamElement*>(ptr)->value;
return v8_wrapper::Set(value);
}
void js_html2_HTMLParamElement::static_set_value(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLParamElement*>(ptr)->value = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLParamElement::static_get_valueType(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLParamElement*>(ptr)->valueType;
return v8_wrapper::Set(value);
}
void js_html2_HTMLParamElement::static_set_valueType(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLParamElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLParamElement*>(ptr)->valueType = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLParamElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLParamElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLParamElement::static_get_name, js_html2_HTMLParamElement::static_set_name);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLParamElement::static_get_type, js_html2_HTMLParamElement::static_set_type);
instance->SetAccessor(v8::String::New("value"), js_html2_HTMLParamElement::static_get_value, js_html2_HTMLParamElement::static_set_value);
instance->SetAccessor(v8::String::New("valueType"), js_html2_HTMLParamElement::static_get_valueType, js_html2_HTMLParamElement::static_set_valueType);
v8_wrapper::Registrator< js_html2_HTMLParamElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLAppletElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_alt(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->alt;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_alt(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->alt = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_archive(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->archive;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_archive(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->archive = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_code(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->code;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_code(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->code = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_codeBase(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->codeBase;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_codeBase(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->codeBase = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_height(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->height;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_height(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->height = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_hspace(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->hspace;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_hspace(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->hspace = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_object(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->object;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_object(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->object = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_vspace(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->vspace;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_vspace(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->vspace = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLAppletElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAppletElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAppletElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAppletElement*>(ptr)->width = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLAppletElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLAppletElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLAppletElement::static_get_align, js_html2_HTMLAppletElement::static_set_align);
instance->SetAccessor(v8::String::New("alt"), js_html2_HTMLAppletElement::static_get_alt, js_html2_HTMLAppletElement::static_set_alt);
instance->SetAccessor(v8::String::New("archive"), js_html2_HTMLAppletElement::static_get_archive, js_html2_HTMLAppletElement::static_set_archive);
instance->SetAccessor(v8::String::New("code"), js_html2_HTMLAppletElement::static_get_code, js_html2_HTMLAppletElement::static_set_code);
instance->SetAccessor(v8::String::New("codeBase"), js_html2_HTMLAppletElement::static_get_codeBase, js_html2_HTMLAppletElement::static_set_codeBase);
instance->SetAccessor(v8::String::New("height"), js_html2_HTMLAppletElement::static_get_height, js_html2_HTMLAppletElement::static_set_height);
instance->SetAccessor(v8::String::New("hspace"), js_html2_HTMLAppletElement::static_get_hspace, js_html2_HTMLAppletElement::static_set_hspace);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLAppletElement::static_get_name, js_html2_HTMLAppletElement::static_set_name);
instance->SetAccessor(v8::String::New("object"), js_html2_HTMLAppletElement::static_get_object, js_html2_HTMLAppletElement::static_set_object);
instance->SetAccessor(v8::String::New("vspace"), js_html2_HTMLAppletElement::static_get_vspace, js_html2_HTMLAppletElement::static_set_vspace);
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLAppletElement::static_get_width, js_html2_HTMLAppletElement::static_set_width);
v8_wrapper::Registrator< js_html2_HTMLAppletElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLMapElement::static_get_areas(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMapElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLMapElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLMapElement*>(ptr)->areas;
return v8_wrapper::Set(value);
}
void js_html2_HTMLMapElement::static_set_areas(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMapElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLMapElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLMapElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMapElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLMapElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLMapElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLMapElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLMapElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLMapElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLMapElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLMapElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLMapElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("areas"), js_html2_HTMLMapElement::static_get_areas, js_html2_HTMLMapElement::static_set_areas);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLMapElement::static_get_name, js_html2_HTMLMapElement::static_set_name);
v8_wrapper::Registrator< js_html2_HTMLMapElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLAreaElement::static_get_accessKey(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->accessKey;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAreaElement::static_set_accessKey(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->accessKey = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAreaElement::static_get_alt(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->alt;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAreaElement::static_set_alt(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->alt = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAreaElement::static_get_coords(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->coords;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAreaElement::static_set_coords(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->coords = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAreaElement::static_get_href(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->href;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAreaElement::static_set_href(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->href = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAreaElement::static_get_noHref(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->noHref;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAreaElement::static_set_noHref(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->noHref = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLAreaElement::static_get_shape(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->shape;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAreaElement::static_set_shape(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->shape = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLAreaElement::static_get_tabIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->tabIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAreaElement::static_set_tabIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->tabIndex = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLAreaElement::static_get_target(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->target;
return v8_wrapper::Set(value);
}
void js_html2_HTMLAreaElement::static_set_target(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLAreaElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLAreaElement*>(ptr)->target = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLAreaElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLAreaElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("accessKey"), js_html2_HTMLAreaElement::static_get_accessKey, js_html2_HTMLAreaElement::static_set_accessKey);
instance->SetAccessor(v8::String::New("alt"), js_html2_HTMLAreaElement::static_get_alt, js_html2_HTMLAreaElement::static_set_alt);
instance->SetAccessor(v8::String::New("coords"), js_html2_HTMLAreaElement::static_get_coords, js_html2_HTMLAreaElement::static_set_coords);
instance->SetAccessor(v8::String::New("href"), js_html2_HTMLAreaElement::static_get_href, js_html2_HTMLAreaElement::static_set_href);
instance->SetAccessor(v8::String::New("noHref"), js_html2_HTMLAreaElement::static_get_noHref, js_html2_HTMLAreaElement::static_set_noHref);
instance->SetAccessor(v8::String::New("shape"), js_html2_HTMLAreaElement::static_get_shape, js_html2_HTMLAreaElement::static_set_shape);
instance->SetAccessor(v8::String::New("tabIndex"), js_html2_HTMLAreaElement::static_get_tabIndex, js_html2_HTMLAreaElement::static_set_tabIndex);
instance->SetAccessor(v8::String::New("target"), js_html2_HTMLAreaElement::static_get_target, js_html2_HTMLAreaElement::static_set_target);
v8_wrapper::Registrator< js_html2_HTMLAreaElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLScriptElement::static_get_text(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->text;
return v8_wrapper::Set(value);
}
void js_html2_HTMLScriptElement::static_set_text(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->text = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLScriptElement::static_get_htmlFor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->htmlFor;
return v8_wrapper::Set(value);
}
void js_html2_HTMLScriptElement::static_set_htmlFor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->htmlFor = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLScriptElement::static_get_event(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->event;
return v8_wrapper::Set(value);
}
void js_html2_HTMLScriptElement::static_set_event(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->event = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLScriptElement::static_get_charset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->charset;
return v8_wrapper::Set(value);
}
void js_html2_HTMLScriptElement::static_set_charset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->charset = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLScriptElement::static_get_defer(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->defer;
return v8_wrapper::Set(value);
}
void js_html2_HTMLScriptElement::static_set_defer(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->defer = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLScriptElement::static_get_src(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->src;
return v8_wrapper::Set(value);
}
void js_html2_HTMLScriptElement::static_set_src(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->src = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLScriptElement::static_get_type(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->type;
return v8_wrapper::Set(value);
}
void js_html2_HTMLScriptElement::static_set_type(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLScriptElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLScriptElement*>(ptr)->type = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLScriptElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLScriptElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("text"), js_html2_HTMLScriptElement::static_get_text, js_html2_HTMLScriptElement::static_set_text);
instance->SetAccessor(v8::String::New("htmlFor"), js_html2_HTMLScriptElement::static_get_htmlFor, js_html2_HTMLScriptElement::static_set_htmlFor);
instance->SetAccessor(v8::String::New("event"), js_html2_HTMLScriptElement::static_get_event, js_html2_HTMLScriptElement::static_set_event);
instance->SetAccessor(v8::String::New("charset"), js_html2_HTMLScriptElement::static_get_charset, js_html2_HTMLScriptElement::static_set_charset);
instance->SetAccessor(v8::String::New("defer"), js_html2_HTMLScriptElement::static_get_defer, js_html2_HTMLScriptElement::static_set_defer);
instance->SetAccessor(v8::String::New("src"), js_html2_HTMLScriptElement::static_get_src, js_html2_HTMLScriptElement::static_set_src);
instance->SetAccessor(v8::String::New("type"), js_html2_HTMLScriptElement::static_get_type, js_html2_HTMLScriptElement::static_set_type);
v8_wrapper::Registrator< js_html2_HTMLScriptElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLTableElement::static_createTHead(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTableElement * el = dynamic_cast<js_html2_HTMLTableElement *>(ptr);
retval = v8_wrapper::Set( el->createTHead() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableElement::static_deleteTHead(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTableElement * el = dynamic_cast<js_html2_HTMLTableElement *>(ptr);
el->deleteTHead();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableElement::static_createTFoot(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTableElement * el = dynamic_cast<js_html2_HTMLTableElement *>(ptr);
retval = v8_wrapper::Set( el->createTFoot() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableElement::static_deleteTFoot(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTableElement * el = dynamic_cast<js_html2_HTMLTableElement *>(ptr);
el->deleteTFoot();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableElement::static_createCaption(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTableElement * el = dynamic_cast<js_html2_HTMLTableElement *>(ptr);
retval = v8_wrapper::Set( el->createCaption() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableElement::static_deleteCaption(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_html2_HTMLTableElement * el = dynamic_cast<js_html2_HTMLTableElement *>(ptr);
el->deleteCaption();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableElement::static_insertRow(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long int val_index = v8_wrapper::Get< long int > ( args[0] );
js_html2_HTMLTableElement * el = dynamic_cast<js_html2_HTMLTableElement *>(ptr);
retval = v8_wrapper::Set( el->insertRow(val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableElement::static_deleteRow(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long int val_index = v8_wrapper::Get< long int > ( args[0] );
js_html2_HTMLTableElement * el = dynamic_cast<js_html2_HTMLTableElement *>(ptr);
el->deleteRow(val_index);
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLTableElement::static_get_caption(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->caption;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_caption(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->caption = v8_wrapper::Get< v8::Handle<v8::Value> >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_tHead(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->tHead;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_tHead(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->tHead = v8_wrapper::Get< v8::Handle<v8::Value> >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_tFoot(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->tFoot;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_tFoot(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->tFoot = v8_wrapper::Get< v8::Handle<v8::Value> >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_rows(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->rows;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_rows(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLTableElement::static_get_tBodies(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->tBodies;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_tBodies(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 5>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLTableElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_bgColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->bgColor;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_bgColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->bgColor = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_border(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->border;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_border(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->border = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_cellPadding(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->cellPadding;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_cellPadding(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->cellPadding = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_cellSpacing(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->cellSpacing;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_cellSpacing(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->cellSpacing = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_frame(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->frame;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_frame(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->frame = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_rules(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->rules;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_rules(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 12>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 12>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->rules = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_summary(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 13>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 13>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->summary;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_summary(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 13>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 13>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->summary = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 14>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 14>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 14>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableElement, 14>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableElement*>(ptr)->width = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLTableElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLTableElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
proto->Set(v8::String::New("createTHead"), v8::FunctionTemplate::New(js_html2_HTMLTableElement::static_createTHead));
proto->Set(v8::String::New("deleteTHead"), v8::FunctionTemplate::New(js_html2_HTMLTableElement::static_deleteTHead));
proto->Set(v8::String::New("createTFoot"), v8::FunctionTemplate::New(js_html2_HTMLTableElement::static_createTFoot));
proto->Set(v8::String::New("deleteTFoot"), v8::FunctionTemplate::New(js_html2_HTMLTableElement::static_deleteTFoot));
proto->Set(v8::String::New("createCaption"), v8::FunctionTemplate::New(js_html2_HTMLTableElement::static_createCaption));
proto->Set(v8::String::New("deleteCaption"), v8::FunctionTemplate::New(js_html2_HTMLTableElement::static_deleteCaption));
proto->Set(v8::String::New("insertRow"), v8::FunctionTemplate::New(js_html2_HTMLTableElement::static_insertRow));
proto->Set(v8::String::New("deleteRow"), v8::FunctionTemplate::New(js_html2_HTMLTableElement::static_deleteRow));
instance->SetAccessor(v8::String::New("caption"), js_html2_HTMLTableElement::static_get_caption, js_html2_HTMLTableElement::static_set_caption);
instance->SetAccessor(v8::String::New("tHead"), js_html2_HTMLTableElement::static_get_tHead, js_html2_HTMLTableElement::static_set_tHead);
instance->SetAccessor(v8::String::New("tFoot"), js_html2_HTMLTableElement::static_get_tFoot, js_html2_HTMLTableElement::static_set_tFoot);
instance->SetAccessor(v8::String::New("rows"), js_html2_HTMLTableElement::static_get_rows, js_html2_HTMLTableElement::static_set_rows);
instance->SetAccessor(v8::String::New("tBodies"), js_html2_HTMLTableElement::static_get_tBodies, js_html2_HTMLTableElement::static_set_tBodies);
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLTableElement::static_get_align, js_html2_HTMLTableElement::static_set_align);
instance->SetAccessor(v8::String::New("bgColor"), js_html2_HTMLTableElement::static_get_bgColor, js_html2_HTMLTableElement::static_set_bgColor);
instance->SetAccessor(v8::String::New("border"), js_html2_HTMLTableElement::static_get_border, js_html2_HTMLTableElement::static_set_border);
instance->SetAccessor(v8::String::New("cellPadding"), js_html2_HTMLTableElement::static_get_cellPadding, js_html2_HTMLTableElement::static_set_cellPadding);
instance->SetAccessor(v8::String::New("cellSpacing"), js_html2_HTMLTableElement::static_get_cellSpacing, js_html2_HTMLTableElement::static_set_cellSpacing);
instance->SetAccessor(v8::String::New("frame"), js_html2_HTMLTableElement::static_get_frame, js_html2_HTMLTableElement::static_set_frame);
instance->SetAccessor(v8::String::New("rules"), js_html2_HTMLTableElement::static_get_rules, js_html2_HTMLTableElement::static_set_rules);
instance->SetAccessor(v8::String::New("summary"), js_html2_HTMLTableElement::static_get_summary, js_html2_HTMLTableElement::static_set_summary);
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLTableElement::static_get_width, js_html2_HTMLTableElement::static_set_width);
v8_wrapper::Registrator< js_html2_HTMLTableElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLTableCaptionElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCaptionElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCaptionElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCaptionElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCaptionElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCaptionElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCaptionElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCaptionElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLTableCaptionElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLTableCaptionElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLTableCaptionElement::static_get_align, js_html2_HTMLTableCaptionElement::static_set_align);
v8_wrapper::Registrator< js_html2_HTMLTableCaptionElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLTableColElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableColElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableColElement::static_get_ch(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->ch;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableColElement::static_set_ch(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->ch = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableColElement::static_get_chOff(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->chOff;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableColElement::static_set_chOff(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->chOff = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableColElement::static_get_span(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->span;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableColElement::static_set_span(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->span = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLTableColElement::static_get_vAlign(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->vAlign;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableColElement::static_set_vAlign(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->vAlign = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableColElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableColElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableColElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableColElement*>(ptr)->width = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLTableColElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLTableColElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLTableColElement::static_get_align, js_html2_HTMLTableColElement::static_set_align);
instance->SetAccessor(v8::String::New("ch"), js_html2_HTMLTableColElement::static_get_ch, js_html2_HTMLTableColElement::static_set_ch);
instance->SetAccessor(v8::String::New("chOff"), js_html2_HTMLTableColElement::static_get_chOff, js_html2_HTMLTableColElement::static_set_chOff);
instance->SetAccessor(v8::String::New("span"), js_html2_HTMLTableColElement::static_get_span, js_html2_HTMLTableColElement::static_set_span);
instance->SetAccessor(v8::String::New("vAlign"), js_html2_HTMLTableColElement::static_get_vAlign, js_html2_HTMLTableColElement::static_set_vAlign);
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLTableColElement::static_get_width, js_html2_HTMLTableColElement::static_set_width);
v8_wrapper::Registrator< js_html2_HTMLTableColElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLTableSectionElement::static_insertRow(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long int val_index = v8_wrapper::Get< long int > ( args[0] );
js_html2_HTMLTableSectionElement * el = dynamic_cast<js_html2_HTMLTableSectionElement *>(ptr);
retval = v8_wrapper::Set( el->insertRow(val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableSectionElement::static_deleteRow(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long int val_index = v8_wrapper::Get< long int > ( args[0] );
js_html2_HTMLTableSectionElement * el = dynamic_cast<js_html2_HTMLTableSectionElement *>(ptr);
el->deleteRow(val_index);
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLTableSectionElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableSectionElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableSectionElement::static_get_ch(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->ch;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableSectionElement::static_set_ch(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->ch = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableSectionElement::static_get_chOff(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->chOff;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableSectionElement::static_set_chOff(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->chOff = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableSectionElement::static_get_vAlign(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->vAlign;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableSectionElement::static_set_vAlign(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->vAlign = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableSectionElement::static_get_rows(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLTableSectionElement*>(ptr)->rows;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableSectionElement::static_set_rows(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableSectionElement, 5>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLTableSectionElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLTableSectionElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
proto->Set(v8::String::New("insertRow"), v8::FunctionTemplate::New(js_html2_HTMLTableSectionElement::static_insertRow));
proto->Set(v8::String::New("deleteRow"), v8::FunctionTemplate::New(js_html2_HTMLTableSectionElement::static_deleteRow));
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLTableSectionElement::static_get_align, js_html2_HTMLTableSectionElement::static_set_align);
instance->SetAccessor(v8::String::New("ch"), js_html2_HTMLTableSectionElement::static_get_ch, js_html2_HTMLTableSectionElement::static_set_ch);
instance->SetAccessor(v8::String::New("chOff"), js_html2_HTMLTableSectionElement::static_get_chOff, js_html2_HTMLTableSectionElement::static_set_chOff);
instance->SetAccessor(v8::String::New("vAlign"), js_html2_HTMLTableSectionElement::static_get_vAlign, js_html2_HTMLTableSectionElement::static_set_vAlign);
instance->SetAccessor(v8::String::New("rows"), js_html2_HTMLTableSectionElement::static_get_rows, js_html2_HTMLTableSectionElement::static_set_rows);
v8_wrapper::Registrator< js_html2_HTMLTableSectionElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_html2_HTMLTableRowElement::static_insertCell(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long int val_index = v8_wrapper::Get< long int > ( args[0] );
js_html2_HTMLTableRowElement * el = dynamic_cast<js_html2_HTMLTableRowElement *>(ptr);
retval = v8_wrapper::Set( el->insertCell(val_index) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_html2_HTMLTableRowElement::static_deleteCell(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
long int val_index = v8_wrapper::Get< long int > ( args[0] );
js_html2_HTMLTableRowElement * el = dynamic_cast<js_html2_HTMLTableRowElement *>(ptr);
el->deleteCell(val_index);
return scope.Close(retval);
}
Handle<Value> js_html2_HTMLTableRowElement::static_get_rowIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->rowIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableRowElement::static_set_rowIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLTableRowElement::static_get_sectionRowIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->sectionRowIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableRowElement::static_set_sectionRowIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLTableRowElement::static_get_cells(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->cells;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableRowElement::static_set_cells(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLTableRowElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableRowElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableRowElement::static_get_bgColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->bgColor;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableRowElement::static_set_bgColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->bgColor = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableRowElement::static_get_ch(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->ch;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableRowElement::static_set_ch(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->ch = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableRowElement::static_get_chOff(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->chOff;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableRowElement::static_set_chOff(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->chOff = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableRowElement::static_get_vAlign(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->vAlign;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableRowElement::static_set_vAlign(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableRowElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableRowElement*>(ptr)->vAlign = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLTableRowElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLTableRowElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
proto->Set(v8::String::New("insertCell"), v8::FunctionTemplate::New(js_html2_HTMLTableRowElement::static_insertCell));
proto->Set(v8::String::New("deleteCell"), v8::FunctionTemplate::New(js_html2_HTMLTableRowElement::static_deleteCell));
instance->SetAccessor(v8::String::New("rowIndex"), js_html2_HTMLTableRowElement::static_get_rowIndex, js_html2_HTMLTableRowElement::static_set_rowIndex);
instance->SetAccessor(v8::String::New("sectionRowIndex"), js_html2_HTMLTableRowElement::static_get_sectionRowIndex, js_html2_HTMLTableRowElement::static_set_sectionRowIndex);
instance->SetAccessor(v8::String::New("cells"), js_html2_HTMLTableRowElement::static_get_cells, js_html2_HTMLTableRowElement::static_set_cells);
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLTableRowElement::static_get_align, js_html2_HTMLTableRowElement::static_set_align);
instance->SetAccessor(v8::String::New("bgColor"), js_html2_HTMLTableRowElement::static_get_bgColor, js_html2_HTMLTableRowElement::static_set_bgColor);
instance->SetAccessor(v8::String::New("ch"), js_html2_HTMLTableRowElement::static_get_ch, js_html2_HTMLTableRowElement::static_set_ch);
instance->SetAccessor(v8::String::New("chOff"), js_html2_HTMLTableRowElement::static_get_chOff, js_html2_HTMLTableRowElement::static_set_chOff);
instance->SetAccessor(v8::String::New("vAlign"), js_html2_HTMLTableRowElement::static_get_vAlign, js_html2_HTMLTableRowElement::static_set_vAlign);
v8_wrapper::Registrator< js_html2_HTMLTableRowElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_cellIndex(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->cellIndex;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_cellIndex(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_abbr(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->abbr;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_abbr(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->abbr = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_axis(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->axis;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_axis(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->axis = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_bgColor(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->bgColor;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_bgColor(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->bgColor = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_ch(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->ch;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_ch(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->ch = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_chOff(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->chOff;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_chOff(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->chOff = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_colSpan(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->colSpan;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_colSpan(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->colSpan = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_headers(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->headers;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_headers(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->headers = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_height(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->height;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_height(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->height = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_noWrap(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->noWrap;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_noWrap(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 11>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->noWrap = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_rowSpan(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 12>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 12>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
long int value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->rowSpan;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_rowSpan(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 12>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 12>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->rowSpan = v8_wrapper::Get< long int >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_scope(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 13>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 13>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->scope;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_scope(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 13>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 13>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->scope = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_vAlign(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 14>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 14>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->vAlign;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_vAlign(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 14>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 14>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->vAlign = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLTableCellElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 15>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 15>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLTableCellElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 15>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLTableCellElement, 15>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLTableCellElement*>(ptr)->width = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLTableCellElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLTableCellElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("cellIndex"), js_html2_HTMLTableCellElement::static_get_cellIndex, js_html2_HTMLTableCellElement::static_set_cellIndex);
instance->SetAccessor(v8::String::New("abbr"), js_html2_HTMLTableCellElement::static_get_abbr, js_html2_HTMLTableCellElement::static_set_abbr);
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLTableCellElement::static_get_align, js_html2_HTMLTableCellElement::static_set_align);
instance->SetAccessor(v8::String::New("axis"), js_html2_HTMLTableCellElement::static_get_axis, js_html2_HTMLTableCellElement::static_set_axis);
instance->SetAccessor(v8::String::New("bgColor"), js_html2_HTMLTableCellElement::static_get_bgColor, js_html2_HTMLTableCellElement::static_set_bgColor);
instance->SetAccessor(v8::String::New("ch"), js_html2_HTMLTableCellElement::static_get_ch, js_html2_HTMLTableCellElement::static_set_ch);
instance->SetAccessor(v8::String::New("chOff"), js_html2_HTMLTableCellElement::static_get_chOff, js_html2_HTMLTableCellElement::static_set_chOff);
instance->SetAccessor(v8::String::New("colSpan"), js_html2_HTMLTableCellElement::static_get_colSpan, js_html2_HTMLTableCellElement::static_set_colSpan);
instance->SetAccessor(v8::String::New("headers"), js_html2_HTMLTableCellElement::static_get_headers, js_html2_HTMLTableCellElement::static_set_headers);
instance->SetAccessor(v8::String::New("height"), js_html2_HTMLTableCellElement::static_get_height, js_html2_HTMLTableCellElement::static_set_height);
instance->SetAccessor(v8::String::New("noWrap"), js_html2_HTMLTableCellElement::static_get_noWrap, js_html2_HTMLTableCellElement::static_set_noWrap);
instance->SetAccessor(v8::String::New("rowSpan"), js_html2_HTMLTableCellElement::static_get_rowSpan, js_html2_HTMLTableCellElement::static_set_rowSpan);
instance->SetAccessor(v8::String::New("scope"), js_html2_HTMLTableCellElement::static_get_scope, js_html2_HTMLTableCellElement::static_set_scope);
instance->SetAccessor(v8::String::New("vAlign"), js_html2_HTMLTableCellElement::static_get_vAlign, js_html2_HTMLTableCellElement::static_set_vAlign);
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLTableCellElement::static_get_width, js_html2_HTMLTableCellElement::static_set_width);
v8_wrapper::Registrator< js_html2_HTMLTableCellElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLFrameSetElement::static_get_cols(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameSetElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameSetElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameSetElement*>(ptr)->cols;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameSetElement::static_set_cols(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameSetElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameSetElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameSetElement*>(ptr)->cols = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFrameSetElement::static_get_rows(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameSetElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameSetElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameSetElement*>(ptr)->rows;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameSetElement::static_set_rows(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameSetElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameSetElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameSetElement*>(ptr)->rows = v8_wrapper::Get< html2::DOMString >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLFrameSetElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLFrameSetElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("cols"), js_html2_HTMLFrameSetElement::static_get_cols, js_html2_HTMLFrameSetElement::static_set_cols);
instance->SetAccessor(v8::String::New("rows"), js_html2_HTMLFrameSetElement::static_get_rows, js_html2_HTMLFrameSetElement::static_set_rows);
v8_wrapper::Registrator< js_html2_HTMLFrameSetElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLFrameElement::static_get_frameBorder(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->frameBorder;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_frameBorder(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->frameBorder = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFrameElement::static_get_longDesc(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->longDesc;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_longDesc(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->longDesc = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFrameElement::static_get_marginHeight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->marginHeight;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_marginHeight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->marginHeight = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFrameElement::static_get_marginWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->marginWidth;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_marginWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->marginWidth = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFrameElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFrameElement::static_get_noResize(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
bool value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->noResize;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_noResize(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->noResize = v8_wrapper::Get< bool >(value);
}
Handle<Value> js_html2_HTMLFrameElement::static_get_scrolling(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->scrolling;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_scrolling(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->scrolling = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFrameElement::static_get_src(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->src;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_src(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->src = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLFrameElement::static_get_contentDocument(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLFrameElement*>(ptr)->contentDocument;
return v8_wrapper::Set(value);
}
void js_html2_HTMLFrameElement::static_set_contentDocument(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLFrameElement, 9>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLFrameElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLFrameElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("frameBorder"), js_html2_HTMLFrameElement::static_get_frameBorder, js_html2_HTMLFrameElement::static_set_frameBorder);
instance->SetAccessor(v8::String::New("longDesc"), js_html2_HTMLFrameElement::static_get_longDesc, js_html2_HTMLFrameElement::static_set_longDesc);
instance->SetAccessor(v8::String::New("marginHeight"), js_html2_HTMLFrameElement::static_get_marginHeight, js_html2_HTMLFrameElement::static_set_marginHeight);
instance->SetAccessor(v8::String::New("marginWidth"), js_html2_HTMLFrameElement::static_get_marginWidth, js_html2_HTMLFrameElement::static_set_marginWidth);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLFrameElement::static_get_name, js_html2_HTMLFrameElement::static_set_name);
instance->SetAccessor(v8::String::New("noResize"), js_html2_HTMLFrameElement::static_get_noResize, js_html2_HTMLFrameElement::static_set_noResize);
instance->SetAccessor(v8::String::New("scrolling"), js_html2_HTMLFrameElement::static_get_scrolling, js_html2_HTMLFrameElement::static_set_scrolling);
instance->SetAccessor(v8::String::New("src"), js_html2_HTMLFrameElement::static_get_src, js_html2_HTMLFrameElement::static_set_src);
instance->SetAccessor(v8::String::New("contentDocument"), js_html2_HTMLFrameElement::static_get_contentDocument, js_html2_HTMLFrameElement::static_set_contentDocument);
v8_wrapper::Registrator< js_html2_HTMLFrameElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_align(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->align;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_align(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 1>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->align = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_frameBorder(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->frameBorder;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_frameBorder(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 2>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 2>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->frameBorder = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_height(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->height;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_height(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 3>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 3>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->height = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_longDesc(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->longDesc;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_longDesc(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 4>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 4>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->longDesc = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_marginHeight(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->marginHeight;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_marginHeight(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 5>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->marginHeight = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_marginWidth(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->marginWidth;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_marginWidth(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 6>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 6>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->marginWidth = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_name(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 7>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 7>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->name;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_name(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 7>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 7>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->name = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_scrolling(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 8>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 8>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->scrolling;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_scrolling(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 8>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 8>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->scrolling = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_src(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 9>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 9>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->src;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_src(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 9>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 9>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->src = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_width(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 10>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 10>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
html2::DOMString value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->width;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_width(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 10>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 10>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->width = v8_wrapper::Get< html2::DOMString >(value);
}
Handle<Value> js_html2_HTMLIFrameElement::static_get_contentDocument(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 11>::implemented) {
return v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 11>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_html2_HTMLIFrameElement*>(ptr)->contentDocument;
return v8_wrapper::Set(value);
}
void js_html2_HTMLIFrameElement::static_set_contentDocument(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 11>::implemented) {
v8_wrapper::CustomAttribute<js_html2_HTMLIFrameElement, 11>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_html2_HTMLIFrameElement >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("html2::HTMLIFrameElement"));
result->Inherit(v8_wrapper::Registrator< js_html2_HTMLElement >::GetTemplate());
instance->SetAccessor(v8::String::New("align"), js_html2_HTMLIFrameElement::static_get_align, js_html2_HTMLIFrameElement::static_set_align);
instance->SetAccessor(v8::String::New("frameBorder"), js_html2_HTMLIFrameElement::static_get_frameBorder, js_html2_HTMLIFrameElement::static_set_frameBorder);
instance->SetAccessor(v8::String::New("height"), js_html2_HTMLIFrameElement::static_get_height, js_html2_HTMLIFrameElement::static_set_height);
instance->SetAccessor(v8::String::New("longDesc"), js_html2_HTMLIFrameElement::static_get_longDesc, js_html2_HTMLIFrameElement::static_set_longDesc);
instance->SetAccessor(v8::String::New("marginHeight"), js_html2_HTMLIFrameElement::static_get_marginHeight, js_html2_HTMLIFrameElement::static_set_marginHeight);
instance->SetAccessor(v8::String::New("marginWidth"), js_html2_HTMLIFrameElement::static_get_marginWidth, js_html2_HTMLIFrameElement::static_set_marginWidth);
instance->SetAccessor(v8::String::New("name"), js_html2_HTMLIFrameElement::static_get_name, js_html2_HTMLIFrameElement::static_set_name);
instance->SetAccessor(v8::String::New("scrolling"), js_html2_HTMLIFrameElement::static_get_scrolling, js_html2_HTMLIFrameElement::static_set_scrolling);
instance->SetAccessor(v8::String::New("src"), js_html2_HTMLIFrameElement::static_get_src, js_html2_HTMLIFrameElement::static_set_src);
instance->SetAccessor(v8::String::New("width"), js_html2_HTMLIFrameElement::static_get_width, js_html2_HTMLIFrameElement::static_set_width);
instance->SetAccessor(v8::String::New("contentDocument"), js_html2_HTMLIFrameElement::static_get_contentDocument, js_html2_HTMLIFrameElement::static_set_contentDocument);
v8_wrapper::Registrator< js_html2_HTMLIFrameElement >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
Handle<Value> js_ranges_RangeException::static_get_code(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_ranges_RangeException, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_ranges_RangeException, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
short unsigned int value = dynamic_cast<js_ranges_RangeException*>(ptr)->code;
return v8_wrapper::Set(value);
}
void js_ranges_RangeException::static_set_code(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_ranges_RangeException, 1>::implemented) {
v8_wrapper::CustomAttribute<js_ranges_RangeException, 1>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_ranges_RangeException*>(ptr)->code = v8_wrapper::Get< short unsigned int >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_ranges_RangeException >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("ranges::RangeException"));
instance->SetAccessor(v8::String::New("code"), js_ranges_RangeException::static_get_code, js_ranges_RangeException::static_set_code);
v8_wrapper::Registrator< js_ranges_RangeException >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_ranges_Range::static_setStart(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_refNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
long int val_offset = v8_wrapper::Get< long int > ( args[1] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->setStart(val_refNode, val_offset);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_setEnd(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_refNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
long int val_offset = v8_wrapper::Get< long int > ( args[1] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->setEnd(val_refNode, val_offset);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_setStartBefore(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_refNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->setStartBefore(val_refNode);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_setStartAfter(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_refNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->setStartAfter(val_refNode);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_setEndBefore(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_refNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->setEndBefore(val_refNode);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_setEndAfter(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_refNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->setEndAfter(val_refNode);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_collapse(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
bool val_toStart = v8_wrapper::Get< bool > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->collapse(val_toStart);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_selectNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_refNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->selectNode(val_refNode);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_selectNodeContents(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_refNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->selectNodeContents(val_refNode);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_compareBoundaryPoints(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
short unsigned int val_how = v8_wrapper::Get< short unsigned int > ( args[0] );
v8::Handle<v8::Value> val_sourceRange = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[1] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
retval = v8_wrapper::Set( el->compareBoundaryPoints(val_how, val_sourceRange) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_deleteContents(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->deleteContents();
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_extractContents(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
retval = v8_wrapper::Set( el->extractContents() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_cloneContents(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
retval = v8_wrapper::Set( el->cloneContents() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_insertNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_newNode = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->insertNode(val_newNode);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_surroundContents(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_newParent = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->surroundContents(val_newParent);
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_cloneRange(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
retval = v8_wrapper::Set( el->cloneRange() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_toString(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
retval = v8_wrapper::Set( el->toString() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_ranges_Range::static_detach(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_ranges_Range * el = dynamic_cast<js_ranges_Range *>(ptr);
el->detach();
return scope.Close(retval);
}
Handle<Value> js_ranges_Range::static_get_startContainer(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_ranges_Range, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_ranges_Range*>(ptr)->startContainer;
return v8_wrapper::Set(value);
}
void js_ranges_Range::static_set_startContainer(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 1>::implemented) {
v8_wrapper::CustomAttribute<js_ranges_Range, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_ranges_Range::static_get_startOffset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_ranges_Range, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_ranges_Range*>(ptr)->startOffset;
return v8_wrapper::Set(value);
}
void js_ranges_Range::static_set_startOffset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 2>::implemented) {
v8_wrapper::CustomAttribute<js_ranges_Range, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_ranges_Range::static_get_endContainer(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_ranges_Range, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_ranges_Range*>(ptr)->endContainer;
return v8_wrapper::Set(value);
}
void js_ranges_Range::static_set_endContainer(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 3>::implemented) {
v8_wrapper::CustomAttribute<js_ranges_Range, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_ranges_Range::static_get_endOffset(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_ranges_Range, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long int value = dynamic_cast<js_ranges_Range*>(ptr)->endOffset;
return v8_wrapper::Set(value);
}
void js_ranges_Range::static_set_endOffset(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 4>::implemented) {
v8_wrapper::CustomAttribute<js_ranges_Range, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_ranges_Range::static_get_collapsed(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_ranges_Range, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_ranges_Range*>(ptr)->collapsed;
return v8_wrapper::Set(value);
}
void js_ranges_Range::static_set_collapsed(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 5>::implemented) {
v8_wrapper::CustomAttribute<js_ranges_Range, 5>::static_set(property, value, info);
return;
}
}
Handle<Value> js_ranges_Range::static_get_commonAncestorContainer(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 6>::implemented) {
return v8_wrapper::CustomAttribute<js_ranges_Range, 6>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_ranges_Range*>(ptr)->commonAncestorContainer;
return v8_wrapper::Set(value);
}
void js_ranges_Range::static_set_commonAncestorContainer(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_ranges_Range, 6>::implemented) {
v8_wrapper::CustomAttribute<js_ranges_Range, 6>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_ranges_Range >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("ranges::Range"));
proto->Set(v8::String::New("setStart"), v8::FunctionTemplate::New(js_ranges_Range::static_setStart));
proto->Set(v8::String::New("setEnd"), v8::FunctionTemplate::New(js_ranges_Range::static_setEnd));
proto->Set(v8::String::New("setStartBefore"), v8::FunctionTemplate::New(js_ranges_Range::static_setStartBefore));
proto->Set(v8::String::New("setStartAfter"), v8::FunctionTemplate::New(js_ranges_Range::static_setStartAfter));
proto->Set(v8::String::New("setEndBefore"), v8::FunctionTemplate::New(js_ranges_Range::static_setEndBefore));
proto->Set(v8::String::New("setEndAfter"), v8::FunctionTemplate::New(js_ranges_Range::static_setEndAfter));
proto->Set(v8::String::New("collapse"), v8::FunctionTemplate::New(js_ranges_Range::static_collapse));
proto->Set(v8::String::New("selectNode"), v8::FunctionTemplate::New(js_ranges_Range::static_selectNode));
proto->Set(v8::String::New("selectNodeContents"), v8::FunctionTemplate::New(js_ranges_Range::static_selectNodeContents));
proto->Set(v8::String::New("compareBoundaryPoints"), v8::FunctionTemplate::New(js_ranges_Range::static_compareBoundaryPoints));
proto->Set(v8::String::New("deleteContents"), v8::FunctionTemplate::New(js_ranges_Range::static_deleteContents));
proto->Set(v8::String::New("extractContents"), v8::FunctionTemplate::New(js_ranges_Range::static_extractContents));
proto->Set(v8::String::New("cloneContents"), v8::FunctionTemplate::New(js_ranges_Range::static_cloneContents));
proto->Set(v8::String::New("insertNode"), v8::FunctionTemplate::New(js_ranges_Range::static_insertNode));
proto->Set(v8::String::New("surroundContents"), v8::FunctionTemplate::New(js_ranges_Range::static_surroundContents));
proto->Set(v8::String::New("cloneRange"), v8::FunctionTemplate::New(js_ranges_Range::static_cloneRange));
proto->Set(v8::String::New("toString"), v8::FunctionTemplate::New(js_ranges_Range::static_toString));
proto->Set(v8::String::New("detach"), v8::FunctionTemplate::New(js_ranges_Range::static_detach));
instance->SetAccessor(v8::String::New("startContainer"), js_ranges_Range::static_get_startContainer, js_ranges_Range::static_set_startContainer);
instance->SetAccessor(v8::String::New("startOffset"), js_ranges_Range::static_get_startOffset, js_ranges_Range::static_set_startOffset);
instance->SetAccessor(v8::String::New("endContainer"), js_ranges_Range::static_get_endContainer, js_ranges_Range::static_set_endContainer);
instance->SetAccessor(v8::String::New("endOffset"), js_ranges_Range::static_get_endOffset, js_ranges_Range::static_set_endOffset);
instance->SetAccessor(v8::String::New("collapsed"), js_ranges_Range::static_get_collapsed, js_ranges_Range::static_set_collapsed);
instance->SetAccessor(v8::String::New("commonAncestorContainer"), js_ranges_Range::static_get_commonAncestorContainer, js_ranges_Range::static_set_commonAncestorContainer);
v8_wrapper::Registrator< js_ranges_Range >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_ranges_DocumentRange::static_createRange(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_ranges_DocumentRange * el = dynamic_cast<js_ranges_DocumentRange *>(ptr);
retval = v8_wrapper::Set( el->createRange() );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_ranges_DocumentRange >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("ranges::DocumentRange"));
proto->Set(v8::String::New("createRange"), v8::FunctionTemplate::New(js_ranges_DocumentRange::static_createRange));
v8_wrapper::Registrator< js_ranges_DocumentRange >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_traversal_NodeIterator::static_nextNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_NodeIterator * el = dynamic_cast<js_traversal_NodeIterator *>(ptr);
retval = v8_wrapper::Set( el->nextNode() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_NodeIterator::static_previousNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_NodeIterator * el = dynamic_cast<js_traversal_NodeIterator *>(ptr);
retval = v8_wrapper::Set( el->previousNode() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_NodeIterator::static_detach(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_NodeIterator * el = dynamic_cast<js_traversal_NodeIterator *>(ptr);
el->detach();
return scope.Close(retval);
}
Handle<Value> js_traversal_NodeIterator::static_get_root(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_traversal_NodeIterator*>(ptr)->root;
return v8_wrapper::Set(value);
}
void js_traversal_NodeIterator::static_set_root(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 1>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_traversal_NodeIterator::static_get_whatToShow(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_traversal_NodeIterator*>(ptr)->whatToShow;
return v8_wrapper::Set(value);
}
void js_traversal_NodeIterator::static_set_whatToShow(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 2>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_traversal_NodeIterator::static_get_filter(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_traversal_NodeIterator*>(ptr)->filter;
return v8_wrapper::Set(value);
}
void js_traversal_NodeIterator::static_set_filter(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 3>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_traversal_NodeIterator::static_get_expandEntityReferences(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_traversal_NodeIterator*>(ptr)->expandEntityReferences;
return v8_wrapper::Set(value);
}
void js_traversal_NodeIterator::static_set_expandEntityReferences(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 4>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_NodeIterator, 4>::static_set(property, value, info);
return;
}
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_traversal_NodeIterator >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("traversal::NodeIterator"));
proto->Set(v8::String::New("nextNode"), v8::FunctionTemplate::New(js_traversal_NodeIterator::static_nextNode));
proto->Set(v8::String::New("previousNode"), v8::FunctionTemplate::New(js_traversal_NodeIterator::static_previousNode));
proto->Set(v8::String::New("detach"), v8::FunctionTemplate::New(js_traversal_NodeIterator::static_detach));
instance->SetAccessor(v8::String::New("root"), js_traversal_NodeIterator::static_get_root, js_traversal_NodeIterator::static_set_root);
instance->SetAccessor(v8::String::New("whatToShow"), js_traversal_NodeIterator::static_get_whatToShow, js_traversal_NodeIterator::static_set_whatToShow);
instance->SetAccessor(v8::String::New("filter"), js_traversal_NodeIterator::static_get_filter, js_traversal_NodeIterator::static_set_filter);
instance->SetAccessor(v8::String::New("expandEntityReferences"), js_traversal_NodeIterator::static_get_expandEntityReferences, js_traversal_NodeIterator::static_set_expandEntityReferences);
v8_wrapper::Registrator< js_traversal_NodeIterator >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_traversal_NodeFilter::static_acceptNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_n = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
js_traversal_NodeFilter * el = dynamic_cast<js_traversal_NodeFilter *>(ptr);
retval = v8_wrapper::Set( el->acceptNode(val_n) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_traversal_NodeFilter >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("traversal::NodeFilter"));
proto->Set(v8::String::New("acceptNode"), v8::FunctionTemplate::New(js_traversal_NodeFilter::static_acceptNode));
v8_wrapper::Registrator< js_traversal_NodeFilter >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_traversal_TreeWalker::static_parentNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_TreeWalker * el = dynamic_cast<js_traversal_TreeWalker *>(ptr);
retval = v8_wrapper::Set( el->parentNode() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_TreeWalker::static_firstChild(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_TreeWalker * el = dynamic_cast<js_traversal_TreeWalker *>(ptr);
retval = v8_wrapper::Set( el->firstChild() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_TreeWalker::static_lastChild(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_TreeWalker * el = dynamic_cast<js_traversal_TreeWalker *>(ptr);
retval = v8_wrapper::Set( el->lastChild() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_TreeWalker::static_previousSibling(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_TreeWalker * el = dynamic_cast<js_traversal_TreeWalker *>(ptr);
retval = v8_wrapper::Set( el->previousSibling() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_TreeWalker::static_nextSibling(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_TreeWalker * el = dynamic_cast<js_traversal_TreeWalker *>(ptr);
retval = v8_wrapper::Set( el->nextSibling() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_TreeWalker::static_previousNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_TreeWalker * el = dynamic_cast<js_traversal_TreeWalker *>(ptr);
retval = v8_wrapper::Set( el->previousNode() );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_TreeWalker::static_nextNode(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
js_traversal_TreeWalker * el = dynamic_cast<js_traversal_TreeWalker *>(ptr);
retval = v8_wrapper::Set( el->nextNode() );
return scope.Close(retval);
}
Handle<Value> js_traversal_TreeWalker::static_get_root(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 1>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 1>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_traversal_TreeWalker*>(ptr)->root;
return v8_wrapper::Set(value);
}
void js_traversal_TreeWalker::static_set_root(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 1>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 1>::static_set(property, value, info);
return;
}
}
Handle<Value> js_traversal_TreeWalker::static_get_whatToShow(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 2>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 2>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const long unsigned int value = dynamic_cast<js_traversal_TreeWalker*>(ptr)->whatToShow;
return v8_wrapper::Set(value);
}
void js_traversal_TreeWalker::static_set_whatToShow(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 2>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 2>::static_set(property, value, info);
return;
}
}
Handle<Value> js_traversal_TreeWalker::static_get_filter(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 3>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 3>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const v8::Handle<v8::Value> value = dynamic_cast<js_traversal_TreeWalker*>(ptr)->filter;
return v8_wrapper::Set(value);
}
void js_traversal_TreeWalker::static_set_filter(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 3>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 3>::static_set(property, value, info);
return;
}
}
Handle<Value> js_traversal_TreeWalker::static_get_expandEntityReferences(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 4>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 4>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
const bool value = dynamic_cast<js_traversal_TreeWalker*>(ptr)->expandEntityReferences;
return v8_wrapper::Set(value);
}
void js_traversal_TreeWalker::static_set_expandEntityReferences(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 4>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 4>::static_set(property, value, info);
return;
}
}
Handle<Value> js_traversal_TreeWalker::static_get_currentNode(Local<String> property, const AccessorInfo &info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 5>::implemented) {
return v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 5>::static_get(property, info);
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" getter ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> value = dynamic_cast<js_traversal_TreeWalker*>(ptr)->currentNode;
return v8_wrapper::Set(value);
}
void js_traversal_TreeWalker::static_set_currentNode(Local<String> property, Local<Value> value,
const AccessorInfo& info)
{
if(v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 5>::implemented) {
v8_wrapper::CustomAttribute<js_traversal_TreeWalker, 5>::static_set(property, value, info);
return;
}
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" setter ") << std::string(__FUNCTION__) );
dynamic_cast<js_traversal_TreeWalker*>(ptr)->currentNode = v8_wrapper::Get< v8::Handle<v8::Value> >(value);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_traversal_TreeWalker >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("traversal::TreeWalker"));
proto->Set(v8::String::New("parentNode"), v8::FunctionTemplate::New(js_traversal_TreeWalker::static_parentNode));
proto->Set(v8::String::New("firstChild"), v8::FunctionTemplate::New(js_traversal_TreeWalker::static_firstChild));
proto->Set(v8::String::New("lastChild"), v8::FunctionTemplate::New(js_traversal_TreeWalker::static_lastChild));
proto->Set(v8::String::New("previousSibling"), v8::FunctionTemplate::New(js_traversal_TreeWalker::static_previousSibling));
proto->Set(v8::String::New("nextSibling"), v8::FunctionTemplate::New(js_traversal_TreeWalker::static_nextSibling));
proto->Set(v8::String::New("previousNode"), v8::FunctionTemplate::New(js_traversal_TreeWalker::static_previousNode));
proto->Set(v8::String::New("nextNode"), v8::FunctionTemplate::New(js_traversal_TreeWalker::static_nextNode));
instance->SetAccessor(v8::String::New("root"), js_traversal_TreeWalker::static_get_root, js_traversal_TreeWalker::static_set_root);
instance->SetAccessor(v8::String::New("whatToShow"), js_traversal_TreeWalker::static_get_whatToShow, js_traversal_TreeWalker::static_set_whatToShow);
instance->SetAccessor(v8::String::New("filter"), js_traversal_TreeWalker::static_get_filter, js_traversal_TreeWalker::static_set_filter);
instance->SetAccessor(v8::String::New("expandEntityReferences"), js_traversal_TreeWalker::static_get_expandEntityReferences, js_traversal_TreeWalker::static_set_expandEntityReferences);
instance->SetAccessor(v8::String::New("currentNode"), js_traversal_TreeWalker::static_get_currentNode, js_traversal_TreeWalker::static_set_currentNode);
v8_wrapper::Registrator< js_traversal_TreeWalker >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
v8::Handle<v8::Value> js_traversal_DocumentTraversal::static_createNodeIterator(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_root = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
long unsigned int val_whatToShow = v8_wrapper::Get< long unsigned int > ( args[1] );
v8::Handle<v8::Value> val_filter = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[2] );
bool val_entityReferenceExpansion = v8_wrapper::Get< bool > ( args[3] );
js_traversal_DocumentTraversal * el = dynamic_cast<js_traversal_DocumentTraversal *>(ptr);
retval = v8_wrapper::Set( el->createNodeIterator(val_root, val_whatToShow, val_filter, val_entityReferenceExpansion) );
return scope.Close(retval);
}
v8::Handle<v8::Value> js_traversal_DocumentTraversal::static_createTreeWalker(const v8::Arguments& args)
{
HandleScope scope;
Local<Object> self = args.This();
Handle<Value> retval;
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
v8_wrapper::tree_node* ptr = static_cast<v8_wrapper::tree_node*>(wrap->Value());
LOG4CXX_TRACE(webEngine::iLogger::GetLogger(), _T("v8 JavaScript binded call 0x") << std::hex << (size_t)ptr << _T(" method ") << std::string(__FUNCTION__) );
v8::Handle<v8::Value> val_root = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[0] );
long unsigned int val_whatToShow = v8_wrapper::Get< long unsigned int > ( args[1] );
v8::Handle<v8::Value> val_filter = v8_wrapper::Get< v8::Handle<v8::Value> > ( args[2] );
bool val_entityReferenceExpansion = v8_wrapper::Get< bool > ( args[3] );
js_traversal_DocumentTraversal * el = dynamic_cast<js_traversal_DocumentTraversal *>(ptr);
retval = v8_wrapper::Set( el->createTreeWalker(val_root, val_whatToShow, val_filter, val_entityReferenceExpansion) );
return scope.Close(retval);
}
namespace v8_wrapper {
template <>
v8::Persistent<v8::FunctionTemplate> Registrator< js_traversal_DocumentTraversal >::GetTemplate()
{
static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
if (!cachedTemplate.IsEmpty())
return cachedTemplate;
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
v8::Local<v8::ObjectTemplate> proto = result->PrototypeTemplate();
instance->SetInternalFieldCount(1);
result->SetClassName(v8::String::New("traversal::DocumentTraversal"));
proto->Set(v8::String::New("createNodeIterator"), v8::FunctionTemplate::New(js_traversal_DocumentTraversal::static_createNodeIterator));
proto->Set(v8::String::New("createTreeWalker"), v8::FunctionTemplate::New(js_traversal_DocumentTraversal::static_createTreeWalker));
v8_wrapper::Registrator< js_traversal_DocumentTraversal >::AdditionalHandlersGetTemplate(instance, proto);
cachedTemplate = v8::Persistent<v8::FunctionTemplate>::New(result);
return cachedTemplate;
}
}
void v8_wrapper::RegisterAll(v8::Persistent<v8::ObjectTemplate> global)
{
global->Set(String::New("DOMException"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_DOMException >::Constructor));
global->Set(String::New("DOMImplementation"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_DOMImplementation >::Constructor));
global->Set(String::New("Node"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_Node >::Constructor));
global->Set(String::New("NodeList"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_NodeList >::Constructor));
global->Set(String::New("NamedNodeMap"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_NamedNodeMap >::Constructor));
global->Set(String::New("CharacterData"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_CharacterData >::Constructor));
global->Set(String::New("Attr"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_Attr >::Constructor));
global->Set(String::New("Element"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_Element >::Constructor));
global->Set(String::New("Text"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_Text >::Constructor));
global->Set(String::New("Comment"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_Comment >::Constructor));
global->Set(String::New("CDATASection"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_CDATASection >::Constructor));
global->Set(String::New("DocumentType"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_DocumentType >::Constructor));
global->Set(String::New("Notation"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_Notation >::Constructor));
global->Set(String::New("Entity"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_Entity >::Constructor));
global->Set(String::New("EntityReference"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_EntityReference >::Constructor));
global->Set(String::New("ProcessingInstruction"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_ProcessingInstruction >::Constructor));
global->Set(String::New("DocumentFragment"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_DocumentFragment >::Constructor));
global->Set(String::New("Document"),
FunctionTemplate::New(v8_wrapper::Registrator< js_dom_Document >::Constructor));
global->Set(String::New("StyleSheet"),
FunctionTemplate::New(v8_wrapper::Registrator< js_stylesheets_StyleSheet >::Constructor));
global->Set(String::New("StyleSheetList"),
FunctionTemplate::New(v8_wrapper::Registrator< js_stylesheets_StyleSheetList >::Constructor));
global->Set(String::New("MediaList"),
FunctionTemplate::New(v8_wrapper::Registrator< js_stylesheets_MediaList >::Constructor));
global->Set(String::New("LinkStyle"),
FunctionTemplate::New(v8_wrapper::Registrator< js_stylesheets_LinkStyle >::Constructor));
global->Set(String::New("DocumentStyle"),
FunctionTemplate::New(v8_wrapper::Registrator< js_stylesheets_DocumentStyle >::Constructor));
global->Set(String::New("AbstractView"),
FunctionTemplate::New(v8_wrapper::Registrator< js_views_AbstractView >::Constructor));
global->Set(String::New("DocumentView"),
FunctionTemplate::New(v8_wrapper::Registrator< js_views_DocumentView >::Constructor));
global->Set(String::New("CSSRuleList"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSRuleList >::Constructor));
global->Set(String::New("CSSRule"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSRule >::Constructor));
global->Set(String::New("CSSStyleRule"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSStyleRule >::Constructor));
global->Set(String::New("CSSMediaRule"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSMediaRule >::Constructor));
global->Set(String::New("CSSFontFaceRule"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSFontFaceRule >::Constructor));
global->Set(String::New("CSSPageRule"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSPageRule >::Constructor));
global->Set(String::New("CSSImportRule"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSImportRule >::Constructor));
global->Set(String::New("CSSCharsetRule"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSCharsetRule >::Constructor));
global->Set(String::New("CSSUnknownRule"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSUnknownRule >::Constructor));
global->Set(String::New("CSSStyleDeclaration"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSStyleDeclaration >::Constructor));
global->Set(String::New("CSSValue"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSValue >::Constructor));
global->Set(String::New("CSSPrimitiveValue"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSPrimitiveValue >::Constructor));
global->Set(String::New("CSSValueList"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSValueList >::Constructor));
global->Set(String::New("RGBColor"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_RGBColor >::Constructor));
global->Set(String::New("Rect"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_Rect >::Constructor));
global->Set(String::New("Counter"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_Counter >::Constructor));
global->Set(String::New("ElementCSSInlineStyle"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_ElementCSSInlineStyle >::Constructor));
global->Set(String::New("CSS2Properties"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSS2Properties >::Constructor));
global->Set(String::New("CSSStyleSheet"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_CSSStyleSheet >::Constructor));
global->Set(String::New("ViewCSS"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_ViewCSS >::Constructor));
global->Set(String::New("DocumentCSS"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_DocumentCSS >::Constructor));
global->Set(String::New("DOMImplementationCSS"),
FunctionTemplate::New(v8_wrapper::Registrator< js_css_DOMImplementationCSS >::Constructor));
global->Set(String::New("EventException"),
FunctionTemplate::New(v8_wrapper::Registrator< js_events_EventException >::Constructor));
global->Set(String::New("EventTarget"),
FunctionTemplate::New(v8_wrapper::Registrator< js_events_EventTarget >::Constructor));
global->Set(String::New("EventListener"),
FunctionTemplate::New(v8_wrapper::Registrator< js_events_EventListener >::Constructor));
global->Set(String::New("Event"),
FunctionTemplate::New(v8_wrapper::Registrator< js_events_Event >::Constructor));
global->Set(String::New("DocumentEvent"),
FunctionTemplate::New(v8_wrapper::Registrator< js_events_DocumentEvent >::Constructor));
global->Set(String::New("UIEvent"),
FunctionTemplate::New(v8_wrapper::Registrator< js_events_UIEvent >::Constructor));
global->Set(String::New("MouseEvent"),
FunctionTemplate::New(v8_wrapper::Registrator< js_events_MouseEvent >::Constructor));
global->Set(String::New("MutationEvent"),
FunctionTemplate::New(v8_wrapper::Registrator< js_events_MutationEvent >::Constructor));
global->Set(String::New("HTMLCollection"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLCollection >::Constructor));
global->Set(String::New("HTMLOptionsCollection"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLOptionsCollection >::Constructor));
global->Set(String::New("HTMLDocument"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLDocument >::Constructor));
global->Set(String::New("HTMLElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLElement >::Constructor));
global->Set(String::New("HTMLHtmlElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLHtmlElement >::Constructor));
global->Set(String::New("HTMLHeadElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLHeadElement >::Constructor));
global->Set(String::New("HTMLLinkElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLLinkElement >::Constructor));
global->Set(String::New("HTMLTitleElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLTitleElement >::Constructor));
global->Set(String::New("HTMLMetaElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLMetaElement >::Constructor));
global->Set(String::New("HTMLBaseElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLBaseElement >::Constructor));
global->Set(String::New("HTMLIsIndexElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLIsIndexElement >::Constructor));
global->Set(String::New("HTMLStyleElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLStyleElement >::Constructor));
global->Set(String::New("HTMLBodyElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLBodyElement >::Constructor));
global->Set(String::New("HTMLFormElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLFormElement >::Constructor));
global->Set(String::New("HTMLSelectElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLSelectElement >::Constructor));
global->Set(String::New("HTMLOptGroupElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLOptGroupElement >::Constructor));
global->Set(String::New("HTMLOptionElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLOptionElement >::Constructor));
global->Set(String::New("HTMLInputElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLInputElement >::Constructor));
global->Set(String::New("HTMLTextAreaElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLTextAreaElement >::Constructor));
global->Set(String::New("HTMLButtonElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLButtonElement >::Constructor));
global->Set(String::New("HTMLLabelElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLLabelElement >::Constructor));
global->Set(String::New("HTMLFieldSetElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLFieldSetElement >::Constructor));
global->Set(String::New("HTMLLegendElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLLegendElement >::Constructor));
global->Set(String::New("HTMLUListElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLUListElement >::Constructor));
global->Set(String::New("HTMLOListElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLOListElement >::Constructor));
global->Set(String::New("HTMLDListElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLDListElement >::Constructor));
global->Set(String::New("HTMLDirectoryElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLDirectoryElement >::Constructor));
global->Set(String::New("HTMLMenuElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLMenuElement >::Constructor));
global->Set(String::New("HTMLLIElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLLIElement >::Constructor));
global->Set(String::New("HTMLDivElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLDivElement >::Constructor));
global->Set(String::New("HTMLParagraphElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLParagraphElement >::Constructor));
global->Set(String::New("HTMLHeadingElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLHeadingElement >::Constructor));
global->Set(String::New("HTMLQuoteElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLQuoteElement >::Constructor));
global->Set(String::New("HTMLPreElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLPreElement >::Constructor));
global->Set(String::New("HTMLBRElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLBRElement >::Constructor));
global->Set(String::New("HTMLBaseFontElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLBaseFontElement >::Constructor));
global->Set(String::New("HTMLFontElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLFontElement >::Constructor));
global->Set(String::New("HTMLHRElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLHRElement >::Constructor));
global->Set(String::New("HTMLModElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLModElement >::Constructor));
global->Set(String::New("HTMLAnchorElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLAnchorElement >::Constructor));
global->Set(String::New("HTMLImageElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLImageElement >::Constructor));
global->Set(String::New("HTMLObjectElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLObjectElement >::Constructor));
global->Set(String::New("HTMLParamElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLParamElement >::Constructor));
global->Set(String::New("HTMLAppletElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLAppletElement >::Constructor));
global->Set(String::New("HTMLMapElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLMapElement >::Constructor));
global->Set(String::New("HTMLAreaElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLAreaElement >::Constructor));
global->Set(String::New("HTMLScriptElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLScriptElement >::Constructor));
global->Set(String::New("HTMLTableElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLTableElement >::Constructor));
global->Set(String::New("HTMLTableCaptionElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLTableCaptionElement >::Constructor));
global->Set(String::New("HTMLTableColElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLTableColElement >::Constructor));
global->Set(String::New("HTMLTableSectionElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLTableSectionElement >::Constructor));
global->Set(String::New("HTMLTableRowElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLTableRowElement >::Constructor));
global->Set(String::New("HTMLTableCellElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLTableCellElement >::Constructor));
global->Set(String::New("HTMLFrameSetElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLFrameSetElement >::Constructor));
global->Set(String::New("HTMLFrameElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLFrameElement >::Constructor));
global->Set(String::New("HTMLIFrameElement"),
FunctionTemplate::New(v8_wrapper::Registrator< js_html2_HTMLIFrameElement >::Constructor));
global->Set(String::New("RangeException"),
FunctionTemplate::New(v8_wrapper::Registrator< js_ranges_RangeException >::Constructor));
global->Set(String::New("Range"),
FunctionTemplate::New(v8_wrapper::Registrator< js_ranges_Range >::Constructor));
global->Set(String::New("DocumentRange"),
FunctionTemplate::New(v8_wrapper::Registrator< js_ranges_DocumentRange >::Constructor));
global->Set(String::New("NodeIterator"),
FunctionTemplate::New(v8_wrapper::Registrator< js_traversal_NodeIterator >::Constructor));
global->Set(String::New("NodeFilter"),
FunctionTemplate::New(v8_wrapper::Registrator< js_traversal_NodeFilter >::Constructor));
global->Set(String::New("TreeWalker"),
FunctionTemplate::New(v8_wrapper::Registrator< js_traversal_TreeWalker >::Constructor));
global->Set(String::New("DocumentTraversal"),
FunctionTemplate::New(v8_wrapper::Registrator< js_traversal_DocumentTraversal >::Constructor));
}
| [
"stinger911@79c36d58-6562-11de-a3c1-4985b5740c72"
] | [
[
[
1,
20094
]
]
] |
2f03a4f1dd5183ad4e2ab0b2775efc58c9fd8c34 | 668dc83d4bc041d522e35b0c783c3e073fcc0bd2 | /fbide-vs/wxScintillaCtrl/stc.h | 3858330e483628b5ba15662a0b2c059585d15246 | [] | no_license | albeva/fbide-old-svn | 4add934982ce1ce95960c9b3859aeaf22477f10b | bde1e72e7e182fabc89452738f7655e3307296f4 | refs/heads/master | 2021-01-13T10:22:25.921182 | 2009-11-19T16:50:48 | 2009-11-19T16:50:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 152,468 | h | ////////////////////////////////////////////////////////////////////////////
// Name: wx/stc/stc.h
// Purpose: A wxWidgets implementation of Scintilla. This class is the
// one meant to be used directly by wx applications. It does not
// derive directly from the Scintilla classes, and in fact there
// is no mention of Scintilla classes at all in this header.
// This class delegates all method calls and events to the
// Scintilla objects and so forth. This allows the use of
// Scintilla without polluting the namespace with all the
// classes and itentifiers from Scintilla.
//
// Author: Robin Dunn
//
// Created: 13-Jan-2000
// RCS-ID: $Id: stc.h 62139 2009-09-26 13:26:16Z VZ $
// Copyright: (c) 2000 by Total Control Software
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*
IMPORTANT: include/wx/stc/stc.h is generated by src/stc/gen_iface.py from
src/stc/stc.h.in, don't edit stc.h file as your changes will be
lost after the next regeneration, edit stc.h.in and rerun the
gen_iface.py script instead!
Parts of this file generated by the script are found in between
the special "{{{" and "}}}" markers, the rest of it is copied
verbatim from src.h.in.
*/
#ifndef _WX_SCINTILLACTRL_STC_H_
#define _WX_SCINTILLACTRL_STC_H_
#include "wx/defs.h"
#include "../Sdk/Sdk.h"
// #define SDK_DLL
// #if wxUSE_STC
#include "wx/control.h"
#include "wx/dnd.h"
#include "wx/stopwatch.h"
#include "wx/textentry.h"
#if wxUSE_TEXTCTRL
#include "wx/textctrl.h"
#endif // wxUSE_TEXTCTRL
class WXDLLIMPEXP_FWD_CORE wxScrollBar;
// SWIG can't handle "#if" type of conditionals, only "#ifdef"
#ifdef SWIG
#define STC_USE_DND 1
#else
#if wxUSE_DRAG_AND_DROP
#define STC_USE_DND 1
#endif
#endif
//----------------------------------------------------------------------
// STC constants generated section {{{
#define wxSCI_INVALID_POSITION -1
// Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages
// as many EM_ messages can be used although that use is deprecated.
#define wxSCI_START 2000
#define wxSCI_OPTIONAL_START 3000
#define wxSCI_LEXER_START 4000
#define wxSCI_WS_INVISIBLE 0
#define wxSCI_WS_VISIBLEALWAYS 1
#define wxSCI_WS_VISIBLEAFTERINDENT 2
#define wxSCI_EOL_CRLF 0
#define wxSCI_EOL_CR 1
#define wxSCI_EOL_LF 2
// The SC_CP_UTF8 value can be used to enter Unicode mode.
// This is the same value as CP_UTF8 in Windows
#define wxSCI_CP_UTF8 65001
// The SC_CP_DBCS value can be used to indicate a DBCS mode for GTK+.
#define wxSCI_CP_DBCS 1
#define wxSCI_MARKER_MAX 31
#define wxSCI_MARK_CIRCLE 0
#define wxSCI_MARK_ROUNDRECT 1
#define wxSCI_MARK_ARROW 2
#define wxSCI_MARK_SMALLRECT 3
#define wxSCI_MARK_SHORTARROW 4
#define wxSCI_MARK_EMPTY 5
#define wxSCI_MARK_ARROWDOWN 6
#define wxSCI_MARK_MINUS 7
#define wxSCI_MARK_PLUS 8
// Shapes used for outlining column.
#define wxSCI_MARK_VLINE 9
#define wxSCI_MARK_LCORNER 10
#define wxSCI_MARK_TCORNER 11
#define wxSCI_MARK_BOXPLUS 12
#define wxSCI_MARK_BOXPLUSCONNECTED 13
#define wxSCI_MARK_BOXMINUS 14
#define wxSCI_MARK_BOXMINUSCONNECTED 15
#define wxSCI_MARK_LCORNERCURVE 16
#define wxSCI_MARK_TCORNERCURVE 17
#define wxSCI_MARK_CIRCLEPLUS 18
#define wxSCI_MARK_CIRCLEPLUSCONNECTED 19
#define wxSCI_MARK_CIRCLEMINUS 20
#define wxSCI_MARK_CIRCLEMINUSCONNECTED 21
// Invisible mark that only sets the line background color.
#define wxSCI_MARK_BACKGROUND 22
#define wxSCI_MARK_DOTDOTDOT 23
#define wxSCI_MARK_ARROWS 24
#define wxSCI_MARK_PIXMAP 25
#define wxSCI_MARK_FULLRECT 26
#define wxSCI_MARK_LEFTRECT 27
#define wxSCI_MARK_AVAILABLE 28
#define wxSCI_MARK_UNDERLINE 29
#define wxSCI_MARK_CHARACTER 10000
// Markers used for outlining column.
#define wxSCI_MARKNUM_FOLDEREND 25
#define wxSCI_MARKNUM_FOLDEROPENMID 26
#define wxSCI_MARKNUM_FOLDERMIDTAIL 27
#define wxSCI_MARKNUM_FOLDERTAIL 28
#define wxSCI_MARKNUM_FOLDERSUB 29
#define wxSCI_MARKNUM_FOLDER 30
#define wxSCI_MARKNUM_FOLDEROPEN 31
#define wxSCI_MASK_FOLDERS 0xFE000000
#define wxSCI_MARGIN_SYMBOL 0
#define wxSCI_MARGIN_NUMBER 1
#define wxSCI_MARGIN_BACK 2
#define wxSCI_MARGIN_FORE 3
#define wxSCI_MARGIN_TEXT 4
#define wxSCI_MARGIN_RTEXT 5
// Styles in range 32..38 are predefined for parts of the UI and are not used as normal styles.
// Style 39 is for future use.
#define wxSCI_STYLE_DEFAULT 32
#define wxSCI_STYLE_LINENUMBER 33
#define wxSCI_STYLE_BRACELIGHT 34
#define wxSCI_STYLE_BRACEBAD 35
#define wxSCI_STYLE_CONTROLCHAR 36
#define wxSCI_STYLE_INDENTGUIDE 37
#define wxSCI_STYLE_CALLTIP 38
#define wxSCI_STYLE_LASTPREDEFINED 39
#define wxSCI_STYLE_MAX 255
// Character set identifiers are used in StyleSetCharacterSet.
// The values are the same as the Windows *_CHARSET values.
#define wxSCI_CHARSET_ANSI 0
#define wxSCI_CHARSET_DEFAULT 1
#define wxSCI_CHARSET_BALTIC 186
#define wxSCI_CHARSET_CHINESEBIG5 136
#define wxSCI_CHARSET_EASTEUROPE 238
#define wxSCI_CHARSET_GB2312 134
#define wxSCI_CHARSET_GREEK 161
#define wxSCI_CHARSET_HANGUL 129
#define wxSCI_CHARSET_MAC 77
#define wxSCI_CHARSET_OEM 255
#define wxSCI_CHARSET_RUSSIAN 204
#define wxSCI_CHARSET_CYRILLIC 1251
#define wxSCI_CHARSET_SHIFTJIS 128
#define wxSCI_CHARSET_SYMBOL 2
#define wxSCI_CHARSET_TURKISH 162
#define wxSCI_CHARSET_JOHAB 130
#define wxSCI_CHARSET_HEBREW 177
#define wxSCI_CHARSET_ARABIC 178
#define wxSCI_CHARSET_VIETNAMESE 163
#define wxSCI_CHARSET_THAI 222
#define wxSCI_CHARSET_8859_15 1000
#define wxSCI_CASE_MIXED 0
#define wxSCI_CASE_UPPER 1
#define wxSCI_CASE_LOWER 2
// Indicator style enumeration and some constants
#define wxSCI_INDIC_PLAIN 0
#define wxSCI_INDIC_SQUIGGLE 1
#define wxSCI_INDIC_TT 2
#define wxSCI_INDIC_DIAGONAL 3
#define wxSCI_INDIC_STRIKE 4
#define wxSCI_INDIC_HIDDEN 5
#define wxSCI_INDIC_BOX 6
#define wxSCI_INDIC_ROUNDBOX 7
#define wxSCI_INDIC_MAX 31
#define wxSCI_INDIC_CONTAINER 8
#define wxSCI_INDIC0_MASK 0x20
#define wxSCI_INDIC1_MASK 0x40
#define wxSCI_INDIC2_MASK 0x80
#define wxSCI_INDICS_MASK 0xE0
#define wxSCI_IV_NONE 0
#define wxSCI_IV_REAL 1
#define wxSCI_IV_LOOKFORWARD 2
#define wxSCI_IV_LOOKBOTH 3
// PrintColourMode - use same colours as screen.
#define wxSCI_PRINT_NORMAL 0
// PrintColourMode - invert the light value of each style for printing.
#define wxSCI_PRINT_INVERTLIGHT 1
// PrintColourMode - force black text on white background for printing.
#define wxSCI_PRINT_BLACKONWHITE 2
// PrintColourMode - text stays coloured, but all background is forced to be white for printing.
#define wxSCI_PRINT_COLOURONWHITE 3
// PrintColourMode - only the default-background is forced to be white for printing.
#define wxSCI_PRINT_COLOURONWHITEDEFAULTBG 4
#define wxSCI_FIND_WHOLEWORD 2
#define wxSCI_FIND_MATCHCASE 4
#define wxSCI_FIND_WORDSTART 0x00100000
#define wxSCI_FIND_REGEXP 0x00200000
#define wxSCI_FIND_POSIX 0x00400000
#define wxSCI_FOLDLEVELBASE 0x400
#define wxSCI_FOLDLEVELWHITEFLAG 0x1000
#define wxSCI_FOLDLEVELHEADERFLAG 0x2000
#define wxSCI_FOLDLEVELNUMBERMASK 0x0FFF
#define wxSCI_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002
#define wxSCI_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004
#define wxSCI_FOLDFLAG_LINEAFTER_EXPANDED 0x0008
#define wxSCI_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010
#define wxSCI_FOLDFLAG_LEVELNUMBERS 0x0040
#define wxSCI_TIME_FOREVER 10000000
#define wxSCI_WRAP_NONE 0
#define wxSCI_WRAP_WORD 1
#define wxSCI_WRAP_CHAR 2
#define wxSCI_WRAPVISUALFLAG_NONE 0x0000
#define wxSCI_WRAPVISUALFLAG_END 0x0001
#define wxSCI_WRAPVISUALFLAG_START 0x0002
#define wxSCI_WRAPVISUALFLAGLOC_DEFAULT 0x0000
#define wxSCI_WRAPVISUALFLAGLOC_END_BY_TEXT 0x0001
#define wxSCI_WRAPVISUALFLAGLOC_START_BY_TEXT 0x0002
#define wxSCI_WRAPINDENT_FIXED 0
#define wxSCI_WRAPINDENT_SAME 1
#define wxSCI_WRAPINDENT_INDENT 2
#define wxSCI_CACHE_NONE 0
#define wxSCI_CACHE_CARET 1
#define wxSCI_CACHE_PAGE 2
#define wxSCI_CACHE_DOCUMENT 3
#define wxSCI_EDGE_NONE 0
#define wxSCI_EDGE_LINE 1
#define wxSCI_EDGE_BACKGROUND 2
#define wxSCI_STATUS_OK 0
#define wxSCI_STATUS_FAILURE 1
#define wxSCI_STATUS_BADALLOC 2
#define wxSCI_CURSORNORMAL -1
#define wxSCI_CURSORWAIT 4
// Constants for use with SetVisiblePolicy, similar to SetCaretPolicy.
#define wxSCI_VISIBLE_SLOP 0x01
#define wxSCI_VISIBLE_STRICT 0x04
// Caret policy, used by SetXCaretPolicy and SetYCaretPolicy.
// If CARET_SLOP is set, we can define a slop value: caretSlop.
// This value defines an unwanted zone (UZ) where the caret is... unwanted.
// This zone is defined as a number of pixels near the vertical margins,
// and as a number of lines near the horizontal margins.
// By keeping the caret away from the edges, it is seen within its context,
// so it is likely that the identifier that the caret is on can be completely seen,
// and that the current line is seen with some of the lines following it which are
// often dependent on that line.
#define wxSCI_CARET_SLOP 0x01
// If CARET_STRICT is set, the policy is enforced... strictly.
// The caret is centred on the display if slop is not set,
// and cannot go in the UZ if slop is set.
#define wxSCI_CARET_STRICT 0x04
// If CARET_JUMPS is set, the display is moved more energetically
// so the caret can move in the same direction longer before the policy is applied again.
#define wxSCI_CARET_JUMPS 0x10
// If CARET_EVEN is not set, instead of having symmetrical UZs,
// the left and bottom UZs are extended up to right and top UZs respectively.
// This way, we favour the displaying of useful information: the begining of lines,
// where most code reside, and the lines after the caret, eg. the body of a function.
#define wxSCI_CARET_EVEN 0x08
#define wxSCI_SEL_STREAM 0
#define wxSCI_SEL_RECTANGLE 1
#define wxSCI_SEL_LINES 2
#define wxSCI_SEL_THIN 3
#define wxSCI_ALPHA_TRANSPARENT 0
#define wxSCI_ALPHA_OPAQUE 255
#define wxSCI_ALPHA_NOALPHA 256
#define wxSCI_CARETSTYLE_INVISIBLE 0
#define wxSCI_CARETSTYLE_LINE 1
#define wxSCI_CARETSTYLE_BLOCK 2
#define wxSCI_ANNOTATION_HIDDEN 0
#define wxSCI_ANNOTATION_STANDARD 1
#define wxSCI_ANNOTATION_BOXED 2
#define wxSCI_UNDO_MAY_COALESCE 1
#define wxSCI_SCVS_NONE 0
#define wxSCI_SCVS_RECTANGULARSELECTION 1
#define wxSCI_SCVS_USERACCESSIBLE 2
// Maximum value of keywordSet parameter of SetKeyWords.
#define wxSCI_KEYWORDSET_MAX 8
// Notifications
// Type of modification and the action which caused the modification.
// These are defined as a bit mask to make it easy to specify which notifications are wanted.
// One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
#define wxSCI_MOD_INSERTTEXT 0x1
#define wxSCI_MOD_DELETETEXT 0x2
#define wxSCI_MOD_CHANGESTYLE 0x4
#define wxSCI_MOD_CHANGEFOLD 0x8
#define wxSCI_PERFORMED_USER 0x10
#define wxSCI_PERFORMED_UNDO 0x20
#define wxSCI_PERFORMED_REDO 0x40
#define wxSCI_MULTISTEPUNDOREDO 0x80
#define wxSCI_LASTSTEPINUNDOREDO 0x100
#define wxSCI_MOD_CHANGEMARKER 0x200
#define wxSCI_MOD_BEFOREINSERT 0x400
#define wxSCI_MOD_BEFOREDELETE 0x800
#define wxSCI_MULTILINEUNDOREDO 0x1000
#define wxSCI_STARTACTION 0x2000
#define wxSCI_MOD_CHANGEINDICATOR 0x4000
#define wxSCI_MOD_CHANGELINESTATE 0x8000
#define wxSCI_MOD_CHANGEMARGIN 0x10000
#define wxSCI_MOD_CHANGEANNOTATION 0x20000
#define wxSCI_MOD_CONTAINER 0x40000
#define wxSCI_MODEVENTMASKALL 0x7FFFF
// Symbolic key codes and modifier flags.
// ASCII and other printable characters below 256.
// Extended keys above 300.
#define wxSCI_KEY_DOWN 300
#define wxSCI_KEY_UP 301
#define wxSCI_KEY_LEFT 302
#define wxSCI_KEY_RIGHT 303
#define wxSCI_KEY_HOME 304
#define wxSCI_KEY_END 305
#define wxSCI_KEY_PRIOR 306
#define wxSCI_KEY_NEXT 307
#define wxSCI_KEY_DELETE 308
#define wxSCI_KEY_INSERT 309
#define wxSCI_KEY_ESCAPE 7
#define wxSCI_KEY_BACK 8
#define wxSCI_KEY_TAB 9
#define wxSCI_KEY_RETURN 13
#define wxSCI_KEY_ADD 310
#define wxSCI_KEY_SUBTRACT 311
#define wxSCI_KEY_DIVIDE 312
#define wxSCI_KEY_WIN 313
#define wxSCI_KEY_RWIN 314
#define wxSCI_KEY_MENU 315
#define wxSCI_SCMOD_NORM 0
#define wxSCI_SCMOD_SHIFT 1
#define wxSCI_SCMOD_CTRL 2
#define wxSCI_SCMOD_ALT 4
#define wxSCI_SCMOD_SUPER 8
// For SciLexer.h
#define wxSCI_LEX_CONTAINER 0
#define wxSCI_LEX_NULL 1
#define wxSCI_LEX_PYTHON 2
#define wxSCI_LEX_CPP 3
#define wxSCI_LEX_HTML 4
#define wxSCI_LEX_XML 5
#define wxSCI_LEX_PERL 6
#define wxSCI_LEX_SQL 7
#define wxSCI_LEX_VB 8
#define wxSCI_LEX_PROPERTIES 9
#define wxSCI_LEX_ERRORLIST 10
#define wxSCI_LEX_MAKEFILE 11
#define wxSCI_LEX_BATCH 12
#define wxSCI_LEX_XCODE 13
#define wxSCI_LEX_LATEX 14
#define wxSCI_LEX_LUA 15
#define wxSCI_LEX_DIFF 16
#define wxSCI_LEX_CONF 17
#define wxSCI_LEX_PASCAL 18
#define wxSCI_LEX_AVE 19
#define wxSCI_LEX_ADA 20
#define wxSCI_LEX_LISP 21
#define wxSCI_LEX_RUBY 22
#define wxSCI_LEX_EIFFEL 23
#define wxSCI_LEX_EIFFELKW 24
#define wxSCI_LEX_TCL 25
#define wxSCI_LEX_NNCRONTAB 26
#define wxSCI_LEX_BULLANT 27
#define wxSCI_LEX_VBSCRIPT 28
#define wxSCI_LEX_BAAN 31
#define wxSCI_LEX_MATLAB 32
#define wxSCI_LEX_SCRIPTOL 33
#define wxSCI_LEX_ASM 34
#define wxSCI_LEX_CPPNOCASE 35
#define wxSCI_LEX_FORTRAN 36
#define wxSCI_LEX_F77 37
#define wxSCI_LEX_CSS 38
#define wxSCI_LEX_POV 39
#define wxSCI_LEX_LOUT 40
#define wxSCI_LEX_ESCRIPT 41
#define wxSCI_LEX_PS 42
#define wxSCI_LEX_NSIS 43
#define wxSCI_LEX_MMIXAL 44
#define wxSCI_LEX_CLW 45
#define wxSCI_LEX_CLWNOCASE 46
#define wxSCI_LEX_LOT 47
#define wxSCI_LEX_YAML 48
#define wxSCI_LEX_TEX 49
#define wxSCI_LEX_METAPOST 50
#define wxSCI_LEX_POWERBASIC 51
#define wxSCI_LEX_FORTH 52
#define wxSCI_LEX_ERLANG 53
#define wxSCI_LEX_OCTAVE 54
#define wxSCI_LEX_MSSQL 55
#define wxSCI_LEX_VERILOG 56
#define wxSCI_LEX_KIX 57
#define wxSCI_LEX_GUI4CLI 58
#define wxSCI_LEX_SPECMAN 59
#define wxSCI_LEX_AU3 60
#define wxSCI_LEX_APDL 61
#define wxSCI_LEX_BASH 62
#define wxSCI_LEX_ASN1 63
#define wxSCI_LEX_VHDL 64
#define wxSCI_LEX_CAML 65
#define wxSCI_LEX_BLITZBASIC 66
#define wxSCI_LEX_PUREBASIC 67
#define wxSCI_LEX_HASKELL 68
#define wxSCI_LEX_PHPSCRIPT 69
#define wxSCI_LEX_TADS3 70
#define wxSCI_LEX_REBOL 71
#define wxSCI_LEX_SMALLTALK 72
#define wxSCI_LEX_FLAGSHIP 73
#define wxSCI_LEX_CSOUND 74
#define wxSCI_LEX_FREEBASIC 75
#define wxSCI_LEX_INNOSETUP 76
#define wxSCI_LEX_OPAL 77
#define wxSCI_LEX_SPICE 78
#define wxSCI_LEX_D 79
#define wxSCI_LEX_CMAKE 80
#define wxSCI_LEX_GAP 81
#define wxSCI_LEX_PLM 82
#define wxSCI_LEX_PROGRESS 83
#define wxSCI_LEX_ABAQUS 84
#define wxSCI_LEX_ASYMPTOTE 85
#define wxSCI_LEX_R 86
#define wxSCI_LEX_MAGIK 87
#define wxSCI_LEX_POWERSHELL 88
#define wxSCI_LEX_MYSQL 89
#define wxSCI_LEX_PO 90
#define wxSCI_LEX_TAL 91
#define wxSCI_LEX_COBOL 92
#define wxSCI_LEX_TACL 93
#define wxSCI_LEX_SORCUS 94
#define wxSCI_LEX_POWERPRO 95
#define wxSCI_LEX_NIMROD 96
#define wxSCI_LEX_SML 97
// When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
// value assigned in sequence from SCLEX_AUTOMATIC+1.
#define wxSCI_LEX_AUTOMATIC 1000
// Lexical states for SCLEX_PYTHON
#define wxSCI_P_DEFAULT 0
#define wxSCI_P_COMMENTLINE 1
#define wxSCI_P_NUMBER 2
#define wxSCI_P_STRING 3
#define wxSCI_P_CHARACTER 4
#define wxSCI_P_WORD 5
#define wxSCI_P_TRIPLE 6
#define wxSCI_P_TRIPLEDOUBLE 7
#define wxSCI_P_CLASSNAME 8
#define wxSCI_P_DEFNAME 9
#define wxSCI_P_OPERATOR 10
#define wxSCI_P_IDENTIFIER 11
#define wxSCI_P_COMMENTBLOCK 12
#define wxSCI_P_STRINGEOL 13
#define wxSCI_P_WORD2 14
#define wxSCI_P_DECORATOR 15
// Lexical states for SCLEX_CPP
#define wxSCI_C_DEFAULT 0
#define wxSCI_C_COMMENT 1
#define wxSCI_C_COMMENTLINE 2
#define wxSCI_C_COMMENTDOC 3
#define wxSCI_C_NUMBER 4
#define wxSCI_C_WORD 5
#define wxSCI_C_STRING 6
#define wxSCI_C_CHARACTER 7
#define wxSCI_C_UUID 8
#define wxSCI_C_PREPROCESSOR 9
#define wxSCI_C_OPERATOR 10
#define wxSCI_C_IDENTIFIER 11
#define wxSCI_C_STRINGEOL 12
#define wxSCI_C_VERBATIM 13
#define wxSCI_C_REGEX 14
#define wxSCI_C_COMMENTLINEDOC 15
#define wxSCI_C_WORD2 16
#define wxSCI_C_COMMENTDOCKEYWORD 17
#define wxSCI_C_COMMENTDOCKEYWORDERROR 18
#define wxSCI_C_GLOBALCLASS 19
// Lexical states for SCLEX_D
#define wxSCI_D_DEFAULT 0
#define wxSCI_D_COMMENT 1
#define wxSCI_D_COMMENTLINE 2
#define wxSCI_D_COMMENTDOC 3
#define wxSCI_D_COMMENTNESTED 4
#define wxSCI_D_NUMBER 5
#define wxSCI_D_WORD 6
#define wxSCI_D_WORD2 7
#define wxSCI_D_WORD3 8
#define wxSCI_D_TYPEDEF 9
#define wxSCI_D_STRING 10
#define wxSCI_D_STRINGEOL 11
#define wxSCI_D_CHARACTER 12
#define wxSCI_D_OPERATOR 13
#define wxSCI_D_IDENTIFIER 14
#define wxSCI_D_COMMENTLINEDOC 15
#define wxSCI_D_COMMENTDOCKEYWORD 16
#define wxSCI_D_COMMENTDOCKEYWORDERROR 17
#define wxSCI_D_STRINGB 18
#define wxSCI_D_STRINGR 19
#define wxSCI_D_WORD5 20
#define wxSCI_D_WORD6 21
#define wxSCI_D_WORD7 22
// Lexical states for SCLEX_TCL
#define wxSCI_TCL_DEFAULT 0
#define wxSCI_TCL_COMMENT 1
#define wxSCI_TCL_COMMENTLINE 2
#define wxSCI_TCL_NUMBER 3
#define wxSCI_TCL_WORD_IN_QUOTE 4
#define wxSCI_TCL_IN_QUOTE 5
#define wxSCI_TCL_OPERATOR 6
#define wxSCI_TCL_IDENTIFIER 7
#define wxSCI_TCL_SUBSTITUTION 8
#define wxSCI_TCL_SUB_BRACE 9
#define wxSCI_TCL_MODIFIER 10
#define wxSCI_TCL_EXPAND 11
#define wxSCI_TCL_WORD 12
#define wxSCI_TCL_WORD2 13
#define wxSCI_TCL_WORD3 14
#define wxSCI_TCL_WORD4 15
#define wxSCI_TCL_WORD5 16
#define wxSCI_TCL_WORD6 17
#define wxSCI_TCL_WORD7 18
#define wxSCI_TCL_WORD8 19
#define wxSCI_TCL_COMMENT_BOX 20
#define wxSCI_TCL_BLOCK_COMMENT 21
// Lexical states for SCLEX_HTML, SCLEX_XML
#define wxSCI_H_DEFAULT 0
#define wxSCI_H_TAG 1
#define wxSCI_H_TAGUNKNOWN 2
#define wxSCI_H_ATTRIBUTE 3
#define wxSCI_H_ATTRIBUTEUNKNOWN 4
#define wxSCI_H_NUMBER 5
#define wxSCI_H_DOUBLESTRING 6
#define wxSCI_H_SINGLESTRING 7
#define wxSCI_H_OTHER 8
#define wxSCI_H_COMMENT 9
#define wxSCI_H_ENTITY 10
// XML and ASP
#define wxSCI_H_TAGEND 11
#define wxSCI_H_XMLSTART 12
#define wxSCI_H_XMLEND 13
#define wxSCI_H_SCRIPT 14
#define wxSCI_H_ASP 15
#define wxSCI_H_ASPAT 16
#define wxSCI_H_CDATA 17
#define wxSCI_H_QUESTION 18
// More HTML
#define wxSCI_H_VALUE 19
// X-Code
#define wxSCI_H_XCCOMMENT 20
// SGML
#define wxSCI_H_SGML_DEFAULT 21
#define wxSCI_H_SGML_COMMAND 22
#define wxSCI_H_SGML_1ST_PARAM 23
#define wxSCI_H_SGML_DOUBLESTRING 24
#define wxSCI_H_SGML_SIMPLESTRING 25
#define wxSCI_H_SGML_ERROR 26
#define wxSCI_H_SGML_SPECIAL 27
#define wxSCI_H_SGML_ENTITY 28
#define wxSCI_H_SGML_COMMENT 29
#define wxSCI_H_SGML_1ST_PARAM_COMMENT 30
#define wxSCI_H_SGML_BLOCK_DEFAULT 31
// Embedded Javascript
#define wxSCI_HJ_START 40
#define wxSCI_HJ_DEFAULT 41
#define wxSCI_HJ_COMMENT 42
#define wxSCI_HJ_COMMENTLINE 43
#define wxSCI_HJ_COMMENTDOC 44
#define wxSCI_HJ_NUMBER 45
#define wxSCI_HJ_WORD 46
#define wxSCI_HJ_KEYWORD 47
#define wxSCI_HJ_DOUBLESTRING 48
#define wxSCI_HJ_SINGLESTRING 49
#define wxSCI_HJ_SYMBOLS 50
#define wxSCI_HJ_STRINGEOL 51
#define wxSCI_HJ_REGEX 52
// ASP Javascript
#define wxSCI_HJA_START 55
#define wxSCI_HJA_DEFAULT 56
#define wxSCI_HJA_COMMENT 57
#define wxSCI_HJA_COMMENTLINE 58
#define wxSCI_HJA_COMMENTDOC 59
#define wxSCI_HJA_NUMBER 60
#define wxSCI_HJA_WORD 61
#define wxSCI_HJA_KEYWORD 62
#define wxSCI_HJA_DOUBLESTRING 63
#define wxSCI_HJA_SINGLESTRING 64
#define wxSCI_HJA_SYMBOLS 65
#define wxSCI_HJA_STRINGEOL 66
#define wxSCI_HJA_REGEX 67
// Embedded VBScript
#define wxSCI_HB_START 70
#define wxSCI_HB_DEFAULT 71
#define wxSCI_HB_COMMENTLINE 72
#define wxSCI_HB_NUMBER 73
#define wxSCI_HB_WORD 74
#define wxSCI_HB_STRING 75
#define wxSCI_HB_IDENTIFIER 76
#define wxSCI_HB_STRINGEOL 77
// ASP VBScript
#define wxSCI_HBA_START 80
#define wxSCI_HBA_DEFAULT 81
#define wxSCI_HBA_COMMENTLINE 82
#define wxSCI_HBA_NUMBER 83
#define wxSCI_HBA_WORD 84
#define wxSCI_HBA_STRING 85
#define wxSCI_HBA_IDENTIFIER 86
#define wxSCI_HBA_STRINGEOL 87
// Embedded Python
#define wxSCI_HP_START 90
#define wxSCI_HP_DEFAULT 91
#define wxSCI_HP_COMMENTLINE 92
#define wxSCI_HP_NUMBER 93
#define wxSCI_HP_STRING 94
#define wxSCI_HP_CHARACTER 95
#define wxSCI_HP_WORD 96
#define wxSCI_HP_TRIPLE 97
#define wxSCI_HP_TRIPLEDOUBLE 98
#define wxSCI_HP_CLASSNAME 99
#define wxSCI_HP_DEFNAME 100
#define wxSCI_HP_OPERATOR 101
#define wxSCI_HP_IDENTIFIER 102
// PHP
#define wxSCI_HPHP_COMPLEX_VARIABLE 104
// ASP Python
#define wxSCI_HPA_START 105
#define wxSCI_HPA_DEFAULT 106
#define wxSCI_HPA_COMMENTLINE 107
#define wxSCI_HPA_NUMBER 108
#define wxSCI_HPA_STRING 109
#define wxSCI_HPA_CHARACTER 110
#define wxSCI_HPA_WORD 111
#define wxSCI_HPA_TRIPLE 112
#define wxSCI_HPA_TRIPLEDOUBLE 113
#define wxSCI_HPA_CLASSNAME 114
#define wxSCI_HPA_DEFNAME 115
#define wxSCI_HPA_OPERATOR 116
#define wxSCI_HPA_IDENTIFIER 117
// PHP
#define wxSCI_HPHP_DEFAULT 118
#define wxSCI_HPHP_HSTRING 119
#define wxSCI_HPHP_SIMPLESTRING 120
#define wxSCI_HPHP_WORD 121
#define wxSCI_HPHP_NUMBER 122
#define wxSCI_HPHP_VARIABLE 123
#define wxSCI_HPHP_COMMENT 124
#define wxSCI_HPHP_COMMENTLINE 125
#define wxSCI_HPHP_HSTRING_VARIABLE 126
#define wxSCI_HPHP_OPERATOR 127
// Lexical states for SCLEX_PERL
#define wxSCI_PL_DEFAULT 0
#define wxSCI_PL_ERROR 1
#define wxSCI_PL_COMMENTLINE 2
#define wxSCI_PL_POD 3
#define wxSCI_PL_NUMBER 4
#define wxSCI_PL_WORD 5
#define wxSCI_PL_STRING 6
#define wxSCI_PL_CHARACTER 7
#define wxSCI_PL_PUNCTUATION 8
#define wxSCI_PL_PREPROCESSOR 9
#define wxSCI_PL_OPERATOR 10
#define wxSCI_PL_IDENTIFIER 11
#define wxSCI_PL_SCALAR 12
#define wxSCI_PL_ARRAY 13
#define wxSCI_PL_HASH 14
#define wxSCI_PL_SYMBOLTABLE 15
#define wxSCI_PL_VARIABLE_INDEXER 16
#define wxSCI_PL_REGEX 17
#define wxSCI_PL_REGSUBST 18
#define wxSCI_PL_LONGQUOTE 19
#define wxSCI_PL_BACKTICKS 20
#define wxSCI_PL_DATASECTION 21
#define wxSCI_PL_HERE_DELIM 22
#define wxSCI_PL_HERE_Q 23
#define wxSCI_PL_HERE_QQ 24
#define wxSCI_PL_HERE_QX 25
#define wxSCI_PL_STRING_Q 26
#define wxSCI_PL_STRING_QQ 27
#define wxSCI_PL_STRING_QX 28
#define wxSCI_PL_STRING_QR 29
#define wxSCI_PL_STRING_QW 30
#define wxSCI_PL_POD_VERB 31
#define wxSCI_PL_SUB_PROTOTYPE 40
#define wxSCI_PL_FORMAT_IDENT 41
#define wxSCI_PL_FORMAT 42
// Lexical states for SCLEX_RUBY
#define wxSCI_RB_DEFAULT 0
#define wxSCI_RB_ERROR 1
#define wxSCI_RB_COMMENTLINE 2
#define wxSCI_RB_POD 3
#define wxSCI_RB_NUMBER 4
#define wxSCI_RB_WORD 5
#define wxSCI_RB_STRING 6
#define wxSCI_RB_CHARACTER 7
#define wxSCI_RB_CLASSNAME 8
#define wxSCI_RB_DEFNAME 9
#define wxSCI_RB_OPERATOR 10
#define wxSCI_RB_IDENTIFIER 11
#define wxSCI_RB_REGEX 12
#define wxSCI_RB_GLOBAL 13
#define wxSCI_RB_SYMBOL 14
#define wxSCI_RB_MODULE_NAME 15
#define wxSCI_RB_INSTANCE_VAR 16
#define wxSCI_RB_CLASS_VAR 17
#define wxSCI_RB_BACKTICKS 18
#define wxSCI_RB_DATASECTION 19
#define wxSCI_RB_HERE_DELIM 20
#define wxSCI_RB_HERE_Q 21
#define wxSCI_RB_HERE_QQ 22
#define wxSCI_RB_HERE_QX 23
#define wxSCI_RB_STRING_Q 24
#define wxSCI_RB_STRING_QQ 25
#define wxSCI_RB_STRING_QX 26
#define wxSCI_RB_STRING_QR 27
#define wxSCI_RB_STRING_QW 28
#define wxSCI_RB_WORD_DEMOTED 29
#define wxSCI_RB_STDIN 30
#define wxSCI_RB_STDOUT 31
#define wxSCI_RB_STDERR 40
#define wxSCI_RB_UPPER_BOUND 41
// Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC
#define wxSCI_B_DEFAULT 0
#define wxSCI_B_COMMENT 1
#define wxSCI_B_NUMBER 2
#define wxSCI_B_KEYWORD 3
#define wxSCI_B_STRING 4
#define wxSCI_B_PREPROCESSOR 5
#define wxSCI_B_OPERATOR 6
#define wxSCI_B_IDENTIFIER 7
#define wxSCI_B_DATE 8
#define wxSCI_B_STRINGEOL 9
#define wxSCI_B_KEYWORD2 10
#define wxSCI_B_KEYWORD3 11
#define wxSCI_B_KEYWORD4 12
#define wxSCI_B_CONSTANT 13
#define wxSCI_B_ASM 14
#define wxSCI_B_LABEL 15
#define wxSCI_B_ERROR 16
#define wxSCI_B_HEXNUMBER 17
#define wxSCI_B_BINNUMBER 18
// Lexical states for SCLEX_PROPERTIES
#define wxSCI_PROPS_DEFAULT 0
#define wxSCI_PROPS_COMMENT 1
#define wxSCI_PROPS_SECTION 2
#define wxSCI_PROPS_ASSIGNMENT 3
#define wxSCI_PROPS_DEFVAL 4
#define wxSCI_PROPS_KEY 5
// Lexical states for SCLEX_LATEX
#define wxSCI_L_DEFAULT 0
#define wxSCI_L_COMMAND 1
#define wxSCI_L_TAG 2
#define wxSCI_L_MATH 3
#define wxSCI_L_COMMENT 4
// Lexical states for SCLEX_LUA
#define wxSCI_LUA_DEFAULT 0
#define wxSCI_LUA_COMMENT 1
#define wxSCI_LUA_COMMENTLINE 2
#define wxSCI_LUA_COMMENTDOC 3
#define wxSCI_LUA_NUMBER 4
#define wxSCI_LUA_WORD 5
#define wxSCI_LUA_STRING 6
#define wxSCI_LUA_CHARACTER 7
#define wxSCI_LUA_LITERALSTRING 8
#define wxSCI_LUA_PREPROCESSOR 9
#define wxSCI_LUA_OPERATOR 10
#define wxSCI_LUA_IDENTIFIER 11
#define wxSCI_LUA_STRINGEOL 12
#define wxSCI_LUA_WORD2 13
#define wxSCI_LUA_WORD3 14
#define wxSCI_LUA_WORD4 15
#define wxSCI_LUA_WORD5 16
#define wxSCI_LUA_WORD6 17
#define wxSCI_LUA_WORD7 18
#define wxSCI_LUA_WORD8 19
// Lexical states for SCLEX_ERRORLIST
#define wxSCI_ERR_DEFAULT 0
#define wxSCI_ERR_PYTHON 1
#define wxSCI_ERR_GCC 2
#define wxSCI_ERR_MS 3
#define wxSCI_ERR_CMD 4
#define wxSCI_ERR_BORLAND 5
#define wxSCI_ERR_PERL 6
#define wxSCI_ERR_NET 7
#define wxSCI_ERR_LUA 8
#define wxSCI_ERR_CTAG 9
#define wxSCI_ERR_DIFF_CHANGED 10
#define wxSCI_ERR_DIFF_ADDITION 11
#define wxSCI_ERR_DIFF_DELETION 12
#define wxSCI_ERR_DIFF_MESSAGE 13
#define wxSCI_ERR_PHP 14
#define wxSCI_ERR_ELF 15
#define wxSCI_ERR_IFC 16
#define wxSCI_ERR_IFORT 17
#define wxSCI_ERR_ABSF 18
#define wxSCI_ERR_TIDY 19
#define wxSCI_ERR_JAVA_STACK 20
#define wxSCI_ERR_VALUE 21
// Lexical states for SCLEX_BATCH
#define wxSCI_BAT_DEFAULT 0
#define wxSCI_BAT_COMMENT 1
#define wxSCI_BAT_WORD 2
#define wxSCI_BAT_LABEL 3
#define wxSCI_BAT_HIDE 4
#define wxSCI_BAT_COMMAND 5
#define wxSCI_BAT_IDENTIFIER 6
#define wxSCI_BAT_OPERATOR 7
// Lexical states for SCLEX_MAKEFILE
#define wxSCI_MAKE_DEFAULT 0
#define wxSCI_MAKE_COMMENT 1
#define wxSCI_MAKE_PREPROCESSOR 2
#define wxSCI_MAKE_IDENTIFIER 3
#define wxSCI_MAKE_OPERATOR 4
#define wxSCI_MAKE_TARGET 5
#define wxSCI_MAKE_IDEOL 9
// Lexical states for SCLEX_DIFF
#define wxSCI_DIFF_DEFAULT 0
#define wxSCI_DIFF_COMMENT 1
#define wxSCI_DIFF_COMMAND 2
#define wxSCI_DIFF_HEADER 3
#define wxSCI_DIFF_POSITION 4
#define wxSCI_DIFF_DELETED 5
#define wxSCI_DIFF_ADDED 6
#define wxSCI_DIFF_CHANGED 7
// Lexical states for SCLEX_CONF (Apache Configuration Files Lexer)
#define wxSCI_CONF_DEFAULT 0
#define wxSCI_CONF_COMMENT 1
#define wxSCI_CONF_NUMBER 2
#define wxSCI_CONF_IDENTIFIER 3
#define wxSCI_CONF_EXTENSION 4
#define wxSCI_CONF_PARAMETER 5
#define wxSCI_CONF_STRING 6
#define wxSCI_CONF_OPERATOR 7
#define wxSCI_CONF_IP 8
#define wxSCI_CONF_DIRECTIVE 9
// Lexical states for SCLEX_AVE, Avenue
#define wxSCI_AVE_DEFAULT 0
#define wxSCI_AVE_COMMENT 1
#define wxSCI_AVE_NUMBER 2
#define wxSCI_AVE_WORD 3
#define wxSCI_AVE_STRING 6
#define wxSCI_AVE_ENUM 7
#define wxSCI_AVE_STRINGEOL 8
#define wxSCI_AVE_IDENTIFIER 9
#define wxSCI_AVE_OPERATOR 10
#define wxSCI_AVE_WORD1 11
#define wxSCI_AVE_WORD2 12
#define wxSCI_AVE_WORD3 13
#define wxSCI_AVE_WORD4 14
#define wxSCI_AVE_WORD5 15
#define wxSCI_AVE_WORD6 16
// Lexical states for SCLEX_ADA
#define wxSCI_ADA_DEFAULT 0
#define wxSCI_ADA_WORD 1
#define wxSCI_ADA_IDENTIFIER 2
#define wxSCI_ADA_NUMBER 3
#define wxSCI_ADA_DELIMITER 4
#define wxSCI_ADA_CHARACTER 5
#define wxSCI_ADA_CHARACTEREOL 6
#define wxSCI_ADA_STRING 7
#define wxSCI_ADA_STRINGEOL 8
#define wxSCI_ADA_LABEL 9
#define wxSCI_ADA_COMMENTLINE 10
#define wxSCI_ADA_ILLEGAL 11
// Lexical states for SCLEX_BAAN
#define wxSCI_BAAN_DEFAULT 0
#define wxSCI_BAAN_COMMENT 1
#define wxSCI_BAAN_COMMENTDOC 2
#define wxSCI_BAAN_NUMBER 3
#define wxSCI_BAAN_WORD 4
#define wxSCI_BAAN_STRING 5
#define wxSCI_BAAN_PREPROCESSOR 6
#define wxSCI_BAAN_OPERATOR 7
#define wxSCI_BAAN_IDENTIFIER 8
#define wxSCI_BAAN_STRINGEOL 9
#define wxSCI_BAAN_WORD2 10
// Lexical states for SCLEX_LISP
#define wxSCI_LISP_DEFAULT 0
#define wxSCI_LISP_COMMENT 1
#define wxSCI_LISP_NUMBER 2
#define wxSCI_LISP_KEYWORD 3
#define wxSCI_LISP_KEYWORD_KW 4
#define wxSCI_LISP_SYMBOL 5
#define wxSCI_LISP_STRING 6
#define wxSCI_LISP_STRINGEOL 8
#define wxSCI_LISP_IDENTIFIER 9
#define wxSCI_LISP_OPERATOR 10
#define wxSCI_LISP_SPECIAL 11
#define wxSCI_LISP_MULTI_COMMENT 12
// Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW
#define wxSCI_EIFFEL_DEFAULT 0
#define wxSCI_EIFFEL_COMMENTLINE 1
#define wxSCI_EIFFEL_NUMBER 2
#define wxSCI_EIFFEL_WORD 3
#define wxSCI_EIFFEL_STRING 4
#define wxSCI_EIFFEL_CHARACTER 5
#define wxSCI_EIFFEL_OPERATOR 6
#define wxSCI_EIFFEL_IDENTIFIER 7
#define wxSCI_EIFFEL_STRINGEOL 8
// Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer)
#define wxSCI_NNCRONTAB_DEFAULT 0
#define wxSCI_NNCRONTAB_COMMENT 1
#define wxSCI_NNCRONTAB_TASK 2
#define wxSCI_NNCRONTAB_SECTION 3
#define wxSCI_NNCRONTAB_KEYWORD 4
#define wxSCI_NNCRONTAB_MODIFIER 5
#define wxSCI_NNCRONTAB_ASTERISK 6
#define wxSCI_NNCRONTAB_NUMBER 7
#define wxSCI_NNCRONTAB_STRING 8
#define wxSCI_NNCRONTAB_ENVIRONMENT 9
#define wxSCI_NNCRONTAB_IDENTIFIER 10
// Lexical states for SCLEX_FORTH (Forth Lexer)
#define wxSCI_FORTH_DEFAULT 0
#define wxSCI_FORTH_COMMENT 1
#define wxSCI_FORTH_COMMENT_ML 2
#define wxSCI_FORTH_IDENTIFIER 3
#define wxSCI_FORTH_CONTROL 4
#define wxSCI_FORTH_KEYWORD 5
#define wxSCI_FORTH_DEFWORD 6
#define wxSCI_FORTH_PREWORD1 7
#define wxSCI_FORTH_PREWORD2 8
#define wxSCI_FORTH_NUMBER 9
#define wxSCI_FORTH_STRING 10
#define wxSCI_FORTH_LOCALE 11
// Lexical states for SCLEX_MATLAB
#define wxSCI_MATLAB_DEFAULT 0
#define wxSCI_MATLAB_COMMENT 1
#define wxSCI_MATLAB_COMMAND 2
#define wxSCI_MATLAB_NUMBER 3
#define wxSCI_MATLAB_KEYWORD 4
// single quoted string
#define wxSCI_MATLAB_STRING 5
#define wxSCI_MATLAB_OPERATOR 6
#define wxSCI_MATLAB_IDENTIFIER 7
#define wxSCI_MATLAB_DOUBLEQUOTESTRING 8
// Lexical states for SCLEX_SCRIPTOL
#define wxSCI_SCRIPTOL_DEFAULT 0
#define wxSCI_SCRIPTOL_WHITE 1
#define wxSCI_SCRIPTOL_COMMENTLINE 2
#define wxSCI_SCRIPTOL_PERSISTENT 3
#define wxSCI_SCRIPTOL_CSTYLE 4
#define wxSCI_SCRIPTOL_COMMENTBLOCK 5
#define wxSCI_SCRIPTOL_NUMBER 6
#define wxSCI_SCRIPTOL_STRING 7
#define wxSCI_SCRIPTOL_CHARACTER 8
#define wxSCI_SCRIPTOL_STRINGEOL 9
#define wxSCI_SCRIPTOL_KEYWORD 10
#define wxSCI_SCRIPTOL_OPERATOR 11
#define wxSCI_SCRIPTOL_IDENTIFIER 12
#define wxSCI_SCRIPTOL_TRIPLE 13
#define wxSCI_SCRIPTOL_CLASSNAME 14
#define wxSCI_SCRIPTOL_PREPROCESSOR 15
// Lexical states for SCLEX_ASM
#define wxSCI_ASM_DEFAULT 0
#define wxSCI_ASM_COMMENT 1
#define wxSCI_ASM_NUMBER 2
#define wxSCI_ASM_STRING 3
#define wxSCI_ASM_OPERATOR 4
#define wxSCI_ASM_IDENTIFIER 5
#define wxSCI_ASM_CPUINSTRUCTION 6
#define wxSCI_ASM_MATHINSTRUCTION 7
#define wxSCI_ASM_REGISTER 8
#define wxSCI_ASM_DIRECTIVE 9
#define wxSCI_ASM_DIRECTIVEOPERAND 10
#define wxSCI_ASM_COMMENTBLOCK 11
#define wxSCI_ASM_CHARACTER 12
#define wxSCI_ASM_STRINGEOL 13
#define wxSCI_ASM_EXTINSTRUCTION 14
// Lexical states for SCLEX_FORTRAN
#define wxSCI_F_DEFAULT 0
#define wxSCI_F_COMMENT 1
#define wxSCI_F_NUMBER 2
#define wxSCI_F_STRING1 3
#define wxSCI_F_STRING2 4
#define wxSCI_F_STRINGEOL 5
#define wxSCI_F_OPERATOR 6
#define wxSCI_F_IDENTIFIER 7
#define wxSCI_F_WORD 8
#define wxSCI_F_WORD2 9
#define wxSCI_F_WORD3 10
#define wxSCI_F_PREPROCESSOR 11
#define wxSCI_F_OPERATOR2 12
#define wxSCI_F_LABEL 13
#define wxSCI_F_CONTINUATION 14
// Lexical states for SCLEX_CSS
#define wxSCI_CSS_DEFAULT 0
#define wxSCI_CSS_TAG 1
#define wxSCI_CSS_CLASS 2
#define wxSCI_CSS_PSEUDOCLASS 3
#define wxSCI_CSS_UNKNOWN_PSEUDOCLASS 4
#define wxSCI_CSS_OPERATOR 5
#define wxSCI_CSS_IDENTIFIER 6
#define wxSCI_CSS_UNKNOWN_IDENTIFIER 7
#define wxSCI_CSS_VALUE 8
#define wxSCI_CSS_COMMENT 9
#define wxSCI_CSS_ID 10
#define wxSCI_CSS_IMPORTANT 11
#define wxSCI_CSS_DIRECTIVE 12
#define wxSCI_CSS_DOUBLESTRING 13
#define wxSCI_CSS_SINGLESTRING 14
#define wxSCI_CSS_IDENTIFIER2 15
#define wxSCI_CSS_ATTRIBUTE 16
#define wxSCI_CSS_IDENTIFIER3 17
#define wxSCI_CSS_PSEUDOELEMENT 18
#define wxSCI_CSS_EXTENDED_IDENTIFIER 19
#define wxSCI_CSS_EXTENDED_PSEUDOCLASS 20
#define wxSCI_CSS_EXTENDED_PSEUDOELEMENT 21
// Lexical states for SCLEX_POV
#define wxSCI_POV_DEFAULT 0
#define wxSCI_POV_COMMENT 1
#define wxSCI_POV_COMMENTLINE 2
#define wxSCI_POV_NUMBER 3
#define wxSCI_POV_OPERATOR 4
#define wxSCI_POV_IDENTIFIER 5
#define wxSCI_POV_STRING 6
#define wxSCI_POV_STRINGEOL 7
#define wxSCI_POV_DIRECTIVE 8
#define wxSCI_POV_BADDIRECTIVE 9
#define wxSCI_POV_WORD2 10
#define wxSCI_POV_WORD3 11
#define wxSCI_POV_WORD4 12
#define wxSCI_POV_WORD5 13
#define wxSCI_POV_WORD6 14
#define wxSCI_POV_WORD7 15
#define wxSCI_POV_WORD8 16
// Lexical states for SCLEX_LOUT
#define wxSCI_LOUT_DEFAULT 0
#define wxSCI_LOUT_COMMENT 1
#define wxSCI_LOUT_NUMBER 2
#define wxSCI_LOUT_WORD 3
#define wxSCI_LOUT_WORD2 4
#define wxSCI_LOUT_WORD3 5
#define wxSCI_LOUT_WORD4 6
#define wxSCI_LOUT_STRING 7
#define wxSCI_LOUT_OPERATOR 8
#define wxSCI_LOUT_IDENTIFIER 9
#define wxSCI_LOUT_STRINGEOL 10
// Lexical states for SCLEX_ESCRIPT
#define wxSCI_ESCRIPT_DEFAULT 0
#define wxSCI_ESCRIPT_COMMENT 1
#define wxSCI_ESCRIPT_COMMENTLINE 2
#define wxSCI_ESCRIPT_COMMENTDOC 3
#define wxSCI_ESCRIPT_NUMBER 4
#define wxSCI_ESCRIPT_WORD 5
#define wxSCI_ESCRIPT_STRING 6
#define wxSCI_ESCRIPT_OPERATOR 7
#define wxSCI_ESCRIPT_IDENTIFIER 8
#define wxSCI_ESCRIPT_BRACE 9
#define wxSCI_ESCRIPT_WORD2 10
#define wxSCI_ESCRIPT_WORD3 11
// Lexical states for SCLEX_PS
#define wxSCI_PS_DEFAULT 0
#define wxSCI_PS_COMMENT 1
#define wxSCI_PS_DSC_COMMENT 2
#define wxSCI_PS_DSC_VALUE 3
#define wxSCI_PS_NUMBER 4
#define wxSCI_PS_NAME 5
#define wxSCI_PS_KEYWORD 6
#define wxSCI_PS_LITERAL 7
#define wxSCI_PS_IMMEVAL 8
#define wxSCI_PS_PAREN_ARRAY 9
#define wxSCI_PS_PAREN_DICT 10
#define wxSCI_PS_PAREN_PROC 11
#define wxSCI_PS_TEXT 12
#define wxSCI_PS_HEXSTRING 13
#define wxSCI_PS_BASE85STRING 14
#define wxSCI_PS_BADSTRINGCHAR 15
// Lexical states for SCLEX_NSIS
#define wxSCI_NSIS_DEFAULT 0
#define wxSCI_NSIS_COMMENT 1
#define wxSCI_NSIS_STRINGDQ 2
#define wxSCI_NSIS_STRINGLQ 3
#define wxSCI_NSIS_STRINGRQ 4
#define wxSCI_NSIS_FUNCTION 5
#define wxSCI_NSIS_VARIABLE 6
#define wxSCI_NSIS_LABEL 7
#define wxSCI_NSIS_USERDEFINED 8
#define wxSCI_NSIS_SECTIONDEF 9
#define wxSCI_NSIS_SUBSECTIONDEF 10
#define wxSCI_NSIS_IFDEFINEDEF 11
#define wxSCI_NSIS_MACRODEF 12
#define wxSCI_NSIS_STRINGVAR 13
#define wxSCI_NSIS_NUMBER 14
#define wxSCI_NSIS_SECTIONGROUP 15
#define wxSCI_NSIS_PAGEEX 16
#define wxSCI_NSIS_FUNCTIONDEF 17
#define wxSCI_NSIS_COMMENTBOX 18
// Lexical states for SCLEX_MMIXAL
#define wxSCI_MMIXAL_LEADWS 0
#define wxSCI_MMIXAL_COMMENT 1
#define wxSCI_MMIXAL_LABEL 2
#define wxSCI_MMIXAL_OPCODE 3
#define wxSCI_MMIXAL_OPCODE_PRE 4
#define wxSCI_MMIXAL_OPCODE_VALID 5
#define wxSCI_MMIXAL_OPCODE_UNKNOWN 6
#define wxSCI_MMIXAL_OPCODE_POST 7
#define wxSCI_MMIXAL_OPERANDS 8
#define wxSCI_MMIXAL_NUMBER 9
#define wxSCI_MMIXAL_REF 10
#define wxSCI_MMIXAL_CHAR 11
#define wxSCI_MMIXAL_STRING 12
#define wxSCI_MMIXAL_REGISTER 13
#define wxSCI_MMIXAL_HEX 14
#define wxSCI_MMIXAL_OPERATOR 15
#define wxSCI_MMIXAL_SYMBOL 16
#define wxSCI_MMIXAL_INCLUDE 17
// Lexical states for SCLEX_CLW
#define wxSCI_CLW_DEFAULT 0
#define wxSCI_CLW_LABEL 1
#define wxSCI_CLW_COMMENT 2
#define wxSCI_CLW_STRING 3
#define wxSCI_CLW_USER_IDENTIFIER 4
#define wxSCI_CLW_INTEGER_CONSTANT 5
#define wxSCI_CLW_REAL_CONSTANT 6
#define wxSCI_CLW_PICTURE_STRING 7
#define wxSCI_CLW_KEYWORD 8
#define wxSCI_CLW_COMPILER_DIRECTIVE 9
#define wxSCI_CLW_RUNTIME_EXPRESSIONS 10
#define wxSCI_CLW_BUILTIN_PROCEDURES_FUNCTION 11
#define wxSCI_CLW_STRUCTURE_DATA_TYPE 12
#define wxSCI_CLW_ATTRIBUTE 13
#define wxSCI_CLW_STANDARD_EQUATE 14
#define wxSCI_CLW_ERROR 15
#define wxSCI_CLW_DEPRECATED 16
// Lexical states for SCLEX_LOT
#define wxSCI_LOT_DEFAULT 0
#define wxSCI_LOT_HEADER 1
#define wxSCI_LOT_BREAK 2
#define wxSCI_LOT_SET 3
#define wxSCI_LOT_PASS 4
#define wxSCI_LOT_FAIL 5
#define wxSCI_LOT_ABORT 6
// Lexical states for SCLEX_YAML
#define wxSCI_YAML_DEFAULT 0
#define wxSCI_YAML_COMMENT 1
#define wxSCI_YAML_IDENTIFIER 2
#define wxSCI_YAML_KEYWORD 3
#define wxSCI_YAML_NUMBER 4
#define wxSCI_YAML_REFERENCE 5
#define wxSCI_YAML_DOCUMENT 6
#define wxSCI_YAML_TEXT 7
#define wxSCI_YAML_ERROR 8
#define wxSCI_YAML_OPERATOR 9
// Lexical states for SCLEX_TEX
#define wxSCI_TEX_DEFAULT 0
#define wxSCI_TEX_SPECIAL 1
#define wxSCI_TEX_GROUP 2
#define wxSCI_TEX_SYMBOL 3
#define wxSCI_TEX_COMMAND 4
#define wxSCI_TEX_TEXT 5
#define wxSCI_METAPOST_DEFAULT 0
#define wxSCI_METAPOST_SPECIAL 1
#define wxSCI_METAPOST_GROUP 2
#define wxSCI_METAPOST_SYMBOL 3
#define wxSCI_METAPOST_COMMAND 4
#define wxSCI_METAPOST_TEXT 5
#define wxSCI_METAPOST_EXTRA 6
// Lexical states for SCLEX_ERLANG
#define wxSCI_ERLANG_DEFAULT 0
#define wxSCI_ERLANG_COMMENT 1
#define wxSCI_ERLANG_VARIABLE 2
#define wxSCI_ERLANG_NUMBER 3
#define wxSCI_ERLANG_KEYWORD 4
#define wxSCI_ERLANG_STRING 5
#define wxSCI_ERLANG_OPERATOR 6
#define wxSCI_ERLANG_ATOM 7
#define wxSCI_ERLANG_FUNCTION_NAME 8
#define wxSCI_ERLANG_CHARACTER 9
#define wxSCI_ERLANG_MACRO 10
#define wxSCI_ERLANG_RECORD 11
#define wxSCI_ERLANG_SEPARATOR 12
#define wxSCI_ERLANG_NODE_NAME 13
#define wxSCI_ERLANG_UNKNOWN 31
// Lexical states for SCLEX_OCTAVE are identical to MatLab
// Lexical states for SCLEX_MSSQL
#define wxSCI_MSSQL_DEFAULT 0
#define wxSCI_MSSQL_COMMENT 1
#define wxSCI_MSSQL_LINE_COMMENT 2
#define wxSCI_MSSQL_NUMBER 3
#define wxSCI_MSSQL_STRING 4
#define wxSCI_MSSQL_OPERATOR 5
#define wxSCI_MSSQL_IDENTIFIER 6
#define wxSCI_MSSQL_VARIABLE 7
#define wxSCI_MSSQL_COLUMN_NAME 8
#define wxSCI_MSSQL_STATEMENT 9
#define wxSCI_MSSQL_DATATYPE 10
#define wxSCI_MSSQL_SYSTABLE 11
#define wxSCI_MSSQL_GLOBAL_VARIABLE 12
#define wxSCI_MSSQL_FUNCTION 13
#define wxSCI_MSSQL_STORED_PROCEDURE 14
#define wxSCI_MSSQL_DEFAULT_PREF_DATATYPE 15
#define wxSCI_MSSQL_COLUMN_NAME_2 16
// Lexical states for SCLEX_VERILOG
#define wxSCI_V_DEFAULT 0
#define wxSCI_V_COMMENT 1
#define wxSCI_V_COMMENTLINE 2
#define wxSCI_V_COMMENTLINEBANG 3
#define wxSCI_V_NUMBER 4
#define wxSCI_V_WORD 5
#define wxSCI_V_STRING 6
#define wxSCI_V_WORD2 7
#define wxSCI_V_WORD3 8
#define wxSCI_V_PREPROCESSOR 9
#define wxSCI_V_OPERATOR 10
#define wxSCI_V_IDENTIFIER 11
#define wxSCI_V_STRINGEOL 12
#define wxSCI_V_USER 19
// Lexical states for SCLEX_KIX
#define wxSCI_KIX_DEFAULT 0
#define wxSCI_KIX_COMMENT 1
#define wxSCI_KIX_STRING1 2
#define wxSCI_KIX_STRING2 3
#define wxSCI_KIX_NUMBER 4
#define wxSCI_KIX_VAR 5
#define wxSCI_KIX_MACRO 6
#define wxSCI_KIX_KEYWORD 7
#define wxSCI_KIX_FUNCTIONS 8
#define wxSCI_KIX_OPERATOR 9
#define wxSCI_KIX_IDENTIFIER 31
// Lexical states for SCLEX_GUI4CLI
#define wxSCI_GC_DEFAULT 0
#define wxSCI_GC_COMMENTLINE 1
#define wxSCI_GC_COMMENTBLOCK 2
#define wxSCI_GC_GLOBAL 3
#define wxSCI_GC_EVENT 4
#define wxSCI_GC_ATTRIBUTE 5
#define wxSCI_GC_CONTROL 6
#define wxSCI_GC_COMMAND 7
#define wxSCI_GC_STRING 8
#define wxSCI_GC_OPERATOR 9
// Lexical states for SCLEX_SPECMAN
#define wxSCI_SN_DEFAULT 0
#define wxSCI_SN_CODE 1
#define wxSCI_SN_COMMENTLINE 2
#define wxSCI_SN_COMMENTLINEBANG 3
#define wxSCI_SN_NUMBER 4
#define wxSCI_SN_WORD 5
#define wxSCI_SN_STRING 6
#define wxSCI_SN_WORD2 7
#define wxSCI_SN_WORD3 8
#define wxSCI_SN_PREPROCESSOR 9
#define wxSCI_SN_OPERATOR 10
#define wxSCI_SN_IDENTIFIER 11
#define wxSCI_SN_STRINGEOL 12
#define wxSCI_SN_REGEXTAG 13
#define wxSCI_SN_SIGNAL 14
#define wxSCI_SN_USER 19
// Lexical states for SCLEX_AU3
#define wxSCI_AU3_DEFAULT 0
#define wxSCI_AU3_COMMENT 1
#define wxSCI_AU3_COMMENTBLOCK 2
#define wxSCI_AU3_NUMBER 3
#define wxSCI_AU3_FUNCTION 4
#define wxSCI_AU3_KEYWORD 5
#define wxSCI_AU3_MACRO 6
#define wxSCI_AU3_STRING 7
#define wxSCI_AU3_OPERATOR 8
#define wxSCI_AU3_VARIABLE 9
#define wxSCI_AU3_SENT 10
#define wxSCI_AU3_PREPROCESSOR 11
#define wxSCI_AU3_SPECIAL 12
#define wxSCI_AU3_EXPAND 13
#define wxSCI_AU3_COMOBJ 14
#define wxSCI_AU3_UDF 15
// Lexical states for SCLEX_APDL
#define wxSCI_APDL_DEFAULT 0
#define wxSCI_APDL_COMMENT 1
#define wxSCI_APDL_COMMENTBLOCK 2
#define wxSCI_APDL_NUMBER 3
#define wxSCI_APDL_STRING 4
#define wxSCI_APDL_OPERATOR 5
#define wxSCI_APDL_WORD 6
#define wxSCI_APDL_PROCESSOR 7
#define wxSCI_APDL_COMMAND 8
#define wxSCI_APDL_SLASHCOMMAND 9
#define wxSCI_APDL_STARCOMMAND 10
#define wxSCI_APDL_ARGUMENT 11
#define wxSCI_APDL_FUNCTION 12
// Lexical states for SCLEX_BASH
#define wxSCI_SH_DEFAULT 0
#define wxSCI_SH_ERROR 1
#define wxSCI_SH_COMMENTLINE 2
#define wxSCI_SH_NUMBER 3
#define wxSCI_SH_WORD 4
#define wxSCI_SH_STRING 5
#define wxSCI_SH_CHARACTER 6
#define wxSCI_SH_OPERATOR 7
#define wxSCI_SH_IDENTIFIER 8
#define wxSCI_SH_SCALAR 9
#define wxSCI_SH_PARAM 10
#define wxSCI_SH_BACKTICKS 11
#define wxSCI_SH_HERE_DELIM 12
#define wxSCI_SH_HERE_Q 13
// Lexical states for SCLEX_ASN1
#define wxSCI_ASN1_DEFAULT 0
#define wxSCI_ASN1_COMMENT 1
#define wxSCI_ASN1_IDENTIFIER 2
#define wxSCI_ASN1_STRING 3
#define wxSCI_ASN1_OID 4
#define wxSCI_ASN1_SCALAR 5
#define wxSCI_ASN1_KEYWORD 6
#define wxSCI_ASN1_ATTRIBUTE 7
#define wxSCI_ASN1_DESCRIPTOR 8
#define wxSCI_ASN1_TYPE 9
#define wxSCI_ASN1_OPERATOR 10
// Lexical states for SCLEX_VHDL
#define wxSCI_VHDL_DEFAULT 0
#define wxSCI_VHDL_COMMENT 1
#define wxSCI_VHDL_COMMENTLINEBANG 2
#define wxSCI_VHDL_NUMBER 3
#define wxSCI_VHDL_STRING 4
#define wxSCI_VHDL_OPERATOR 5
#define wxSCI_VHDL_IDENTIFIER 6
#define wxSCI_VHDL_STRINGEOL 7
#define wxSCI_VHDL_KEYWORD 8
#define wxSCI_VHDL_STDOPERATOR 9
#define wxSCI_VHDL_ATTRIBUTE 10
#define wxSCI_VHDL_STDFUNCTION 11
#define wxSCI_VHDL_STDPACKAGE 12
#define wxSCI_VHDL_STDTYPE 13
#define wxSCI_VHDL_USERWORD 14
// Lexical states for SCLEX_CAML
#define wxSCI_CAML_DEFAULT 0
#define wxSCI_CAML_IDENTIFIER 1
#define wxSCI_CAML_TAGNAME 2
#define wxSCI_CAML_KEYWORD 3
#define wxSCI_CAML_KEYWORD2 4
#define wxSCI_CAML_KEYWORD3 5
#define wxSCI_CAML_LINENUM 6
#define wxSCI_CAML_OPERATOR 7
#define wxSCI_CAML_NUMBER 8
#define wxSCI_CAML_CHAR 9
#define wxSCI_CAML_WHITE 10
#define wxSCI_CAML_STRING 11
#define wxSCI_CAML_COMMENT 12
#define wxSCI_CAML_COMMENT1 13
#define wxSCI_CAML_COMMENT2 14
#define wxSCI_CAML_COMMENT3 15
// Lexical states for SCLEX_HASKELL
#define wxSCI_HA_DEFAULT 0
#define wxSCI_HA_IDENTIFIER 1
#define wxSCI_HA_KEYWORD 2
#define wxSCI_HA_NUMBER 3
#define wxSCI_HA_STRING 4
#define wxSCI_HA_CHARACTER 5
#define wxSCI_HA_CLASS 6
#define wxSCI_HA_MODULE 7
#define wxSCI_HA_CAPITAL 8
#define wxSCI_HA_DATA 9
#define wxSCI_HA_IMPORT 10
#define wxSCI_HA_OPERATOR 11
#define wxSCI_HA_INSTANCE 12
#define wxSCI_HA_COMMENTLINE 13
#define wxSCI_HA_COMMENTBLOCK 14
#define wxSCI_HA_COMMENTBLOCK2 15
#define wxSCI_HA_COMMENTBLOCK3 16
// Lexical states of SCLEX_TADS3
#define wxSCI_T3_DEFAULT 0
#define wxSCI_T3_X_DEFAULT 1
#define wxSCI_T3_PREPROCESSOR 2
#define wxSCI_T3_BLOCK_COMMENT 3
#define wxSCI_T3_LINE_COMMENT 4
#define wxSCI_T3_OPERATOR 5
#define wxSCI_T3_KEYWORD 6
#define wxSCI_T3_NUMBER 7
#define wxSCI_T3_IDENTIFIER 8
#define wxSCI_T3_S_STRING 9
#define wxSCI_T3_D_STRING 10
#define wxSCI_T3_X_STRING 11
#define wxSCI_T3_LIB_DIRECTIVE 12
#define wxSCI_T3_MSG_PARAM 13
#define wxSCI_T3_HTML_TAG 14
#define wxSCI_T3_HTML_DEFAULT 15
#define wxSCI_T3_HTML_STRING 16
#define wxSCI_T3_USER1 17
#define wxSCI_T3_USER2 18
#define wxSCI_T3_USER3 19
#define wxSCI_T3_BRACE 20
// Lexical states for SCLEX_REBOL
#define wxSCI_REBOL_DEFAULT 0
#define wxSCI_REBOL_COMMENTLINE 1
#define wxSCI_REBOL_COMMENTBLOCK 2
#define wxSCI_REBOL_PREFACE 3
#define wxSCI_REBOL_OPERATOR 4
#define wxSCI_REBOL_CHARACTER 5
#define wxSCI_REBOL_QUOTEDSTRING 6
#define wxSCI_REBOL_BRACEDSTRING 7
#define wxSCI_REBOL_NUMBER 8
#define wxSCI_REBOL_PAIR 9
#define wxSCI_REBOL_TUPLE 10
#define wxSCI_REBOL_BINARY 11
#define wxSCI_REBOL_MONEY 12
#define wxSCI_REBOL_ISSUE 13
#define wxSCI_REBOL_TAG 14
#define wxSCI_REBOL_FILE 15
#define wxSCI_REBOL_EMAIL 16
#define wxSCI_REBOL_URL 17
#define wxSCI_REBOL_DATE 18
#define wxSCI_REBOL_TIME 19
#define wxSCI_REBOL_IDENTIFIER 20
#define wxSCI_REBOL_WORD 21
#define wxSCI_REBOL_WORD2 22
#define wxSCI_REBOL_WORD3 23
#define wxSCI_REBOL_WORD4 24
#define wxSCI_REBOL_WORD5 25
#define wxSCI_REBOL_WORD6 26
#define wxSCI_REBOL_WORD7 27
#define wxSCI_REBOL_WORD8 28
// Lexical states for SCLEX_SQL
#define wxSCI_SQL_DEFAULT 0
#define wxSCI_SQL_COMMENT 1
#define wxSCI_SQL_COMMENTLINE 2
#define wxSCI_SQL_COMMENTDOC 3
#define wxSCI_SQL_NUMBER 4
#define wxSCI_SQL_WORD 5
#define wxSCI_SQL_STRING 6
#define wxSCI_SQL_CHARACTER 7
#define wxSCI_SQL_SQLPLUS 8
#define wxSCI_SQL_SQLPLUS_PROMPT 9
#define wxSCI_SQL_OPERATOR 10
#define wxSCI_SQL_IDENTIFIER 11
#define wxSCI_SQL_SQLPLUS_COMMENT 13
#define wxSCI_SQL_COMMENTLINEDOC 15
#define wxSCI_SQL_WORD2 16
#define wxSCI_SQL_COMMENTDOCKEYWORD 17
#define wxSCI_SQL_COMMENTDOCKEYWORDERROR 18
#define wxSCI_SQL_USER1 19
#define wxSCI_SQL_USER2 20
#define wxSCI_SQL_USER3 21
#define wxSCI_SQL_USER4 22
#define wxSCI_SQL_QUOTEDIDENTIFIER 23
// Lexical states for SCLEX_SMALLTALK
#define wxSCI_ST_DEFAULT 0
#define wxSCI_ST_STRING 1
#define wxSCI_ST_NUMBER 2
#define wxSCI_ST_COMMENT 3
#define wxSCI_ST_SYMBOL 4
#define wxSCI_ST_BINARY 5
#define wxSCI_ST_BOOL 6
#define wxSCI_ST_SELF 7
#define wxSCI_ST_SUPER 8
#define wxSCI_ST_NIL 9
#define wxSCI_ST_GLOBAL 10
#define wxSCI_ST_RETURN 11
#define wxSCI_ST_SPECIAL 12
#define wxSCI_ST_KWSEND 13
#define wxSCI_ST_ASSIGN 14
#define wxSCI_ST_CHARACTER 15
#define wxSCI_ST_SPEC_SEL 16
// Lexical states for SCLEX_FLAGSHIP (clipper)
#define wxSCI_FS_DEFAULT 0
#define wxSCI_FS_COMMENT 1
#define wxSCI_FS_COMMENTLINE 2
#define wxSCI_FS_COMMENTDOC 3
#define wxSCI_FS_COMMENTLINEDOC 4
#define wxSCI_FS_COMMENTDOCKEYWORD 5
#define wxSCI_FS_COMMENTDOCKEYWORDERROR 6
#define wxSCI_FS_KEYWORD 7
#define wxSCI_FS_KEYWORD2 8
#define wxSCI_FS_KEYWORD3 9
#define wxSCI_FS_KEYWORD4 10
#define wxSCI_FS_NUMBER 11
#define wxSCI_FS_STRING 12
#define wxSCI_FS_PREPROCESSOR 13
#define wxSCI_FS_OPERATOR 14
#define wxSCI_FS_IDENTIFIER 15
#define wxSCI_FS_DATE 16
#define wxSCI_FS_STRINGEOL 17
#define wxSCI_FS_CONSTANT 18
#define wxSCI_FS_ASM 19
#define wxSCI_FS_LABEL 20
#define wxSCI_FS_ERROR 21
#define wxSCI_FS_HEXNUMBER 22
#define wxSCI_FS_BINNUMBER 23
// Lexical states for SCLEX_CSOUND
#define wxSCI_CSOUND_DEFAULT 0
#define wxSCI_CSOUND_COMMENT 1
#define wxSCI_CSOUND_NUMBER 2
#define wxSCI_CSOUND_OPERATOR 3
#define wxSCI_CSOUND_INSTR 4
#define wxSCI_CSOUND_IDENTIFIER 5
#define wxSCI_CSOUND_OPCODE 6
#define wxSCI_CSOUND_HEADERSTMT 7
#define wxSCI_CSOUND_USERKEYWORD 8
#define wxSCI_CSOUND_COMMENTBLOCK 9
#define wxSCI_CSOUND_PARAM 10
#define wxSCI_CSOUND_ARATE_VAR 11
#define wxSCI_CSOUND_KRATE_VAR 12
#define wxSCI_CSOUND_IRATE_VAR 13
#define wxSCI_CSOUND_GLOBAL_VAR 14
#define wxSCI_CSOUND_STRINGEOL 15
// Lexical states for SCLEX_INNOSETUP
#define wxSCI_INNO_DEFAULT 0
#define wxSCI_INNO_COMMENT 1
#define wxSCI_INNO_KEYWORD 2
#define wxSCI_INNO_PARAMETER 3
#define wxSCI_INNO_SECTION 4
#define wxSCI_INNO_PREPROC 5
#define wxSCI_INNO_PREPROC_INLINE 6
#define wxSCI_INNO_INLINE_EXPANSION 6
#define wxSCI_INNO_COMMENT_PASCAL 7
#define wxSCI_INNO_KEYWORD_PASCAL 8
#define wxSCI_INNO_KEYWORD_USER 9
#define wxSCI_INNO_STRING_DOUBLE 10
#define wxSCI_INNO_STRING_SINGLE 11
#define wxSCI_INNO_IDENTIFIER 12
// Lexical states for SCLEX_OPAL
#define wxSCI_OPAL_SPACE 0
#define wxSCI_OPAL_COMMENT_BLOCK 1
#define wxSCI_OPAL_COMMENT_LINE 2
#define wxSCI_OPAL_INTEGER 3
#define wxSCI_OPAL_KEYWORD 4
#define wxSCI_OPAL_SORT 5
#define wxSCI_OPAL_STRING 6
#define wxSCI_OPAL_PAR 7
#define wxSCI_OPAL_BOOL_CONST 8
#define wxSCI_OPAL_DEFAULT 32
// Lexical states for SCLEX_SPICE
#define wxSCI_SPICE_DEFAULT 0
#define wxSCI_SPICE_IDENTIFIER 1
#define wxSCI_SPICE_KEYWORD 2
#define wxSCI_SPICE_KEYWORD2 3
#define wxSCI_SPICE_KEYWORD3 4
#define wxSCI_SPICE_NUMBER 5
#define wxSCI_SPICE_DELIMITER 6
#define wxSCI_SPICE_VALUE 7
#define wxSCI_SPICE_COMMENTLINE 8
// Lexical states for SCLEX_CMAKE
#define wxSCI_CMAKE_DEFAULT 0
#define wxSCI_CMAKE_COMMENT 1
#define wxSCI_CMAKE_STRINGDQ 2
#define wxSCI_CMAKE_STRINGLQ 3
#define wxSCI_CMAKE_STRINGRQ 4
#define wxSCI_CMAKE_COMMANDS 5
#define wxSCI_CMAKE_PARAMETERS 6
#define wxSCI_CMAKE_VARIABLE 7
#define wxSCI_CMAKE_USERDEFINED 8
#define wxSCI_CMAKE_WHILEDEF 9
#define wxSCI_CMAKE_FOREACHDEF 10
#define wxSCI_CMAKE_IFDEFINEDEF 11
#define wxSCI_CMAKE_MACRODEF 12
#define wxSCI_CMAKE_STRINGVAR 13
#define wxSCI_CMAKE_NUMBER 14
// Lexical states for SCLEX_GAP
#define wxSCI_GAP_DEFAULT 0
#define wxSCI_GAP_IDENTIFIER 1
#define wxSCI_GAP_KEYWORD 2
#define wxSCI_GAP_KEYWORD2 3
#define wxSCI_GAP_KEYWORD3 4
#define wxSCI_GAP_KEYWORD4 5
#define wxSCI_GAP_STRING 6
#define wxSCI_GAP_CHAR 7
#define wxSCI_GAP_OPERATOR 8
#define wxSCI_GAP_COMMENT 9
#define wxSCI_GAP_NUMBER 10
#define wxSCI_GAP_STRINGEOL 11
// Lexical state for SCLEX_PLM
#define wxSCI_PLM_DEFAULT 0
#define wxSCI_PLM_COMMENT 1
#define wxSCI_PLM_STRING 2
#define wxSCI_PLM_NUMBER 3
#define wxSCI_PLM_IDENTIFIER 4
#define wxSCI_PLM_OPERATOR 5
#define wxSCI_PLM_CONTROL 6
#define wxSCI_PLM_KEYWORD 7
// Lexical state for SCLEX_PROGRESS
#define wxSCI_4GL_DEFAULT 0
#define wxSCI_4GL_NUMBER 1
#define wxSCI_4GL_WORD 2
#define wxSCI_4GL_STRING 3
#define wxSCI_4GL_CHARACTER 4
#define wxSCI_4GL_PREPROCESSOR 5
#define wxSCI_4GL_OPERATOR 6
#define wxSCI_4GL_IDENTIFIER 7
#define wxSCI_4GL_BLOCK 8
#define wxSCI_4GL_END 9
#define wxSCI_4GL_COMMENT1 10
#define wxSCI_4GL_COMMENT2 11
#define wxSCI_4GL_COMMENT3 12
#define wxSCI_4GL_COMMENT4 13
#define wxSCI_4GL_COMMENT5 14
#define wxSCI_4GL_COMMENT6 15
#define wxSCI_4GL_DEFAULT_ 16
#define wxSCI_4GL_NUMBER_ 17
#define wxSCI_4GL_WORD_ 18
#define wxSCI_4GL_STRING_ 19
#define wxSCI_4GL_CHARACTER_ 20
#define wxSCI_4GL_PREPROCESSOR_ 21
#define wxSCI_4GL_OPERATOR_ 22
#define wxSCI_4GL_IDENTIFIER_ 23
#define wxSCI_4GL_BLOCK_ 24
#define wxSCI_4GL_END_ 25
#define wxSCI_4GL_COMMENT1_ 26
#define wxSCI_4GL_COMMENT2_ 27
#define wxSCI_4GL_COMMENT3_ 28
#define wxSCI_4GL_COMMENT4_ 29
#define wxSCI_4GL_COMMENT5_ 30
#define wxSCI_4GL_COMMENT6_ 31
// Lexical states for SCLEX_ABAQUS
#define wxSCI_ABAQUS_DEFAULT 0
#define wxSCI_ABAQUS_COMMENT 1
#define wxSCI_ABAQUS_COMMENTBLOCK 2
#define wxSCI_ABAQUS_NUMBER 3
#define wxSCI_ABAQUS_STRING 4
#define wxSCI_ABAQUS_OPERATOR 5
#define wxSCI_ABAQUS_WORD 6
#define wxSCI_ABAQUS_PROCESSOR 7
#define wxSCI_ABAQUS_COMMAND 8
#define wxSCI_ABAQUS_SLASHCOMMAND 9
#define wxSCI_ABAQUS_STARCOMMAND 10
#define wxSCI_ABAQUS_ARGUMENT 11
#define wxSCI_ABAQUS_FUNCTION 12
// Lexical states for SCLEX_ASYMPTOTE
#define wxSCI_ASY_DEFAULT 0
#define wxSCI_ASY_COMMENT 1
#define wxSCI_ASY_COMMENTLINE 2
#define wxSCI_ASY_NUMBER 3
#define wxSCI_ASY_WORD 4
#define wxSCI_ASY_STRING 5
#define wxSCI_ASY_CHARACTER 6
#define wxSCI_ASY_OPERATOR 7
#define wxSCI_ASY_IDENTIFIER 8
#define wxSCI_ASY_STRINGEOL 9
#define wxSCI_ASY_COMMENTLINEDOC 10
#define wxSCI_ASY_WORD2 11
// Lexical states for SCLEX_R
#define wxSCI_R_DEFAULT 0
#define wxSCI_R_COMMENT 1
#define wxSCI_R_KWORD 2
#define wxSCI_R_BASEKWORD 3
#define wxSCI_R_OTHERKWORD 4
#define wxSCI_R_NUMBER 5
#define wxSCI_R_STRING 6
#define wxSCI_R_STRING2 7
#define wxSCI_R_OPERATOR 8
#define wxSCI_R_IDENTIFIER 9
#define wxSCI_R_INFIX 10
#define wxSCI_R_INFIXEOL 11
// Lexical state for SCLEX_MAGIKSF
#define wxSCI_MAGIK_DEFAULT 0
#define wxSCI_MAGIK_COMMENT 1
#define wxSCI_MAGIK_HYPER_COMMENT 16
#define wxSCI_MAGIK_STRING 2
#define wxSCI_MAGIK_CHARACTER 3
#define wxSCI_MAGIK_NUMBER 4
#define wxSCI_MAGIK_IDENTIFIER 5
#define wxSCI_MAGIK_OPERATOR 6
#define wxSCI_MAGIK_FLOW 7
#define wxSCI_MAGIK_CONTAINER 8
#define wxSCI_MAGIK_BRACKET_BLOCK 9
#define wxSCI_MAGIK_BRACE_BLOCK 10
#define wxSCI_MAGIK_SQBRACKET_BLOCK 11
#define wxSCI_MAGIK_UNKNOWN_KEYWORD 12
#define wxSCI_MAGIK_KEYWORD 13
#define wxSCI_MAGIK_PRAGMA 14
#define wxSCI_MAGIK_SYMBOL 15
// Lexical state for SCLEX_POWERSHELL
#define wxSCI_POWERSHELL_DEFAULT 0
#define wxSCI_POWERSHELL_COMMENT 1
#define wxSCI_POWERSHELL_STRING 2
#define wxSCI_POWERSHELL_CHARACTER 3
#define wxSCI_POWERSHELL_NUMBER 4
#define wxSCI_POWERSHELL_VARIABLE 5
#define wxSCI_POWERSHELL_OPERATOR 6
#define wxSCI_POWERSHELL_IDENTIFIER 7
#define wxSCI_POWERSHELL_KEYWORD 8
#define wxSCI_POWERSHELL_CMDLET 9
#define wxSCI_POWERSHELL_ALIAS 10
// Lexical state for SCLEX_MYSQL
#define wxSCI_MYSQL_DEFAULT 0
#define wxSCI_MYSQL_COMMENT 1
#define wxSCI_MYSQL_COMMENTLINE 2
#define wxSCI_MYSQL_VARIABLE 3
#define wxSCI_MYSQL_SYSTEMVARIABLE 4
#define wxSCI_MYSQL_KNOWNSYSTEMVARIABLE 5
#define wxSCI_MYSQL_NUMBER 6
#define wxSCI_MYSQL_MAJORKEYWORD 7
#define wxSCI_MYSQL_KEYWORD 8
#define wxSCI_MYSQL_DATABASEOBJECT 9
#define wxSCI_MYSQL_PROCEDUREKEYWORD 10
#define wxSCI_MYSQL_STRING 11
#define wxSCI_MYSQL_SQSTRING 12
#define wxSCI_MYSQL_DQSTRING 13
#define wxSCI_MYSQL_OPERATOR 14
#define wxSCI_MYSQL_FUNCTION 15
#define wxSCI_MYSQL_IDENTIFIER 16
#define wxSCI_MYSQL_QUOTEDIDENTIFIER 17
#define wxSCI_MYSQL_USER1 18
#define wxSCI_MYSQL_USER2 19
#define wxSCI_MYSQL_USER3 20
#define wxSCI_MYSQL_HIDDENCOMMAND 21
// Lexical state for SCLEX_PO
#define wxSCI_PO_DEFAULT 0
#define wxSCI_PO_COMMENT 1
#define wxSCI_PO_MSGID 2
#define wxSCI_PO_MSGID_TEXT 3
#define wxSCI_PO_MSGSTR 4
#define wxSCI_PO_MSGSTR_TEXT 5
#define wxSCI_PO_MSGCTXT 6
#define wxSCI_PO_MSGCTXT_TEXT 7
#define wxSCI_PO_FUZZY 8
// Lexical states for SCLEX_PASCAL
#define wxSCI_PAS_DEFAULT 0
#define wxSCI_PAS_IDENTIFIER 1
#define wxSCI_PAS_COMMENT 2
#define wxSCI_PAS_COMMENT2 3
#define wxSCI_PAS_COMMENTLINE 4
#define wxSCI_PAS_PREPROCESSOR 5
#define wxSCI_PAS_PREPROCESSOR2 6
#define wxSCI_PAS_NUMBER 7
#define wxSCI_PAS_HEXNUMBER 8
#define wxSCI_PAS_WORD 9
#define wxSCI_PAS_STRING 10
#define wxSCI_PAS_STRINGEOL 11
#define wxSCI_PAS_CHARACTER 12
#define wxSCI_PAS_OPERATOR 13
#define wxSCI_PAS_ASM 14
// Lexical state for SCLEX_SORCUS
#define wxSCI_SORCUS_DEFAULT 0
#define wxSCI_SORCUS_COMMAND 1
#define wxSCI_SORCUS_PARAMETER 2
#define wxSCI_SORCUS_COMMENTLINE 3
#define wxSCI_SORCUS_STRING 4
#define wxSCI_SORCUS_STRINGEOL 5
#define wxSCI_SORCUS_IDENTIFIER 6
#define wxSCI_SORCUS_OPERATOR 7
#define wxSCI_SORCUS_NUMBER 8
#define wxSCI_SORCUS_CONSTANT 9
// Lexical state for SCLEX_POWERPRO
#define wxSCI_POWERPRO_DEFAULT 0
#define wxSCI_POWERPRO_COMMENTBLOCK 1
#define wxSCI_POWERPRO_COMMENTLINE 2
#define wxSCI_POWERPRO_NUMBER 3
#define wxSCI_POWERPRO_WORD 4
#define wxSCI_POWERPRO_WORD2 5
#define wxSCI_POWERPRO_WORD3 6
#define wxSCI_POWERPRO_WORD4 7
#define wxSCI_POWERPRO_DOUBLEQUOTEDSTRING 8
#define wxSCI_POWERPRO_SINGLEQUOTEDSTRING 9
#define wxSCI_POWERPRO_LINECONTINUE 10
#define wxSCI_POWERPRO_OPERATOR 11
#define wxSCI_POWERPRO_IDENTIFIER 12
#define wxSCI_POWERPRO_STRINGEOL 13
#define wxSCI_POWERPRO_VERBATIM 14
#define wxSCI_POWERPRO_ALTQUOTE 15
#define wxSCI_POWERPRO_FUNCTION 16
// Lexical states for SCLEX_SML
#define wxSCI_SML_DEFAULT 0
#define wxSCI_SML_IDENTIFIER 1
#define wxSCI_SML_TAGNAME 2
#define wxSCI_SML_KEYWORD 3
#define wxSCI_SML_KEYWORD2 4
#define wxSCI_SML_KEYWORD3 5
#define wxSCI_SML_LINENUM 6
#define wxSCI_SML_OPERATOR 7
#define wxSCI_SML_NUMBER 8
#define wxSCI_SML_CHAR 9
#define wxSCI_SML_STRING 11
#define wxSCI_SML_COMMENT 12
#define wxSCI_SML_COMMENT1 13
#define wxSCI_SML_COMMENT2 14
#define wxSCI_SML_COMMENT3 15
//}}}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// Commands that can be bound to keystrokes section {{{
// Redoes the next action on the undo history.
#define wxSCI_CMD_REDO 2011
// Select all the text in the document.
#define wxSCI_CMD_SELECTALL 2013
// Undo one action in the undo history.
#define wxSCI_CMD_UNDO 2176
// Cut the selection to the clipboard.
#define wxSCI_CMD_CUT 2177
// Copy the selection to the clipboard.
#define wxSCI_CMD_COPY 2178
// Paste the contents of the clipboard into the document replacing the selection.
#define wxSCI_CMD_PASTE 2179
// Clear the selection.
#define wxSCI_CMD_CLEAR 2180
// Move caret down one line.
#define wxSCI_CMD_LINEDOWN 2300
// Move caret down one line extending selection to new caret position.
#define wxSCI_CMD_LINEDOWNEXTEND 2301
// Move caret up one line.
#define wxSCI_CMD_LINEUP 2302
// Move caret up one line extending selection to new caret position.
#define wxSCI_CMD_LINEUPEXTEND 2303
// Move caret left one character.
#define wxSCI_CMD_CHARLEFT 2304
// Move caret left one character extending selection to new caret position.
#define wxSCI_CMD_CHARLEFTEXTEND 2305
// Move caret right one character.
#define wxSCI_CMD_CHARRIGHT 2306
// Move caret right one character extending selection to new caret position.
#define wxSCI_CMD_CHARRIGHTEXTEND 2307
// Move caret left one word.
#define wxSCI_CMD_WORDLEFT 2308
// Move caret left one word extending selection to new caret position.
#define wxSCI_CMD_WORDLEFTEXTEND 2309
// Move caret right one word.
#define wxSCI_CMD_WORDRIGHT 2310
// Move caret right one word extending selection to new caret position.
#define wxSCI_CMD_WORDRIGHTEXTEND 2311
// Move caret to first position on line.
#define wxSCI_CMD_HOME 2312
// Move caret to first position on line extending selection to new caret position.
#define wxSCI_CMD_HOMEEXTEND 2313
// Move caret to last position on line.
#define wxSCI_CMD_LINEEND 2314
// Move caret to last position on line extending selection to new caret position.
#define wxSCI_CMD_LINEENDEXTEND 2315
// Move caret to first position in document.
#define wxSCI_CMD_DOCUMENTSTART 2316
// Move caret to first position in document extending selection to new caret position.
#define wxSCI_CMD_DOCUMENTSTARTEXTEND 2317
// Move caret to last position in document.
#define wxSCI_CMD_DOCUMENTEND 2318
// Move caret to last position in document extending selection to new caret position.
#define wxSCI_CMD_DOCUMENTENDEXTEND 2319
// Move caret one page up.
#define wxSCI_CMD_PAGEUP 2320
// Move caret one page up extending selection to new caret position.
#define wxSCI_CMD_PAGEUPEXTEND 2321
// Move caret one page down.
#define wxSCI_CMD_PAGEDOWN 2322
// Move caret one page down extending selection to new caret position.
#define wxSCI_CMD_PAGEDOWNEXTEND 2323
// Switch from insert to overtype mode or the reverse.
#define wxSCI_CMD_EDITTOGGLEOVERTYPE 2324
// Cancel any modes such as call tip or auto-completion list display.
#define wxSCI_CMD_CANCEL 2325
// Delete the selection or if no selection, the character before the caret.
#define wxSCI_CMD_DELETEBACK 2326
// If selection is empty or all on one line replace the selection with a tab character.
// If more than one line selected, indent the lines.
#define wxSCI_CMD_TAB 2327
// Dedent the selected lines.
#define wxSCI_CMD_BACKTAB 2328
// Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
#define wxSCI_CMD_NEWLINE 2329
// Insert a Form Feed character.
#define wxSCI_CMD_FORMFEED 2330
// Move caret to before first visible character on line.
// If already there move to first character on line.
#define wxSCI_CMD_VCHOME 2331
// Like VCHome but extending selection to new caret position.
#define wxSCI_CMD_VCHOMEEXTEND 2332
// Magnify the displayed text by increasing the sizes by 1 point.
#define wxSCI_CMD_ZOOMIN 2333
// Make the displayed text smaller by decreasing the sizes by 1 point.
#define wxSCI_CMD_ZOOMOUT 2334
// Delete the word to the left of the caret.
#define wxSCI_CMD_DELWORDLEFT 2335
// Delete the word to the right of the caret.
#define wxSCI_CMD_DELWORDRIGHT 2336
// Delete the word to the right of the caret, but not the trailing non-word characters.
#define wxSCI_CMD_DELWORDRIGHTEND 2518
// Cut the line containing the caret.
#define wxSCI_CMD_LINECUT 2337
// Delete the line containing the caret.
#define wxSCI_CMD_LINEDELETE 2338
// Switch the current line with the previous.
#define wxSCI_CMD_LINETRANSPOSE 2339
// Duplicate the current line.
#define wxSCI_CMD_LINEDUPLICATE 2404
// Transform the selection to lower case.
#define wxSCI_CMD_LOWERCASE 2340
// Transform the selection to upper case.
#define wxSCI_CMD_UPPERCASE 2341
// Scroll the document down, keeping the caret visible.
#define wxSCI_CMD_LINESCROLLDOWN 2342
// Scroll the document up, keeping the caret visible.
#define wxSCI_CMD_LINESCROLLUP 2343
// Delete the selection or if no selection, the character before the caret.
// Will not delete the character before at the start of a line.
#define wxSCI_CMD_DELETEBACKNOTLINE 2344
// Move caret to first position on display line.
#define wxSCI_CMD_HOMEDISPLAY 2345
// Move caret to first position on display line extending selection to
// new caret position.
#define wxSCI_CMD_HOMEDISPLAYEXTEND 2346
// Move caret to last position on display line.
#define wxSCI_CMD_LINEENDDISPLAY 2347
// Move caret to last position on display line extending selection to new
// caret position.
#define wxSCI_CMD_LINEENDDISPLAYEXTEND 2348
// These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)?
// except they behave differently when word-wrap is enabled:
// They go first to the start / end of the display line, like (Home|LineEnd)Display
// The difference is that, the cursor is already at the point, it goes on to the start
// or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.
#define wxSCI_CMD_HOMEWRAP 2349
#define wxSCI_CMD_HOMEWRAPEXTEND 2450
#define wxSCI_CMD_LINEENDWRAP 2451
#define wxSCI_CMD_LINEENDWRAPEXTEND 2452
#define wxSCI_CMD_VCHOMEWRAP 2453
#define wxSCI_CMD_VCHOMEWRAPEXTEND 2454
// Copy the line containing the caret.
#define wxSCI_CMD_LINECOPY 2455
// Move to the previous change in capitalisation.
#define wxSCI_CMD_WORDPARTLEFT 2390
// Move to the previous change in capitalisation extending selection
// to new caret position.
#define wxSCI_CMD_WORDPARTLEFTEXTEND 2391
// Move to the change next in capitalisation.
#define wxSCI_CMD_WORDPARTRIGHT 2392
// Move to the next change in capitalisation extending selection
// to new caret position.
#define wxSCI_CMD_WORDPARTRIGHTEXTEND 2393
// Delete back from the current position to the start of the line.
#define wxSCI_CMD_DELLINELEFT 2395
// Delete forwards from the current position to the end of the line.
#define wxSCI_CMD_DELLINERIGHT 2396
// Move caret between paragraphs (delimited by empty lines).
#define wxSCI_CMD_PARADOWN 2413
#define wxSCI_CMD_PARADOWNEXTEND 2414
#define wxSCI_CMD_PARAUP 2415
#define wxSCI_CMD_PARAUPEXTEND 2416
// Move caret down one line, extending rectangular selection to new caret position.
#define wxSCI_CMD_LINEDOWNRECTEXTEND 2426
// Move caret up one line, extending rectangular selection to new caret position.
#define wxSCI_CMD_LINEUPRECTEXTEND 2427
// Move caret left one character, extending rectangular selection to new caret position.
#define wxSCI_CMD_CHARLEFTRECTEXTEND 2428
// Move caret right one character, extending rectangular selection to new caret position.
#define wxSCI_CMD_CHARRIGHTRECTEXTEND 2429
// Move caret to first position on line, extending rectangular selection to new caret position.
#define wxSCI_CMD_HOMERECTEXTEND 2430
// Move caret to before first visible character on line.
// If already there move to first character on line.
// In either case, extend rectangular selection to new caret position.
#define wxSCI_CMD_VCHOMERECTEXTEND 2431
// Move caret to last position on line, extending rectangular selection to new caret position.
#define wxSCI_CMD_LINEENDRECTEXTEND 2432
// Move caret one page up, extending rectangular selection to new caret position.
#define wxSCI_CMD_PAGEUPRECTEXTEND 2433
// Move caret one page down, extending rectangular selection to new caret position.
#define wxSCI_CMD_PAGEDOWNRECTEXTEND 2434
// Move caret to top of page, or one page up if already at top of page.
#define wxSCI_CMD_STUTTEREDPAGEUP 2435
// Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
#define wxSCI_CMD_STUTTEREDPAGEUPEXTEND 2436
// Move caret to bottom of page, or one page down if already at bottom of page.
#define wxSCI_CMD_STUTTEREDPAGEDOWN 2437
// Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
#define wxSCI_CMD_STUTTEREDPAGEDOWNEXTEND 2438
// Move caret left one word, position cursor at end of word.
#define wxSCI_CMD_WORDLEFTEND 2439
// Move caret left one word, position cursor at end of word, extending selection to new caret position.
#define wxSCI_CMD_WORDLEFTENDEXTEND 2440
// Move caret right one word, position cursor at end of word.
#define wxSCI_CMD_WORDRIGHTEND 2441
// Move caret right one word, position cursor at end of word, extending selection to new caret position.
#define wxSCI_CMD_WORDRIGHTENDEXTEND 2442
//}}}
//----------------------------------------------------------------------
class ScintillaWX; // forward declare
class WordList;
struct SCNotification;
#ifndef SWIG
//extern const char wxSTCNameStr[];
class SDK_DLL wxScintillaCtrl;
class SDK_DLL wxStyledTextEvent;
#endif
//----------------------------------------------------------------------
class SDK_DLL wxScintillaCtrl : public wxControl,
#if wxUSE_TEXTCTRL
public wxTextCtrlIface
#else // !wxUSE_TEXTCTRL
public wxTextEntryBase
#endif // wxUSE_TEXTCTRL/!wxUSE_TEXTCTRL
{
public:
#ifdef SWIG
%pythonAppend wxScintillaCtrl "self._setOORInfo(self)"
%pythonAppend wxScintillaCtrl() ""
wxScintillaCtrl(wxWindow *parent, wxWindowID id=wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxPySTCNameStr);
%RenameCtor(PreStyledTextCtrl, wxScintillaCtrl());
#else
wxScintillaCtrl(wxWindow *parent, wxWindowID id=wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = "wxScintillaCtrl");
wxScintillaCtrl() { m_swx = NULL; }
~wxScintillaCtrl();
#endif
bool Create(wxWindow *parent, wxWindowID id=wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = "wxScintillaCtrl");
//----------------------------------------------------------------------
// Generated method declaration section {{{
// Add text to the document at current position.
void AddText(const wxString& text);
// Add array of cells to document.
void AddStyledText(const wxMemoryBuffer& data);
// Insert string at a position.
void InsertText(int pos, const wxString& text);
// Delete all text in the document.
void ClearAll();
// Set all style bytes to 0, remove all folding information.
void ClearDocumentStyle();
// Returns the number of bytes in the document.
int GetLength() const;
// Returns the character byte at the position.
int GetCharAt(int pos) const;
// Returns the position of the caret.
int GetCurrentPos() const;
// Returns the position of the opposite end of the selection to the caret.
int GetAnchor() const;
// Returns the style byte at the position.
int GetStyleAt(int pos) const;
// Redoes the next action on the undo history.
void Redo();
// Choose between collecting actions into the undo
// history and discarding them.
void SetUndoCollection(bool collectUndo);
// Select all the text in the document.
void SelectAll();
// Remember the current position in the undo history as the position
// at which the document was saved.
void SetSavePoint();
// Retrieve a buffer of cells.
wxMemoryBuffer GetStyledText(int startPos, int endPos);
// Are there any redoable actions in the undo history?
bool CanRedo() const;
// Retrieve the line number at which a particular marker is located.
int MarkerLineFromHandle(int handle);
// Delete a marker.
void MarkerDeleteHandle(int handle);
// Is undo history being collected?
bool GetUndoCollection() const;
// Are white space characters currently visible?
// Returns one of SCWS_* constants.
int GetViewWhiteSpace() const;
// Make white space characters invisible, always visible or visible outside indentation.
void SetViewWhiteSpace(int viewWS);
// Find the position from a point within the window.
int PositionFromPoint(wxPoint pt) const;
// Find the position from a point within the window but return
// INVALID_POSITION if not close to text.
int PositionFromPointClose(int x, int y);
// Set caret to start of a line and ensure it is visible.
void GotoLine(int line);
// Set caret to a position and ensure it is visible.
void GotoPos(int pos);
// Set the selection anchor to a position. The anchor is the opposite
// end of the selection from the caret.
void SetAnchor(int posAnchor);
// Retrieve the text of the line containing the caret.
// Returns the index of the caret on the line.
#ifdef SWIG
wxString GetCurLine(int* OUTPUT);
#else
wxString GetCurLine(int* linePos=NULL);
#endif
// Retrieve the position of the last correctly styled character.
int GetEndStyled() const;
// Convert all line endings in the document to one mode.
void ConvertEOLs(int eolMode);
// Retrieve the current end of line mode - one of CRLF, CR, or LF.
int GetEOLMode() const;
// Set the current end of line mode.
void SetEOLMode(int eolMode);
// Set the current styling position to pos and the styling mask to mask.
// The styling mask can be used to protect some bits in each styling byte from modification.
void StartStyling(int pos, int mask);
// Change style from current styling position for length characters to a style
// and move the current styling position to after this newly styled segment.
void SetStyling(int length, int style);
// Is drawing done first into a buffer or direct to the screen?
bool GetBufferedDraw() const;
// If drawing is buffered then each line of text is drawn into a bitmap buffer
// before drawing it to the screen to avoid flicker.
void SetBufferedDraw(bool buffered);
// Change the visible size of a tab to be a multiple of the width of a space character.
void SetTabWidth(int tabWidth);
// Retrieve the visible size of a tab.
int GetTabWidth() const;
// Set the code page used to interpret the bytes of the document as characters.
void SetCodePage(int codePage);
// Set the symbol used for a particular marker number,
// and optionally the fore and background colours.
void MarkerDefine(int markerNumber, int markerSymbol,
const wxColour& foreground = wxNullColour,
const wxColour& background = wxNullColour);
// Set the foreground colour used for a particular marker number.
void MarkerSetForeground(int markerNumber, const wxColour& fore);
// Set the background colour used for a particular marker number.
void MarkerSetBackground(int markerNumber, const wxColour& back);
// Add a marker to a line, returning an ID which can be used to find or delete the marker.
int MarkerAdd(int line, int markerNumber);
// Delete a marker from a line.
void MarkerDelete(int line, int markerNumber);
// Delete all markers with a particular number from all lines.
void MarkerDeleteAll(int markerNumber);
// Get a bit mask of all the markers set on a line.
int MarkerGet(int line);
// Find the next line after lineStart that includes a marker in mask.
int MarkerNext(int lineStart, int markerMask);
// Find the previous line before lineStart that includes a marker in mask.
int MarkerPrevious(int lineStart, int markerMask);
// Define a marker from a bitmap
void MarkerDefineBitmap(int markerNumber, const wxBitmap& bmp);
// Add a set of markers to a line.
void MarkerAddSet(int line, int set);
// Set the alpha used for a marker that is drawn in the text area, not the margin.
void MarkerSetAlpha(int markerNumber, int alpha);
// Set a margin to be either numeric or symbolic.
void SetMarginType(int margin, int marginType);
// Retrieve the type of a margin.
int GetMarginType(int margin) const;
// Set the width of a margin to a width expressed in pixels.
void SetMarginWidth(int margin, int pixelWidth);
// Retrieve the width of a margin in pixels.
int GetMarginWidth(int margin) const;
// Set a mask that determines which markers are displayed in a margin.
void SetMarginMask(int margin, int mask);
// Retrieve the marker mask of a margin.
int GetMarginMask(int margin) const;
// Make a margin sensitive or insensitive to mouse clicks.
void SetMarginSensitive(int margin, bool sensitive);
// Retrieve the mouse click sensitivity of a margin.
bool GetMarginSensitive(int margin) const;
// Clear all the styles and make equivalent to the global default style.
void StyleClearAll();
// Set the foreground colour of a style.
void StyleSetForeground(int style, const wxColour& fore);
// Set the background colour of a style.
void StyleSetBackground(int style, const wxColour& back);
// Set a style to be bold or not.
void StyleSetBold(int style, bool bold);
// Set a style to be italic or not.
void StyleSetItalic(int style, bool italic);
// Set the size of characters of a style.
void StyleSetSize(int style, int sizePoints);
// Set the font of a style.
void StyleSetFaceName(int style, const wxString& fontName);
// Set a style to have its end of line filled or not.
void StyleSetEOLFilled(int style, bool filled);
// Reset the default style to its state at startup
void StyleResetDefault();
// Set a style to be underlined or not.
void StyleSetUnderline(int style, bool underline);
// Get the foreground colour of a style.
wxColour StyleGetForeground(int style) const;
// Get the background colour of a style.
wxColour StyleGetBackground(int style) const;
// Get is a style bold or not.
bool StyleGetBold(int style) const;
// Get is a style italic or not.
bool StyleGetItalic(int style) const;
// Get the size of characters of a style.
int StyleGetSize(int style) const;
// Get the font facename of a style
wxString StyleGetFaceName(int style);
// Get is a style to have its end of line filled or not.
bool StyleGetEOLFilled(int style) const;
// Get is a style underlined or not.
bool StyleGetUnderline(int style) const;
// Get is a style mixed case, or to force upper or lower case.
int StyleGetCase(int style) const;
// Get the character get of the font in a style.
int StyleGetCharacterSet(int style) const;
// Get is a style visible or not.
bool StyleGetVisible(int style) const;
// Get is a style changeable or not (read only).
// Experimental feature, currently buggy.
bool StyleGetChangeable(int style) const;
// Get is a style a hotspot or not.
bool StyleGetHotSpot(int style) const;
// Set a style to be mixed case, or to force upper or lower case.
void StyleSetCase(int style, int caseForce);
// Set a style to be a hotspot or not.
void StyleSetHotSpot(int style, bool hotspot);
// Set the foreground colour of the main and additional selections and whether to use this setting.
void SetSelForeground(bool useSetting, const wxColour& fore);
// Set the background colour of the main and additional selections and whether to use this setting.
void SetSelBackground(bool useSetting, const wxColour& back);
// Get the alpha of the selection.
int GetSelAlpha() const;
// Set the alpha of the selection.
void SetSelAlpha(int alpha);
// Is the selection end of line filled?
bool GetSelEOLFilled() const;
// Set the selection to have its end of line filled or not.
void SetSelEOLFilled(bool filled);
// Set the foreground colour of the caret.
void SetCaretForeground(const wxColour& fore);
// When key+modifier combination km is pressed perform msg.
void CmdKeyAssign(int key, int modifiers, int cmd);
// When key+modifier combination km is pressed do nothing.
void CmdKeyClear(int key, int modifiers);
// Drop all key mappings.
void CmdKeyClearAll();
// Set the styles for a segment of the document.
void SetStyleBytes(int length, char* styleBytes);
// Set a style to be visible or not.
void StyleSetVisible(int style, bool visible);
// Get the time in milliseconds that the caret is on and off.
int GetCaretPeriod() const;
// Get the time in milliseconds that the caret is on and off. 0 = steady on.
void SetCaretPeriod(int periodMilliseconds);
// Set the set of characters making up words for when moving or selecting by word.
// First sets defaults like SetCharsDefault.
void SetWordChars(const wxString& characters);
// Start a sequence of actions that is undone and redone as a unit.
// May be nested.
void BeginUndoAction();
// End a sequence of actions that is undone and redone as a unit.
void EndUndoAction();
// Set an indicator to plain, squiggle or TT.
void IndicatorSetStyle(int indic, int style);
// Retrieve the style of an indicator.
int IndicatorGetStyle(int indic) const;
// Set the foreground colour of an indicator.
void IndicatorSetForeground(int indic, const wxColour& fore);
// Retrieve the foreground colour of an indicator.
wxColour IndicatorGetForeground(int indic) const;
// Set an indicator to draw under text or over(default).
void IndicatorSetUnder(int indic, bool under);
// Retrieve whether indicator drawn under or over text.
bool IndicatorGetUnder(int indic) const;
// Set the foreground colour of all whitespace and whether to use this setting.
void SetWhitespaceForeground(bool useSetting, const wxColour& fore);
// Set the background colour of all whitespace and whether to use this setting.
void SetWhitespaceBackground(bool useSetting, const wxColour& back);
// Divide each styling byte into lexical class bits (default: 5) and indicator
// bits (default: 3). If a lexer requires more than 32 lexical states, then this
// is used to expand the possible states.
void SetStyleBits(int bits);
// Retrieve number of bits in style bytes used to hold the lexical state.
int GetStyleBits() const;
// Used to hold extra styling information for each line.
void SetLineState(int line, int state);
// Retrieve the extra styling information for a line.
int GetLineState(int line) const;
// Retrieve the last line number that has line state.
int GetMaxLineState() const;
// Is the background of the line containing the caret in a different colour?
bool GetCaretLineVisible() const;
// Display the background of the line containing the caret in a different colour.
void SetCaretLineVisible(bool show);
// Get the colour of the background of the line containing the caret.
wxColour GetCaretLineBackground() const;
// Set the colour of the background of the line containing the caret.
void SetCaretLineBackground(const wxColour& back);
// Set a style to be changeable or not (read only).
// Experimental feature, currently buggy.
void StyleSetChangeable(int style, bool changeable);
// Display a auto-completion list.
// The lenEntered parameter indicates how many characters before
// the caret should be used to provide context.
void AutoCompShow(int lenEntered, const wxString& itemList);
// Remove the auto-completion list from the screen.
void AutoCompCancel();
// Is there an auto-completion list visible?
bool AutoCompActive();
// Retrieve the position of the caret when the auto-completion list was displayed.
int AutoCompPosStart();
// User has selected an item so remove the list and insert the selection.
void AutoCompComplete();
// Define a set of character that when typed cancel the auto-completion list.
void AutoCompStops(const wxString& characterSet);
// Change the separator character in the string setting up an auto-completion list.
// Default is space but can be changed if items contain space.
void AutoCompSetSeparator(int separatorCharacter);
// Retrieve the auto-completion list separator character.
int AutoCompGetSeparator() const;
// Select the item in the auto-completion list that starts with a string.
void AutoCompSelect(const wxString& text);
// Should the auto-completion list be cancelled if the user backspaces to a
// position before where the box was created.
void AutoCompSetCancelAtStart(bool cancel);
// Retrieve whether auto-completion cancelled by backspacing before start.
bool AutoCompGetCancelAtStart() const;
// Define a set of characters that when typed will cause the autocompletion to
// choose the selected item.
void AutoCompSetFillUps(const wxString& characterSet);
// Should a single item auto-completion list automatically choose the item.
void AutoCompSetChooseSingle(bool chooseSingle);
// Retrieve whether a single item auto-completion list automatically choose the item.
bool AutoCompGetChooseSingle() const;
// Set whether case is significant when performing auto-completion searches.
void AutoCompSetIgnoreCase(bool ignoreCase);
// Retrieve state of ignore case flag.
bool AutoCompGetIgnoreCase() const;
// Display a list of strings and send notification when user chooses one.
void UserListShow(int listType, const wxString& itemList);
// Set whether or not autocompletion is hidden automatically when nothing matches.
void AutoCompSetAutoHide(bool autoHide);
// Retrieve whether or not autocompletion is hidden automatically when nothing matches.
bool AutoCompGetAutoHide() const;
// Set whether or not autocompletion deletes any word characters
// after the inserted text upon completion.
void AutoCompSetDropRestOfWord(bool dropRestOfWord);
// Retrieve whether or not autocompletion deletes any word characters
// after the inserted text upon completion.
bool AutoCompGetDropRestOfWord() const;
// Register an image for use in autocompletion lists.
void RegisterImage(int type, const wxBitmap& bmp);
// Clear all the registered images.
void ClearRegisteredImages();
// Retrieve the auto-completion list type-separator character.
int AutoCompGetTypeSeparator() const;
// Change the type-separator character in the string setting up an auto-completion list.
// Default is '?' but can be changed if items contain '?'.
void AutoCompSetTypeSeparator(int separatorCharacter);
// Set the maximum width, in characters, of auto-completion and user lists.
// Set to 0 to autosize to fit longest item, which is the default.
void AutoCompSetMaxWidth(int characterCount);
// Get the maximum width, in characters, of auto-completion and user lists.
int AutoCompGetMaxWidth() const;
// Set the maximum height, in rows, of auto-completion and user lists.
// The default is 5 rows.
void AutoCompSetMaxHeight(int rowCount);
// Set the maximum height, in rows, of auto-completion and user lists.
int AutoCompGetMaxHeight() const;
// Set the number of spaces used for one level of indentation.
void SetIndent(int indentSize);
// Retrieve indentation size.
int GetIndent() const;
// Indentation will only use space characters if useTabs is false, otherwise
// it will use a combination of tabs and spaces.
void SetUseTabs(bool useTabs);
// Retrieve whether tabs will be used in indentation.
bool GetUseTabs() const;
// Change the indentation of a line to a number of columns.
void SetLineIndentation(int line, int indentSize);
// Retrieve the number of columns that a line is indented.
int GetLineIndentation(int line) const;
// Retrieve the position before the first non indentation character on a line.
int GetLineIndentPosition(int line) const;
// Retrieve the column number of a position, taking tab width into account.
int GetColumn(int pos) const;
// Show or hide the horizontal scroll bar.
void SetUseHorizontalScrollBar(bool show);
// Is the horizontal scroll bar visible?
bool GetUseHorizontalScrollBar() const;
// Show or hide indentation guides.
void SetIndentationGuides(int indentView);
// Are the indentation guides visible?
int GetIndentationGuides() const;
// Set the highlighted indentation guide column.
// 0 = no highlighted guide.
void SetHighlightGuide(int column);
// Get the highlighted indentation guide column.
int GetHighlightGuide() const;
// Get the position after the last visible characters on a line.
int GetLineEndPosition(int line) const;
// Get the code page used to interpret the bytes of the document as characters.
int GetCodePage() const;
// Get the foreground colour of the caret.
wxColour GetCaretForeground() const;
// In read-only mode?
bool GetReadOnly() const;
// Sets the position of the caret.
void SetCurrentPos(int pos);
// Sets the position that starts the selection - this becomes the anchor.
void SetSelectionStart(int pos);
// Returns the position at the start of the selection.
int GetSelectionStart() const;
// Sets the position that ends the selection - this becomes the currentPosition.
void SetSelectionEnd(int pos);
// Returns the position at the end of the selection.
int GetSelectionEnd() const;
// Sets the print magnification added to the point size of each style for printing.
void SetPrintMagnification(int magnification);
// Returns the print magnification.
int GetPrintMagnification() const;
// Modify colours when printing for clearer printed text.
void SetPrintColourMode(int mode);
// Returns the print colour mode.
int GetPrintColourMode() const;
// Find some text in the document.
int FindText(int minPos, int maxPos, const wxString& text, int flags=0);
// On Windows, will draw the document into a display context such as a printer.
int FormatRange(bool doDraw,
int startPos,
int endPos,
wxDC* draw,
wxDC* target,
wxRect renderRect,
wxRect pageRect);
// Retrieve the display line at the top of the display.
int GetFirstVisibleLine() const;
// Retrieve the contents of a line.
wxString GetLine(int line) const;
// Returns the number of lines in the document. There is always at least one.
int GetLineCount() const;
// Sets the size in pixels of the left margin.
void SetMarginLeft(int pixelWidth);
// Returns the size in pixels of the left margin.
int GetMarginLeft() const;
// Sets the size in pixels of the right margin.
void SetMarginRight(int pixelWidth);
// Returns the size in pixels of the right margin.
int GetMarginRight() const;
// Is the document different from when it was last saved?
bool GetModify() const;
// Retrieve the selected text.
wxString GetSelectedText();
// Retrieve a range of text.
wxString GetTextRange(int startPos, int endPos);
// Draw the selection in normal style or with selection highlighted.
void HideSelection(bool normal);
// Retrieve the line containing a position.
int LineFromPosition(int pos) const;
// Retrieve the position at the start of a line.
int PositionFromLine(int line) const;
// Scroll horizontally and vertically.
void LineScroll(int columns, int lines);
// Ensure the caret is visible.
void EnsureCaretVisible();
// Replace the selected text with the argument text.
void ReplaceSelection(const wxString& text);
// Set to read only or read write.
void SetReadOnly(bool readOnly);
// Will a paste succeed?
bool CanPaste() const;
// Are there any undoable actions in the undo history?
bool CanUndo() const;
// Delete the undo history.
void EmptyUndoBuffer();
// Undo one action in the undo history.
void Undo();
// Cut the selection to the clipboard.
void Cut();
// Copy the selection to the clipboard.
void Copy();
// Paste the contents of the clipboard into the document replacing the selection.
void Paste();
// Clear the selection.
void Clear();
// Replace the contents of the document with the argument text.
void SetText(const wxString& text);
// Retrieve all the text in the document.
wxString GetText() const;
// Retrieve the number of characters in the document.
int GetTextLength() const;
// Set to overtype (true) or insert mode.
void SetOvertype(bool overtype);
// Returns true if overtype mode is active otherwise false is returned.
bool GetOvertype() const;
// Set the width of the insert mode caret.
void SetCaretWidth(int pixelWidth);
// Returns the width of the insert mode caret.
int GetCaretWidth() const;
// Sets the position that starts the target which is used for updating the
// document without affecting the scroll position.
void SetTargetStart(int pos);
// Get the position that starts the target.
int GetTargetStart() const;
// Sets the position that ends the target which is used for updating the
// document without affecting the scroll position.
void SetTargetEnd(int pos);
// Get the position that ends the target.
int GetTargetEnd() const;
// Replace the target text with the argument text.
// Text is counted so it can contain NULs.
// Returns the length of the replacement text.
int ReplaceTarget(const wxString& text);
// Replace the target text with the argument text after \d processing.
// Text is counted so it can contain NULs.
// Looks for \d where d is between 1 and 9 and replaces these with the strings
// matched in the last search operation which were surrounded by \( and \).
// Returns the length of the replacement text including any change
// caused by processing the \d patterns.
int ReplaceTargetRE(const wxString& text);
// Search for a counted string in the target and set the target to the found
// range. Text is counted so it can contain NULs.
// Returns length of range or -1 for failure in which case target is not moved.
int SearchInTarget(const wxString& text);
// Set the search flags used by SearchInTarget.
void SetSearchFlags(int flags);
// Get the search flags used by SearchInTarget.
int GetSearchFlags() const;
// Show a call tip containing a definition near position pos.
void CallTipShow(int pos, const wxString& definition);
// Remove the call tip from the screen.
void CallTipCancel();
// Is there an active call tip?
bool CallTipActive();
// Retrieve the position where the caret was before displaying the call tip.
int CallTipPosAtStart();
// Highlight a segment of the definition.
void CallTipSetHighlight(int start, int end);
// Set the background colour for the call tip.
void CallTipSetBackground(const wxColour& back);
// Set the foreground colour for the call tip.
void CallTipSetForeground(const wxColour& fore);
// Set the foreground colour for the highlighted part of the call tip.
void CallTipSetForegroundHighlight(const wxColour& fore);
// Enable use of STYLE_CALLTIP and set call tip tab size in pixels.
void CallTipUseStyle(int tabSize);
// Find the display line of a document line taking hidden lines into account.
int VisibleFromDocLine(int line);
// Find the document line of a display line taking hidden lines into account.
int DocLineFromVisible(int lineDisplay);
// The number of display lines needed to wrap a document line
int WrapCount(int line);
// Set the fold level of a line.
// This encodes an integer level along with flags indicating whether the
// line is a header and whether it is effectively white space.
void SetFoldLevel(int line, int level);
// Retrieve the fold level of a line.
int GetFoldLevel(int line) const;
// Find the last child line of a header line.
int GetLastChild(int line, int level) const;
// Find the parent line of a child line.
int GetFoldParent(int line) const;
// Make a range of lines visible.
void ShowLines(int lineStart, int lineEnd);
// Make a range of lines invisible.
void HideLines(int lineStart, int lineEnd);
// Is a line visible?
bool GetLineVisible(int line) const;
// Show the children of a header line.
void SetFoldExpanded(int line, bool expanded);
// Is a header line expanded?
bool GetFoldExpanded(int line) const;
// Switch a header line between expanded and contracted.
void ToggleFold(int line);
// Ensure a particular line is visible by expanding any header line hiding it.
void EnsureVisible(int line);
// Set some style options for folding.
void SetFoldFlags(int flags);
// Ensure a particular line is visible by expanding any header line hiding it.
// Use the currently set visibility policy to determine which range to display.
void EnsureVisibleEnforcePolicy(int line);
// Sets whether a tab pressed when caret is within indentation indents.
void SetTabIndents(bool tabIndents);
// Does a tab pressed when caret is within indentation indent?
bool GetTabIndents() const;
// Sets whether a backspace pressed when caret is within indentation unindents.
void SetBackSpaceUnIndents(bool bsUnIndents);
// Does a backspace pressed when caret is within indentation unindent?
bool GetBackSpaceUnIndents() const;
// Sets the time the mouse must sit still to generate a mouse dwell event.
void SetMouseDwellTime(int periodMilliseconds);
// Retrieve the time the mouse must sit still to generate a mouse dwell event.
int GetMouseDwellTime() const;
// Get position of start of word.
int WordStartPosition(int pos, bool onlyWordCharacters);
// Get position of end of word.
int WordEndPosition(int pos, bool onlyWordCharacters);
// Sets whether text is word wrapped.
void SetWrapMode(int mode);
// Retrieve whether text is word wrapped.
int GetWrapMode() const;
// Set the display mode of visual flags for wrapped lines.
void SetWrapVisualFlags(int wrapVisualFlags);
// Retrive the display mode of visual flags for wrapped lines.
int GetWrapVisualFlags() const;
// Set the location of visual flags for wrapped lines.
void SetWrapVisualFlagsLocation(int wrapVisualFlagsLocation);
// Retrive the location of visual flags for wrapped lines.
int GetWrapVisualFlagsLocation() const;
// Set the start indent for wrapped lines.
void SetWrapStartIndent(int indent);
// Retrive the start indent for wrapped lines.
int GetWrapStartIndent() const;
// Sets how wrapped sublines are placed. Default is fixed.
void SetWrapIndentMode(int mode);
// Retrieve how wrapped sublines are placed. Default is fixed.
int GetWrapIndentMode() const;
// Sets the degree of caching of layout information.
void SetLayoutCache(int mode);
// Retrieve the degree of caching of layout information.
int GetLayoutCache() const;
// Sets the document width assumed for scrolling.
void SetScrollWidth(int pixelWidth);
// Retrieve the document width assumed for scrolling.
int GetScrollWidth() const;
// Sets whether the maximum width line displayed is used to set scroll width.
void SetScrollWidthTracking(bool tracking);
// Retrieve whether the scroll width tracks wide lines.
bool GetScrollWidthTracking() const;
// Measure the pixel width of some text in a particular style.
// NUL terminated text argument.
// Does not handle tab or control characters.
int TextWidth(int style, const wxString& text);
// Sets the scroll range so that maximum scroll position has
// the last line at the bottom of the view (default).
// Setting this to false allows scrolling one page below the last line.
void SetEndAtLastLine(bool endAtLastLine);
// Retrieve whether the maximum scroll position has the last
// line at the bottom of the view.
bool GetEndAtLastLine() const;
// Retrieve the height of a particular line of text in pixels.
int TextHeight(int line);
// Show or hide the vertical scroll bar.
void SetUseVerticalScrollBar(bool show);
// Is the vertical scroll bar visible?
bool GetUseVerticalScrollBar() const;
// Append a string to the end of the document without changing the selection.
void AppendText(const wxString& text);
// Is drawing done in two phases with backgrounds drawn before foregrounds?
bool GetTwoPhaseDraw() const;
// In twoPhaseDraw mode, drawing is performed in two phases, first the background
// and then the foreground. This avoids chopping off characters that overlap the next run.
void SetTwoPhaseDraw(bool twoPhase);
// Make the target range start and end be the same as the selection range start and end.
void TargetFromSelection();
// Join the lines in the target.
void LinesJoin();
// Split the lines in the target into lines that are less wide than pixelWidth
// where possible.
void LinesSplit(int pixelWidth);
// Set the colours used as a chequerboard pattern in the fold margin
void SetFoldMarginColour(bool useSetting, const wxColour& back);
void SetFoldMarginHiColour(bool useSetting, const wxColour& fore);
// Move caret down one line.
void LineDown();
// Move caret down one line extending selection to new caret position.
void LineDownExtend();
// Move caret up one line.
void LineUp();
// Move caret up one line extending selection to new caret position.
void LineUpExtend();
// Move caret left one character.
void CharLeft();
// Move caret left one character extending selection to new caret position.
void CharLeftExtend();
// Move caret right one character.
void CharRight();
// Move caret right one character extending selection to new caret position.
void CharRightExtend();
// Move caret left one word.
void WordLeft();
// Move caret left one word extending selection to new caret position.
void WordLeftExtend();
// Move caret right one word.
void WordRight();
// Move caret right one word extending selection to new caret position.
void WordRightExtend();
// Move caret to first position on line.
void Home();
// Move caret to first position on line extending selection to new caret position.
void HomeExtend();
// Move caret to last position on line.
void LineEnd();
// Move caret to last position on line extending selection to new caret position.
void LineEndExtend();
// Move caret to first position in document.
void DocumentStart();
// Move caret to first position in document extending selection to new caret position.
void DocumentStartExtend();
// Move caret to last position in document.
void DocumentEnd();
// Move caret to last position in document extending selection to new caret position.
void DocumentEndExtend();
// Move caret one page up.
void PageUp();
// Move caret one page up extending selection to new caret position.
void PageUpExtend();
// Move caret one page down.
void PageDown();
// Move caret one page down extending selection to new caret position.
void PageDownExtend();
// Switch from insert to overtype mode or the reverse.
void EditToggleOvertype();
// Cancel any modes such as call tip or auto-completion list display.
void Cancel();
// Delete the selection or if no selection, the character before the caret.
void DeleteBack();
// If selection is empty or all on one line replace the selection with a tab character.
// If more than one line selected, indent the lines.
void Tab();
// Dedent the selected lines.
void BackTab();
// Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
void NewLine();
// Insert a Form Feed character.
void FormFeed();
// Move caret to before first visible character on line.
// If already there move to first character on line.
void VCHome();
// Like VCHome but extending selection to new caret position.
void VCHomeExtend();
// Magnify the displayed text by increasing the sizes by 1 point.
void ZoomIn();
// Make the displayed text smaller by decreasing the sizes by 1 point.
void ZoomOut();
// Delete the word to the left of the caret.
void DelWordLeft();
// Delete the word to the right of the caret.
void DelWordRight();
// Delete the word to the right of the caret, but not the trailing non-word characters.
void DelWordRightEnd();
// Cut the line containing the caret.
void LineCut();
// Delete the line containing the caret.
void LineDelete();
// Switch the current line with the previous.
void LineTranspose();
// Duplicate the current line.
void LineDuplicate();
// Transform the selection to lower case.
void LowerCase();
// Transform the selection to upper case.
void UpperCase();
// Scroll the document down, keeping the caret visible.
void LineScrollDown();
// Scroll the document up, keeping the caret visible.
void LineScrollUp();
// Delete the selection or if no selection, the character before the caret.
// Will not delete the character before at the start of a line.
void DeleteBackNotLine();
// Move caret to first position on display line.
void HomeDisplay();
// Move caret to first position on display line extending selection to
// new caret position.
void HomeDisplayExtend();
// Move caret to last position on display line.
void LineEndDisplay();
// Move caret to last position on display line extending selection to new
// caret position.
void LineEndDisplayExtend();
// These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)?
// except they behave differently when word-wrap is enabled:
// They go first to the start / end of the display line, like (Home|LineEnd)Display
// The difference is that, the cursor is already at the point, it goes on to the start
// or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.
void HomeWrap();
void HomeWrapExtend();
void LineEndWrap();
void LineEndWrapExtend();
void VCHomeWrap();
void VCHomeWrapExtend();
// Copy the line containing the caret.
void LineCopy();
// Move the caret inside current view if it's not there already.
void MoveCaretInsideView();
// How many characters are on a line, including end of line characters?
int LineLength(int line) const;
// Highlight the characters at two positions.
void BraceHighlight(int pos1, int pos2);
// Highlight the character at a position indicating there is no matching brace.
void BraceBadLight(int pos);
// Find the position of a matching brace or INVALID_POSITION if no match.
int BraceMatch(int pos);
// Are the end of line characters visible?
bool GetViewEOL() const;
// Make the end of line characters visible or invisible.
void SetViewEOL(bool visible);
// Retrieve a pointer to the document object.
void* GetDocPointer();
// Change the document object used.
void SetDocPointer(void* docPointer);
// Set which document modification events are sent to the container.
void SetModEventMask(int mask);
// Retrieve the column number which text should be kept within.
int GetEdgeColumn() const;
// Set the column number of the edge.
// If text goes past the edge then it is highlighted.
void SetEdgeColumn(int column);
// Retrieve the edge highlight mode.
int GetEdgeMode() const;
// The edge may be displayed by a line (EDGE_LINE) or by highlighting text that
// goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).
void SetEdgeMode(int mode);
// Retrieve the colour used in edge indication.
wxColour GetEdgeColour() const;
// Change the colour used in edge indication.
void SetEdgeColour(const wxColour& edgeColour);
// Sets the current caret position to be the search anchor.
void SearchAnchor();
// Find some text starting at the search anchor.
// Does not ensure the selection is visible.
int SearchNext(int flags, const wxString& text);
// Find some text starting at the search anchor and moving backwards.
// Does not ensure the selection is visible.
int SearchPrev(int flags, const wxString& text);
// Retrieves the number of lines completely visible.
int LinesOnScreen() const;
// Set whether a pop up menu is displayed automatically when the user presses
// the wrong mouse button.
void UsePopUp(bool allowPopUp);
// Is the selection rectangular? The alternative is the more common stream selection.
bool SelectionIsRectangle() const;
// Set the zoom level. This number of points is added to the size of all fonts.
// It may be positive to magnify or negative to reduce.
void SetZoom(int zoom);
// Retrieve the zoom level.
int GetZoom() const;
// Create a new document object.
// Starts with reference count of 1 and not selected into editor.
void* CreateDocument();
// Extend life of document.
void AddRefDocument(void* docPointer);
// Release a reference to the document, deleting document if it fades to black.
void ReleaseDocument(void* docPointer);
// Get which document modification events are sent to the container.
int GetModEventMask() const;
// Change internal focus flag.
void SetSTCFocus(bool focus);
// Get internal focus flag.
bool GetSTCFocus() const;
// Change error status - 0 = OK.
void SetStatus(int statusCode);
// Get error status.
int GetStatus() const;
// Set whether the mouse is captured when its button is pressed.
void SetMouseDownCaptures(bool captures);
// Get whether mouse gets captured.
bool GetMouseDownCaptures() const;
// Sets the cursor to one of the SC_CURSOR* values.
void SetSTCCursor(int cursorType);
// Get cursor type.
int GetSTCCursor() const;
// Change the way control characters are displayed:
// If symbol is < 32, keep the drawn way, else, use the given character.
void SetControlCharSymbol(int symbol);
// Get the way control characters are displayed.
int GetControlCharSymbol() const;
// Move to the previous change in capitalisation.
void WordPartLeft();
// Move to the previous change in capitalisation extending selection
// to new caret position.
void WordPartLeftExtend();
// Move to the change next in capitalisation.
void WordPartRight();
// Move to the next change in capitalisation extending selection
// to new caret position.
void WordPartRightExtend();
// Set the way the display area is determined when a particular line
// is to be moved to by Find, FindNext, GotoLine, etc.
void SetVisiblePolicy(int visiblePolicy, int visibleSlop);
// Delete back from the current position to the start of the line.
void DelLineLeft();
// Delete forwards from the current position to the end of the line.
void DelLineRight();
// Get and Set the xOffset (ie, horizonal scroll position).
void SetXOffset(int newOffset);
int GetXOffset() const;
// Set the last x chosen value to be the caret x position.
void ChooseCaretX();
// Set the way the caret is kept visible when going sideway.
// The exclusion zone is given in pixels.
void SetXCaretPolicy(int caretPolicy, int caretSlop);
// Set the way the line the caret is on is kept visible.
// The exclusion zone is given in lines.
void SetYCaretPolicy(int caretPolicy, int caretSlop);
// Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).
void SetPrintWrapMode(int mode);
// Is printing line wrapped?
int GetPrintWrapMode() const;
// Set a fore colour for active hotspots.
void SetHotspotActiveForeground(bool useSetting, const wxColour& fore);
// Get the fore colour for active hotspots.
wxColour GetHotspotActiveForeground() const;
// Set a back colour for active hotspots.
void SetHotspotActiveBackground(bool useSetting, const wxColour& back);
// Get the back colour for active hotspots.
wxColour GetHotspotActiveBackground() const;
// Enable / Disable underlining active hotspots.
void SetHotspotActiveUnderline(bool underline);
// Get whether underlining for active hotspots.
bool GetHotspotActiveUnderline() const;
// Limit hotspots to single line so hotspots on two lines don't merge.
void SetHotspotSingleLine(bool singleLine);
// Get the HotspotSingleLine property
bool GetHotspotSingleLine() const;
// Move caret between paragraphs (delimited by empty lines).
void ParaDown();
void ParaDownExtend();
void ParaUp();
void ParaUpExtend();
// Given a valid document position, return the previous position taking code
// page into account. Returns 0 if passed 0.
int PositionBefore(int pos);
// Given a valid document position, return the next position taking code
// page into account. Maximum value returned is the last position in the document.
int PositionAfter(int pos);
// Copy a range of text to the clipboard. Positions are clipped into the document.
void CopyRange(int start, int end);
// Copy argument text to the clipboard.
void CopyText(int length, const wxString& text);
// Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or
// by lines (SC_SEL_LINES).
void SetSelectionMode(int mode);
// Get the mode of the current selection.
int GetSelectionMode() const;
// Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).
int GetLineSelStartPosition(int line);
// Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).
int GetLineSelEndPosition(int line);
// Move caret down one line, extending rectangular selection to new caret position.
void LineDownRectExtend();
// Move caret up one line, extending rectangular selection to new caret position.
void LineUpRectExtend();
// Move caret left one character, extending rectangular selection to new caret position.
void CharLeftRectExtend();
// Move caret right one character, extending rectangular selection to new caret position.
void CharRightRectExtend();
// Move caret to first position on line, extending rectangular selection to new caret position.
void HomeRectExtend();
// Move caret to before first visible character on line.
// If already there move to first character on line.
// In either case, extend rectangular selection to new caret position.
void VCHomeRectExtend();
// Move caret to last position on line, extending rectangular selection to new caret position.
void LineEndRectExtend();
// Move caret one page up, extending rectangular selection to new caret position.
void PageUpRectExtend();
// Move caret one page down, extending rectangular selection to new caret position.
void PageDownRectExtend();
// Move caret to top of page, or one page up if already at top of page.
void StutteredPageUp();
// Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
void StutteredPageUpExtend();
// Move caret to bottom of page, or one page down if already at bottom of page.
void StutteredPageDown();
// Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
void StutteredPageDownExtend();
// Move caret left one word, position cursor at end of word.
void WordLeftEnd();
// Move caret left one word, position cursor at end of word, extending selection to new caret position.
void WordLeftEndExtend();
// Move caret right one word, position cursor at end of word.
void WordRightEnd();
// Move caret right one word, position cursor at end of word, extending selection to new caret position.
void WordRightEndExtend();
// Set the set of characters making up whitespace for when moving or selecting by word.
// Should be called after SetWordChars.
void SetWhitespaceChars(const wxString& characters);
// Reset the set of characters for whitespace and word characters to the defaults.
void SetCharsDefault();
// Get currently selected item position in the auto-completion list
int AutoCompGetCurrent();
// Enlarge the document to a particular size of text bytes.
void Allocate(int bytes);
// Find the position of a column on a line taking into account tabs and
// multi-byte characters. If beyond end of line, return line end position.
int FindColumn(int line, int column);
// Can the caret preferred x position only be changed by explicit movement commands?
bool GetCaretSticky() const;
// Stop the caret preferred x position changing when the user types.
void SetCaretSticky(bool useCaretStickyBehaviour);
// Switch between sticky and non-sticky: meant to be bound to a key.
void ToggleCaretSticky();
// Enable/Disable convert-on-paste for line endings
void SetPasteConvertEndings(bool convert);
// Get convert-on-paste setting
bool GetPasteConvertEndings() const;
// Duplicate the selection. If selection empty duplicate the line containing the caret.
void SelectionDuplicate();
// Set background alpha of the caret line.
void SetCaretLineBackAlpha(int alpha);
// Get the background alpha of the caret line.
int GetCaretLineBackAlpha() const;
// Set the style of the caret to be drawn.
void SetCaretStyle(int caretStyle);
// Returns the current style of the caret.
int GetCaretStyle() const;
// Set the indicator used for IndicatorFillRange and IndicatorClearRange
void SetIndicatorCurrent(int indicator);
// Get the current indicator
int GetIndicatorCurrent() const;
// Set the value used for IndicatorFillRange
void SetIndicatorValue(int value);
// Get the current indicator vaue
int GetIndicatorValue() const;
// Turn a indicator on over a range.
void IndicatorFillRange(int position, int fillLength);
// Turn a indicator off over a range.
void IndicatorClearRange(int position, int clearLength);
// Are any indicators present at position?
int IndicatorAllOnFor(int position);
// What value does a particular indicator have at at a position?
int IndicatorValueAt(int indicator, int position);
// Where does a particular indicator start?
int IndicatorStart(int indicator, int position);
// Where does a particular indicator end?
int IndicatorEnd(int indicator, int position);
// Set number of entries in position cache
void SetPositionCacheSize(int size);
// How many entries are allocated to the position cache?
int GetPositionCacheSize() const;
// Copy the selection, if selection empty copy the line with the caret
void CopyAllowLine();
// Compact the document buffer and return a read-only pointer to the
// characters in the document.
int GetCharacterPointer() const;
// Always interpret keyboard input as Unicode
void SetKeysUnicode(bool keysUnicode);
// Are keys always interpreted as Unicode?
bool GetKeysUnicode() const;
// Set the alpha fill colour of the given indicator.
void IndicatorSetAlpha(int indicator, int alpha);
// Get the alpha fill colour of the given indicator.
int IndicatorGetAlpha(int indicator) const;
// Set extra ascent for each line
void SetExtraAscent(int extraAscent);
// Get extra ascent for each line
int GetExtraAscent() const;
// Set extra descent for each line
void SetExtraDescent(int extraDescent);
// Get extra descent for each line
int GetExtraDescent() const;
// Which symbol was defined for markerNumber with MarkerDefine
int GetMarkerSymbolDefined(int markerNumber);
// Set the text in the text margin for a line
void MarginSetText(int line, const wxString& text);
// Get the text in the text margin for a line
wxString MarginGetText(int line) const;
// Set the style number for the text margin for a line
void MarginSetStyle(int line, int style);
// Get the style number for the text margin for a line
int MarginGetStyle(int line) const;
// Set the style in the text margin for a line
void MarginSetStyles(int line, const wxString& styles);
// Get the styles in the text margin for a line
wxString MarginGetStyles(int line) const;
// Clear the margin text on all lines
void MarginTextClearAll();
// Get the start of the range of style numbers used for margin text
void MarginSetStyleOffset(int style);
// Get the start of the range of style numbers used for margin text
int MarginGetStyleOffset() const;
// Set the annotation text for a line
void AnnotationSetText(int line, const wxString& text);
// Get the annotation text for a line
wxString AnnotationGetText(int line) const;
// Set the style number for the annotations for a line
void AnnotationSetStyle(int line, int style);
// Get the style number for the annotations for a line
int AnnotationGetStyle(int line) const;
// Set the annotation styles for a line
void AnnotationSetStyles(int line, const wxString& styles);
// Get the annotation styles for a line
wxString AnnotationGetStyles(int line) const;
// Get the number of annotation lines for a line
int AnnotationGetLines(int line) const;
// Clear the annotations from all lines
void AnnotationClearAll();
// Set the visibility for the annotations for a view
void AnnotationSetVisible(int visible);
// Get the visibility for the annotations for a view
int AnnotationGetVisible() const;
// Get the start of the range of style numbers used for annotations
void AnnotationSetStyleOffset(int style);
// Get the start of the range of style numbers used for annotations
int AnnotationGetStyleOffset() const;
// Add a container action to the undo stack
void AddUndoAction(int token, int flags);
// Find the position of a character from a point within the window.
int CharPositionFromPoint(int x, int y);
// Find the position of a character from a point within the window.
// Return INVALID_POSITION if not close to text.
int CharPositionFromPointClose(int x, int y);
// Set whether multiple selections can be made
void SetMultipleSelection(bool multipleSelection);
// Whether multiple selections can be made
bool GetMultipleSelection() const;
// Set whether typing can be performed into multiple selections
void SetAdditionalSelectionTyping(bool additionalSelectionTyping);
// Whether typing can be performed into multiple selections
bool GetAdditionalSelectionTyping() const;
// Set whether additional carets will blink
void SetAdditionalCaretsBlink(bool additionalCaretsBlink);
// Whether additional carets will blink
bool GetAdditionalCaretsBlink() const;
// How many selections are there?
int GetSelections() const;
// Clear selections to a single empty stream selection
void ClearSelections();
// Set a simple selection
int SetSelection(int caret, int anchor);
// Add a selection
int AddSelection(int caret, int anchor);
// Set the main selection
void SetMainSelection(int selection);
// Which selection is the main selection
int GetMainSelection() const;
void SetSelectionNCaret(int selection, int pos);
int GetSelectionNCaret(int selection) const;
void SetSelectionNAnchor(int selection, int posAnchor);
int GetSelectionNAnchor(int selection) const;
void SetSelectionNCaretVirtualSpace(int selection, int space);
int GetSelectionNCaretVirtualSpace(int selection) const;
void SetSelectionNAnchorVirtualSpace(int selection, int space);
int GetSelectionNAnchorVirtualSpace(int selection) const;
// Sets the position that starts the selection - this becomes the anchor.
void SetSelectionNStart(int selection, int pos);
// Returns the position at the start of the selection.
int GetSelectionNStart() const;
// Sets the position that ends the selection - this becomes the currentPosition.
void SetSelectionNEnd(int selection, int pos);
// Returns the position at the end of the selection.
int GetSelectionNEnd() const;
void SetRectangularSelectionCaret(int pos);
int GetRectangularSelectionCaret() const;
void SetRectangularSelectionAnchor(int posAnchor);
int GetRectangularSelectionAnchor() const;
void SetRectangularSelectionCaretVirtualSpace(int space);
int GetRectangularSelectionCaretVirtualSpace() const;
void SetRectangularSelectionAnchorVirtualSpace(int space);
int GetRectangularSelectionAnchorVirtualSpace() const;
void SetVirtualSpaceOptions(int virtualSpaceOptions);
int GetVirtualSpaceOptions() const;
// On GTK+, allow selecting the modifier key to use for mouse-based
// rectangular selection. Often the window manager requires Alt+Mouse Drag
// for moving windows.
// Valid values are SCMOD_CTRL(default), SCMOD_ALT, or SCMOD_SUPER.
void SetRectangularSelectionModifier(int modifier);
// Get the modifier key used for rectangular selection.
int GetRectangularSelectionModifier() const;
// Set the foreground colour of additional selections.
// Must have previously called SetSelFore with non-zero first argument for this to have an effect.
void SetAdditionalSelForeground(const wxColour& fore);
// Set the background colour of additional selections.
// Must have previously called SetSelBack with non-zero first argument for this to have an effect.
void SetAdditionalSelBackground(const wxColour& back);
// Set the alpha of the selection.
void SetAdditionalSelAlpha(int alpha);
// Get the alpha of the selection.
int GetAdditionalSelAlpha() const;
// Set the foreground colour of additional carets.
void SetAdditionalCaretForeground(const wxColour& fore);
// Get the foreground colour of additional carets.
wxColour GetAdditionalCaretForeground() const;
// Set the main selection to the next selection.
void RotateSelection();
// Swap that caret and anchor of the main selection.
void SwapMainAnchorCaret();
// Start notifying the container of all key presses and commands.
void StartRecord();
// Stop notifying the container of all key presses and commands.
void StopRecord();
// Set the lexing language of the document.
void SetLexer(int lexer);
// Retrieve the lexing language of the document.
int GetLexer() const;
// Colourise a segment of the document using the current lexing language.
void Colourise(int start, int end);
// Set up a value that may be used by a lexer for some optional feature.
void SetProperty(const wxString& key, const wxString& value);
// Set up the key words used by the lexer.
void SetKeyWords(int keywordSet, const wxString& keyWords);
// Set the lexing language of the document based on string name.
void SetLexerLanguage(const wxString& language);
// Retrieve a 'property' value previously set with SetProperty.
wxString GetProperty(const wxString& key);
// Retrieve a 'property' value previously set with SetProperty,
// with '$()' variable replacement on returned buffer.
wxString GetPropertyExpanded(const wxString& key);
// Retrieve a 'property' value previously set with SetProperty,
// interpreted as an int AFTER any '$()' variable replacement.
int GetPropertyInt(const wxString& key) const;
// Retrieve the number of bits the current lexer needs for styling.
int GetStyleBitsNeeded() const;
//}}}
//----------------------------------------------------------------------
// Manually declared methods
// Returns the line number of the line with the caret.
int GetCurrentLine();
// Extract style settings from a spec-string which is composed of one or
// more of the following comma separated elements:
//
// bold turns on bold
// italic turns on italics
// fore:[name or #RRGGBB] sets the foreground colour
// back:[name or #RRGGBB] sets the background colour
// face:[facename] sets the font face name to use
// size:[num] sets the font size in points
// eol turns on eol filling
// underline turns on underlining
//
void StyleSetSpec(int styleNum, const wxString& spec);
// Get the font of a style.
wxFont StyleGetFont(int style);
// Set style size, face, bold, italic, and underline attributes from
// a wxFont's attributes.
void StyleSetFont(int styleNum, wxFont& font);
// Set all font style attributes at once.
void StyleSetFontAttr(int styleNum, int size,
const wxString& faceName,
bool bold, bool italic,
bool underline,
wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
// Set the character set of the font in a style. Converts the Scintilla
// character set values to a wxFontEncoding.
void StyleSetCharacterSet(int style, int characterSet);
// Set the font encoding to be used by a style.
void StyleSetFontEncoding(int style, wxFontEncoding encoding);
// Perform one of the operations defined by the wxSCI_CMD_* constants.
void CmdKeyExecute(int cmd);
// Set the left and right margin in the edit area, measured in pixels.
void SetMargins(int left, int right);
// Retrieve the point in the window where a position is displayed.
wxPoint PointFromPosition(int pos);
// Scroll enough to make the given line visible
void ScrollToLine(int line);
// Scroll enough to make the given column visible
void ScrollToColumn(int column);
// Send a message to Scintilla
//
// NB: this method is not really const as it can modify the control but it
// has to be declared as such as it's called from both const and
// non-const methods and we can't distinguish between the two
wxIntPtr SendMsg(int msg, wxUIntPtr wp=0, wxIntPtr lp=0) const;
// Set the vertical scrollbar to use instead of the ont that's built-in.
void SetVScrollBar(wxScrollBar* bar);
// Set the horizontal scrollbar to use instead of the ont that's built-in.
void SetHScrollBar(wxScrollBar* bar);
// Can be used to prevent the EVT_CHAR handler from adding the char
bool GetLastKeydownProcessed() { return m_lastKeyDownConsumed; }
void SetLastKeydownProcessed(bool val) { m_lastKeyDownConsumed = val; }
// if we derive from wxTextAreaBase it already provides these methods
#if !wxUSE_TEXTCTRL
// Write the contents of the editor to filename
bool SaveFile(const wxString& filename);
// Load the contents of filename into the editor
bool LoadFile(const wxString& filename);
#endif // !wxUSE_TEXTCTRL
#ifdef STC_USE_DND
// Allow for simulating a DnD DragOver
wxDragResult DoDragOver(wxCoord x, wxCoord y, wxDragResult def);
// Allow for simulating a DnD DropText
bool DoDropText(long x, long y, const wxString& data);
#endif
// Specify whether anti-aliased fonts should be used. Will have no effect
// on some platforms, but on some (wxMac for example) can greatly improve
// performance.
void SetUseAntiAliasing(bool useAA);
// Returns the current UseAntiAliasing setting.
bool GetUseAntiAliasing();
// The following methods are nearly equivallent to their similarly named
// cousins above. The difference is that these methods bypass wxString
// and always use a char* even if used in a unicode build of wxWidgets.
// In that case the character data will be utf-8 encoded since that is
// what is used internally by Scintilla in unicode builds.
// Add text to the document at current position.
void AddTextRaw(const char* text);
// Insert string at a position.
void InsertTextRaw(int pos, const char* text);
// Retrieve the text of the line containing the caret.
// Returns the index of the caret on the line.
#ifdef SWIG
wxCharBuffer GetCurLineRaw(int* OUTPUT);
#else
wxCharBuffer GetCurLineRaw(int* linePos=NULL);
#endif
// Retrieve the contents of a line.
wxCharBuffer GetLineRaw(int line);
// Retrieve the selected text.
wxCharBuffer GetSelectedTextRaw();
// Retrieve a range of text.
wxCharBuffer GetTextRangeRaw(int startPos, int endPos);
// Replace the contents of the document with the argument text.
void SetTextRaw(const char* text);
// Retrieve all the text in the document.
wxCharBuffer GetTextRaw();
// Append a string to the end of the document without changing the selection.
void AppendTextRaw(const char* text);
#ifdef SWIG
%pythoncode "_stc_utf8_methods.py"
#endif
// implement wxTextEntryBase pure virtual methods
// ----------------------------------------------
virtual void WriteText(const wxString& text) { AddText(text); }
virtual void Remove(long from, long to)
{
Replace(from, to, "");
}
virtual void Replace(long from, long to, const wxString& text)
{
SetTargetStart(from);
SetTargetEnd(to);
ReplaceTarget(text);
}
/*
These functions are already declared in the generated section.
virtual void Copy();
virtual void Cut();
virtual void Paste();
virtual void Undo();
virtual void Redo();
virtual bool CanUndo() const;
virtual bool CanRedo() const;
*/
virtual void SetInsertionPoint(long pos) { SetCurrentPos(pos); }
virtual long GetInsertionPoint() const { return GetCurrentPos(); }
virtual long GetLastPosition() const { return GetTextLength(); }
virtual void SetSelection(long from, long to)
{
if ( from == -1 && to == -1 )
{
SelectAll();
}
else
{
SetSelectionStart(from);
SetSelectionEnd(to);
}
}
#ifdef SWIG
void GetSelection(long* OUTPUT, long* OUTPUT) const;
#else
virtual void GetSelection(long *from, long *to) const
{
if ( from )
*from = GetSelectionStart();
if ( to )
*to = GetSelectionEnd();
}
// kept for compatibility only
void GetSelection(int *from, int *to)
{
long f, t;
GetSelection(&f, &t);
if ( from )
*from = f;
if ( to )
*to = t;
}
#endif
virtual bool IsEditable() const { return !GetReadOnly(); }
virtual void SetEditable(bool editable) { SetReadOnly(!editable); }
// implement wxTextAreaBase pure virtual methods
// ---------------------------------------------
virtual int GetLineLength(long n) const { return GetLine(n).length(); }
virtual wxString GetLineText(long n) const { return GetLine(n); }
virtual int GetNumberOfLines() const { return GetLineCount(); }
virtual bool IsModified() const { return GetModify(); }
virtual void MarkDirty() { wxFAIL_MSG("not implemented"); }
virtual void DiscardEdits() { SetSavePoint(); }
virtual bool SetStyle(long WXUNUSED(start), long WXUNUSED(end),
const wxTextAttr& WXUNUSED(style))
{
wxFAIL_MSG("not implemented");
return false;
}
virtual bool GetStyle(long WXUNUSED(position), wxTextAttr& WXUNUSED(style))
{
wxFAIL_MSG("not implemented");
return false;
}
virtual bool SetDefaultStyle(const wxTextAttr& WXUNUSED(style))
{
wxFAIL_MSG("not implemented");
return false;
}
virtual long XYToPosition(long x, long y) const
{
long pos = PositionFromLine(y);
pos += x;
return pos;
}
virtual bool PositionToXY(long pos, long *x, long *y) const
{
if ( x )
*x = -1; // TODO
if ( y )
{
long l = LineFromPosition(pos);
if ( l == -1 )
return false;
*y = l;
}
return true;
}
virtual void ShowPosition(long pos) { GotoPos(pos); }
// FIXME-VC6: can't use wxWindow here because of "error C2603: illegal
// access declaration: 'wxWindow' is not a direct base of
// 'wxScintillaCtrl'" with VC6
using wxControl::HitTest;
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const
{
const long l = PositionFromPoint(pt);
if ( l == -1 )
return wxTE_HT_BELOW; // we don't really know where it was
if ( pos )
*pos = l;
return wxTE_HT_ON_TEXT;
}
// just unhide it
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
wxTextCoord *col,
wxTextCoord *row) const
{
return wxTextAreaBase::HitTest(pt, col, row);
}
protected:
virtual wxString DoGetValue() const { return GetText(); }
virtual wxWindow *GetEditableWindow() { return this; }
#ifndef SWIG
virtual bool DoLoadFile(const wxString& file, int fileType);
virtual bool DoSaveFile(const wxString& file, int fileType);
// Event handlers
void OnPaint(wxPaintEvent& evt);
void OnScrollWin(wxScrollWinEvent& evt);
void OnScroll(wxScrollEvent& evt);
void OnSize(wxSizeEvent& evt);
void OnMouseLeftDown(wxMouseEvent& evt);
void OnMouseMove(wxMouseEvent& evt);
void OnMouseLeftUp(wxMouseEvent& evt);
void OnMouseRightUp(wxMouseEvent& evt);
void OnMouseMiddleUp(wxMouseEvent& evt);
void OnContextMenu(wxContextMenuEvent& evt);
void OnMouseWheel(wxMouseEvent& evt);
void OnChar(wxKeyEvent& evt);
void OnKeyDown(wxKeyEvent& evt);
void OnLoseFocus(wxFocusEvent& evt);
void OnGainFocus(wxFocusEvent& evt);
void OnSysColourChanged(wxSysColourChangedEvent& evt);
void OnEraseBackground(wxEraseEvent& evt);
void OnMenu(wxCommandEvent& evt);
void OnListBox(wxCommandEvent& evt);
void OnIdle(wxIdleEvent& evt);
virtual wxSize DoGetBestSize() const;
// Turn notifications from Scintilla into events
void NotifyChange();
void NotifyParent(SCNotification* scn);
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxScintillaCtrl)
protected:
ScintillaWX* m_swx;
wxStopWatch m_stopWatch;
wxScrollBar* m_vScrollBar;
wxScrollBar* m_hScrollBar;
bool m_lastKeyDownConsumed;
// the timestamp that consists of the last wheel event
// added to the time taken to process that event.
long m_lastWheelTimestamp;
friend class ScintillaWX;
friend class Platform;
#endif // !SWIG
};
//----------------------------------------------------------------------
class SDK_DLL wxStyledTextEvent : public wxCommandEvent {
public:
wxStyledTextEvent(wxEventType commandType=0, int id=0);
#ifndef SWIG
wxStyledTextEvent(const wxStyledTextEvent& event);
#endif
~wxStyledTextEvent() {}
void SetPosition(int pos) { m_position = pos; }
void SetKey(int k) { m_key = k; }
void SetModifiers(int m) { m_modifiers = m; }
void SetModificationType(int t) { m_modificationType = t; }
void SetText(const wxString& t) { m_text = t; }
void SetLength(int len) { m_length = len; }
void SetLinesAdded(int num) { m_linesAdded = num; }
void SetLine(int val) { m_line = val; }
void SetFoldLevelNow(int val) { m_foldLevelNow = val; }
void SetFoldLevelPrev(int val) { m_foldLevelPrev = val; }
void SetMargin(int val) { m_margin = val; }
void SetMessage(int val) { m_message = val; }
void SetWParam(int val) { m_wParam = val; }
void SetLParam(int val) { m_lParam = val; }
void SetListType(int val) { m_listType = val; }
void SetX(int val) { m_x = val; }
void SetY(int val) { m_y = val; }
void SetDragText(const wxString& val) { m_dragText = val; }
void SetDragAllowMove(bool val) { m_dragAllowMove = val; }
#ifdef STC_USE_DND
void SetDragResult(wxDragResult val) { m_dragResult = val; }
#endif
int GetPosition() const { return m_position; }
int GetKey() const { return m_key; }
int GetModifiers() const { return m_modifiers; }
int GetModificationType() const { return m_modificationType; }
wxString GetText() const { return m_text; }
int GetLength() const { return m_length; }
int GetLinesAdded() const { return m_linesAdded; }
int GetLine() const { return m_line; }
int GetFoldLevelNow() const { return m_foldLevelNow; }
int GetFoldLevelPrev() const { return m_foldLevelPrev; }
int GetMargin() const { return m_margin; }
int GetMessage() const { return m_message; }
int GetWParam() const { return m_wParam; }
int GetLParam() const { return m_lParam; }
int GetListType() const { return m_listType; }
int GetX() const { return m_x; }
int GetY() const { return m_y; }
wxString GetDragText() { return m_dragText; }
bool GetDragAllowMove() { return m_dragAllowMove; }
#ifdef STC_USE_DND
wxDragResult GetDragResult() { return m_dragResult; }
#endif
bool GetShift() const;
bool GetControl() const;
bool GetAlt() const;
virtual wxEvent* Clone() const { return new wxStyledTextEvent(*this); }
#ifndef SWIG
private:
DECLARE_DYNAMIC_CLASS(wxStyledTextEvent)
int m_position;
int m_key;
int m_modifiers;
int m_modificationType; // wxEVT_STC_MODIFIED
wxString m_text;
int m_length;
int m_linesAdded;
int m_line;
int m_foldLevelNow;
int m_foldLevelPrev;
int m_margin; // wxEVT_STC_MARGINCLICK
int m_message; // wxEVT_STC_MACRORECORD
int m_wParam;
int m_lParam;
int m_listType;
int m_x;
int m_y;
wxString m_dragText; // wxEVT_STC_START_DRAG, wxEVT_STC_DO_DROP
bool m_dragAllowMove; // wxEVT_STC_START_DRAG
#if wxUSE_DRAG_AND_DROP
wxDragResult m_dragResult; // wxEVT_STC_DRAG_OVER,wxEVT_STC_DO_DROP
#endif
#endif
};
#ifndef SWIG
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_CHANGE, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_STYLENEEDED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_CHARADDED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_SAVEPOINTREACHED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_SAVEPOINTLEFT, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_ROMODIFYATTEMPT, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_KEY, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_DOUBLECLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_UPDATEUI, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_MODIFIED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_MACRORECORD, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_MARGINCLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_NEEDSHOWN, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_PAINTED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_USERLISTSELECTION, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_URIDROPPED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_DWELLSTART, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_DWELLEND, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_START_DRAG, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_DRAG_OVER, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_DO_DROP, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_ZOOM, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_HOTSPOT_CLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_HOTSPOT_DCLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_CALLTIP_CLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_AUTOCOMP_SELECTION, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_INDICATOR_CLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( SDK_DLL, wxEVT_STC_INDICATOR_RELEASE, wxStyledTextEvent );
#else
enum {
wxEVT_STC_CHANGE,
wxEVT_STC_STYLENEEDED,
wxEVT_STC_CHARADDED,
wxEVT_STC_SAVEPOINTREACHED,
wxEVT_STC_SAVEPOINTLEFT,
wxEVT_STC_ROMODIFYATTEMPT,
wxEVT_STC_KEY,
wxEVT_STC_DOUBLECLICK,
wxEVT_STC_UPDATEUI,
wxEVT_STC_MODIFIED,
wxEVT_STC_MACRORECORD,
wxEVT_STC_MARGINCLICK,
wxEVT_STC_NEEDSHOWN,
wxEVT_STC_PAINTED,
wxEVT_STC_USERLISTSELECTION,
wxEVT_STC_URIDROPPED,
wxEVT_STC_DWELLSTART,
wxEVT_STC_DWELLEND,
wxEVT_STC_START_DRAG,
wxEVT_STC_DRAG_OVER,
wxEVT_STC_DO_DROP,
wxEVT_STC_ZOOM,
wxEVT_STC_HOTSPOT_CLICK,
wxEVT_STC_HOTSPOT_DCLICK,
wxEVT_STC_CALLTIP_CLICK,
wxEVT_STC_AUTOCOMP_SELECTION,
wxEVT_STC_INDICATOR_CLICK,
wxEVT_STC_INDICATOR_RELEASE
};
#endif
#ifndef SWIG
typedef void (wxEvtHandler::*wxStyledTextEventFunction)(wxStyledTextEvent&);
#define wxStyledTextEventHandler( func ) \
wxEVENT_HANDLER_CAST( wxStyledTextEventFunction, func )
#define EVT_STC_CHANGE(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CHANGE, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_STYLENEEDED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_STYLENEEDED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_CHARADDED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CHARADDED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_SAVEPOINTREACHED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_SAVEPOINTREACHED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_SAVEPOINTLEFT(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_SAVEPOINTLEFT, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_ROMODIFYATTEMPT(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_ROMODIFYATTEMPT, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_KEY(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_KEY, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DOUBLECLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DOUBLECLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_UPDATEUI(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_UPDATEUI, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_MODIFIED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MODIFIED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_MACRORECORD(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MACRORECORD, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_MARGINCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MARGINCLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_NEEDSHOWN(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_NEEDSHOWN, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_PAINTED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_PAINTED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_USERLISTSELECTION(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_USERLISTSELECTION, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_URIDROPPED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_URIDROPPED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DWELLSTART(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DWELLSTART, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DWELLEND(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DWELLEND, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_START_DRAG(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_START_DRAG, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DRAG_OVER(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DRAG_OVER, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DO_DROP(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DO_DROP, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_ZOOM(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_ZOOM, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_HOTSPOT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_HOTSPOT_CLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_HOTSPOT_DCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_HOTSPOT_DCLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_CALLTIP_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CALLTIP_CLICK id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_AUTOCOMP_SELECTION(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_AUTOCOMP_SELECTION id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_INDICATOR_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_INDICATOR_CLICK id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_INDICATOR_RELEASE(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_INDICATOR_RELEASE id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#endif
// #endif // wxUSE_STC
#endif // _WX_STC_STC_H_
| [
"vongodric@957c6b5c-1c3a-0410-895f-c76cfc11fbc7"
] | [
[
[
1,
4451
]
]
] |
37faf100b49d3f5fefa54b156ae177ff4300d18c | e53e3f6fac0340ae0435c8e60d15d763704ef7ec | /WDL/wingui/virtwnd-listbox.cpp | db0494c00bb4a83ca420b55cf8e47dca0d8acdfa | [] | no_license | b-vesco/vfx-wdl | 906a69f647938b60387d8966f232a03ce5b87e5f | ee644f752e2174be2fefe43275aec2979f0baaec | refs/heads/master | 2020-05-30T21:37:06.356326 | 2011-01-04T08:54:45 | 2011-01-04T08:54:45 | 848,136 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,621 | cpp | /*
WDL - virtwnd-listbox.cpp
Copyright (C) 2006 and later Cockos Incorporated
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Implementation for virtual window listboxes.
*/
#include "virtwnd-controls.h"
#include "../lice/lice.h"
WDL_VirtualListBox::WDL_VirtualListBox()
{
memset(m_lastscrollbuttons,0,sizeof(m_lastscrollbuttons));
m_scrollbuttonsize=14;
m_cap_startitem=-1;
m_cap_state=0;
m_margin_l=m_margin_r=0;
m_GetItemInfo=0;
m_CustomDraw=0;
m_GetItemInfo_ctx=0;
m_viewoffs=0;
m_align=-1;
m_rh=14;
m_maxcolwidth=m_mincolwidth=0;
m_font=0;
m_clickmsg=0;
m_dropmsg=0;
m_dragbeginmsg=0;
m_grayed=false;
}
WDL_VirtualListBox::~WDL_VirtualListBox()
{
}
void WDL_VirtualListBox::CalcLayout(int num_items, int *nrows, int *ncols, int *leftrightbuttonsize, int *updownbuttonsize, int *startpos,
int *usedw)
{
*usedw = m_position.right - m_position.left;
*leftrightbuttonsize=*updownbuttonsize=0;
if (m_rh<7) m_rh=7;
*ncols=1;
*nrows= (m_position.bottom - m_position.top) / m_rh;
if (*nrows<1) *nrows=1;
if (m_mincolwidth>0)
{
*ncols = (num_items+*nrows-1) / *nrows; // round up
if (*ncols<1) *ncols=1;
if ((m_position.right-m_position.left) < m_mincolwidth* *ncols)
*ncols = (m_position.right-m_position.left)/m_mincolwidth;
}
if (m_maxcolwidth>0)
{
int oc = *ncols;
if (m_mincolwidth<=0 || (m_position.right-m_position.left) <= m_maxcolwidth * *ncols)
*ncols = (m_position.right-m_position.left) / m_maxcolwidth; // round down
}
if (*ncols < 1) *ncols=1;
*startpos=0;
if (num_items > *nrows * *ncols)
{
*startpos=m_viewoffs;
if (*ncols > 1 && m_mincolwidth>0) // reduce columns to meet size requirements
{
if ((m_position.right-m_position.left - m_scrollbuttonsize*2) < m_mincolwidth* *ncols)
{
*ncols = (m_position.right-m_position.left - m_scrollbuttonsize*2)/m_mincolwidth;
if (*ncols < 1) *ncols=1;
}
}
if (*ncols > 1) *leftrightbuttonsize = m_scrollbuttonsize;
else *updownbuttonsize = m_scrollbuttonsize;
*nrows = (m_position.bottom - m_position.top - *updownbuttonsize) / m_rh;
if (*nrows<1) *nrows=1;
if (m_maxcolwidth>0 && *ncols == 1 && *nrows ==1)
{
*leftrightbuttonsize = m_scrollbuttonsize;
*updownbuttonsize=0;
*nrows = (m_position.bottom - m_position.top - *updownbuttonsize) / m_rh;
if (*nrows<1) *nrows=1;
}
int tot=*nrows * *ncols - (*nrows-1);
if (*startpos > num_items-tot) *startpos=num_items-tot;
if (*startpos<0)*startpos=0;
if (*ncols>1)
*startpos -= *startpos % *nrows;
}
if (m_maxcolwidth > 0)
{
int maxw=*ncols*m_maxcolwidth + 2* *leftrightbuttonsize;
if (maxw < *usedw) *usedw=maxw;
}
}
void DrawBkImage(LICE_IBitmap *drawbm, WDL_VirtualWnd_BGCfg *bkbm, int drawx, int drawy, int draww, int drawh,
RECT *cliprect, int drawsrcx, int drawsrcw, int bkbmstate, float alpha=1.0f)
{
int hh=bkbm->bgimage->getHeight()/3;
if (bkbm->bgimage_lt[0]||bkbm->bgimage_lt[1]||bkbm->bgimage_rb[0] || bkbm->bgimage_rb[1])
{
WDL_VirtualWnd_BGCfg tmp = *bkbm;
if ((tmp.bgimage_noalphaflags&0xffff)!=0xffff) tmp.bgimage_noalphaflags=0; // force alpha channel if any alpha
LICE_SubBitmap bm(tmp.bgimage,drawsrcx,bkbmstate*hh,drawsrcw+1,hh+2);
tmp.bgimage = &bm;
WDL_VirtualWnd_ScaledBlitBG(drawbm,&tmp,
drawx,drawy,draww,drawh,
cliprect->left,cliprect->top,cliprect->right-cliprect->left,cliprect->bottom-cliprect->top,
alpha,LICE_BLIT_USE_ALPHA|LICE_BLIT_MODE_COPY|LICE_BLIT_FILTER_BILINEAR);
}
else
{
LICE_ScaledBlit(drawbm,bkbm->bgimage,
drawx,drawy,draww,drawh,
drawsrcx,bkbmstate*hh,
drawsrcw,hh,alpha,LICE_BLIT_USE_ALPHA|LICE_BLIT_MODE_COPY|LICE_BLIT_FILTER_BILINEAR);
}
}
void WDL_VirtualListBox::OnPaint(LICE_IBitmap *drawbm, int origin_x, int origin_y, RECT *cliprect)
{
RECT r=m_position;
r.left+=origin_x;
r.right+=origin_x;
r.top+=origin_y;
r.bottom+=origin_y;
WDL_VirtualWnd_BGCfg *mainbk=0;
int num_items = m_GetItemInfo ? m_GetItemInfo(this,-1,NULL,0,NULL,&mainbk) : 0;
LICE_pixel bgc=WDL_STYLE_GetSysColor(COLOR_BTNFACE);
bgc=LICE_RGBA_FROMNATIVE(bgc,255);
int nrows,num_cols,updownbuttonsize,leftrightbuttonsize,startpos,usedw;
CalcLayout(num_items,&nrows,&num_cols,&leftrightbuttonsize,&updownbuttonsize,&startpos,&usedw);
if (r.right > r.left + usedw) r.right=r.left+usedw;
if (mainbk && mainbk->bgimage)
{
if (mainbk->bgimage->getWidth()>1 && mainbk->bgimage->getHeight()>1)
{
WDL_VirtualWnd_ScaledBlitBG(drawbm,mainbk,
r.left,r.top,r.right-r.left,r.bottom-r.top,
cliprect->left,cliprect->top,cliprect->right-cliprect->left,cliprect->bottom-cliprect->top,
1.0,LICE_BLIT_USE_ALPHA|LICE_BLIT_MODE_COPY|LICE_BLIT_FILTER_BILINEAR);
}
}
else
{
LICE_FillRect(drawbm,r.left,r.top,r.right-r.left,r.bottom-r.top,bgc,1.0f,LICE_BLIT_MODE_COPY);
}
LICE_pixel pencol = WDL_STYLE_GetSysColor(COLOR_3DSHADOW);
LICE_pixel pencol2 = WDL_STYLE_GetSysColor(COLOR_3DHILIGHT);
pencol=LICE_RGBA_FROMNATIVE(pencol,255);
pencol2=LICE_RGBA_FROMNATIVE(pencol2,255);
LICE_pixel tcol=WDL_STYLE_GetSysColor(COLOR_BTNTEXT);
if (m_font) m_font->SetBkMode(TRANSPARENT);
float alpha = (m_grayed ? 0.25f : 1.0f);
int endpos=r.bottom - updownbuttonsize;
int itempos=startpos;
int colpos;
int y=0;
for (colpos = 0; colpos < num_cols; colpos ++)
{
int col_x = r.left + leftrightbuttonsize + ((r.right-r.left-leftrightbuttonsize*2)*colpos) / num_cols;
int col_w = r.left + leftrightbuttonsize + ((r.right-r.left-leftrightbuttonsize*2)*(colpos+1)) / num_cols - col_x;
for (y = r.top + m_rh; y <= endpos; y += m_rh)
{
int ly=y-m_rh;
WDL_VirtualWnd_BGCfg *bkbm=0;
if (m_GetItemInfo && ly >= r.top)
{
char buf[64];
buf[0]=0;
int color=tcol;
if (m_GetItemInfo(this,itempos++,buf,sizeof(buf),&color,&bkbm))
{
color=LICE_RGBA_FROMNATIVE(color,0);
RECT thisr;
thisr.left = col_x;
thisr.right = col_x + col_w;
thisr.top = ly+1;
thisr.bottom = y-1;
int rev=0;
int bkbmstate=0;
if (m_cap_state==1 && m_cap_startitem==itempos-1)
{
if (bkbm) bkbmstate=1;
else color = ((color>>1)&0x7f7f7f7f)+LICE_RGBA(0x7f,0x7f,0x7f,0);
}
if (m_cap_state>=0x1000 && m_cap_startitem==itempos-1)
{
if (bkbm) bkbmstate=2;
else
{
rev=1;
LICE_FillRect(drawbm,thisr.left,thisr.top,thisr.right-thisr.left,thisr.bottom-thisr.top, color,alpha,LICE_BLIT_MODE_COPY);
}
}
if (bkbm && bkbm->bgimage) //draw image!
{
DrawBkImage(drawbm,bkbm,
thisr.left,thisr.top-1,thisr.right-thisr.left,thisr.bottom-thisr.top+2,
cliprect,
0,bkbm->bgimage->getWidth(),bkbmstate,alpha);
}
if (m_CustomDraw)
{
m_CustomDraw(this,itempos-1,&thisr,drawbm);
}
if (buf[0])
{
thisr.left+=m_margin_l;
thisr.right-=m_margin_r;
if (m_font)
{
m_font->SetTextColor(rev?bgc:color);
m_font->SetCombineMode(LICE_BLIT_MODE_COPY, alpha); // maybe gray text only if !bkbm->bgimage
m_font->DrawText(drawbm,buf,-1,&thisr,DT_VCENTER|(m_align<0?DT_LEFT:m_align>0?DT_RIGHT:DT_CENTER)|DT_NOPREFIX);
}
}
}
}
if (!bkbm)
{
LICE_Line(drawbm,col_x,y,col_x+col_w,y,pencol2,1.0f,LICE_BLIT_MODE_COPY,false);
}
}
}
memset(&m_lastscrollbuttons,0,sizeof(m_lastscrollbuttons));
if (updownbuttonsize||leftrightbuttonsize)
{
WDL_VirtualWnd_BGCfg *bkbm=0;
int a=m_GetItemInfo ? m_GetItemInfo(this,
leftrightbuttonsize ? WDL_VWND_LISTBOX_ARROWINDEX_LR : WDL_VWND_LISTBOX_ARROWINDEX,NULL,0,NULL,&bkbm) : 0;
if (leftrightbuttonsize)
{
RECT br={0,0,r.right-r.left,r.bottom-r.top};
if (startpos>0)
{
m_lastscrollbuttons[0]=br;
m_lastscrollbuttons[0].right = br.left + m_scrollbuttonsize;
}
if (itempos < num_items)
{
m_lastscrollbuttons[1]=br;
m_lastscrollbuttons[1].left=br.right - m_scrollbuttonsize;
}
}
else
{
RECT br={0,y-r.top - m_rh,r.right-r.left,y-r.top - m_rh + m_scrollbuttonsize};
if (startpos>0)
{
m_lastscrollbuttons[0]=br;
m_lastscrollbuttons[0].right = (br.left+br.right)/2;
}
if (itempos < num_items)
{
m_lastscrollbuttons[1]=br;
m_lastscrollbuttons[1].left = (br.left+br.right)/2;
}
}
if (bkbm && bkbm->bgimage)
{
if (leftrightbuttonsize)
{
int bkbmstate=startpos>0 ? 2 : 1;
DrawBkImage(drawbm,bkbm,
r.left,r.top,m_scrollbuttonsize,(r.bottom-r.top),
cliprect,
0,bkbm->bgimage->getWidth()/2,bkbmstate);
bkbmstate=itempos<num_items ? 2 : 1;
DrawBkImage(drawbm,bkbm,
r.right-m_scrollbuttonsize,r.top,m_scrollbuttonsize,(r.bottom-r.top),
cliprect,
bkbm->bgimage->getWidth()/2,bkbm->bgimage->getWidth() - bkbm->bgimage->getWidth()/2,bkbmstate);
}
else
{
int bkbmstate=startpos>0 ? 2 : 1;
DrawBkImage(drawbm,bkbm,
r.left,y-m_rh,(r.right-r.left)/2,m_scrollbuttonsize,
cliprect,
0,bkbm->bgimage->getWidth()/2,bkbmstate);
bkbmstate=itempos<num_items ? 2 : 1;
DrawBkImage(drawbm,bkbm,
(r.left+r.right)/2,y-m_rh,(r.right-r.left) - (r.right-r.left)/2,m_scrollbuttonsize,
cliprect,
bkbm->bgimage->getWidth()/2,bkbm->bgimage->getWidth() - bkbm->bgimage->getWidth()/2,bkbmstate);
}
}
if (!a||!bkbm||!bkbm->bgimage)
{
bool butaa = true;
if (updownbuttonsize)
{
int cx=(r.left+r.right)/2;
int bs=5;
int bsh=8;
LICE_Line(drawbm,cx,y-m_scrollbuttonsize+2,cx,y-1,pencol2,1.0f,0,false);
LICE_Line(drawbm,r.left,y,r.right,y,pencol2,1.0f,0,false);
y-=m_scrollbuttonsize/2+bsh/2;
if (itempos<num_items)
{
cx=(r.left+r.right)*3/4;
LICE_Line(drawbm,cx-bs+1,y+2,cx,y+bsh-2,pencol2,1.0f,0,butaa);
LICE_Line(drawbm,cx,y+bsh-2,cx+bs-1,y+2,pencol2,1.0f,0,butaa);
LICE_Line(drawbm,cx+bs-1,y+2,cx-bs+1,y+2,pencol2,1.0f,0,butaa);
LICE_Line(drawbm,cx-bs-1,y+1,cx,y+bsh-1,pencol,1.0f,0,butaa);
LICE_Line(drawbm,cx,y+bsh-1,cx+bs+1,y+1,pencol,1.0f,0,butaa);
LICE_Line(drawbm,cx+bs+1,y+1,cx-bs-1,y+1,pencol,1.0f,0,butaa);
}
if (startpos>0)
{
y-=2;
cx=(r.left+r.right)/4;
LICE_Line(drawbm,cx-bs+1,y+bsh,cx,y+3+1,pencol2,1.0f,0,butaa);
LICE_Line(drawbm,cx,y+3+1,cx+bs-1,y+bsh,pencol2,1.0f,0,butaa);
LICE_Line(drawbm,cx+bs-1,y+bsh,cx-bs+1,y+bsh,pencol2,1.0f,0,butaa);
LICE_Line(drawbm,cx-bs-1,y+bsh+1,cx,y+3,pencol,1.0f,0,butaa);
LICE_Line(drawbm,cx,y+3,cx+bs+1,y+bsh+1,pencol,1.0f,0,butaa);
LICE_Line(drawbm,cx+bs+1,y+bsh+1, cx-bs-1,y+bsh+1, pencol,1.0f,0,butaa);
}
}
else // sideways buttons
{
#define LICE_LINEROT(bm,x1,y1,x2,y2,pc,al,mode,aa) LICE_Line(bm,y1,x1,y2,x2,pc,al,mode,aa)
int bs=5;
int bsh=8;
int cx = (r.bottom + r.top)/2;
if (itempos < num_items)
{
int y = r.right - leftrightbuttonsize/2 - bsh/2;
LICE_LINEROT(drawbm,cx-bs+1,y+2,cx,y+bsh-2,pencol2,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx,y+bsh-2,cx+bs-1,y+2,pencol2,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx+bs-1,y+2,cx-bs+1,y+2,pencol2,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx-bs-1,y+1,cx,y+bsh-1,pencol,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx,y+bsh-1,cx+bs+1,y+1,pencol,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx+bs+1,y+1,cx-bs-1,y+1,pencol,1.0f,0,butaa);
}
if (startpos>0)
{
int y = r.left + leftrightbuttonsize/2-bsh/2 - 2;
LICE_LINEROT(drawbm,cx-bs+1,y+bsh,cx,y+3+1,pencol2,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx,y+3+1,cx+bs-1,y+bsh,pencol2,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx+bs-1,y+bsh,cx-bs+1,y+bsh,pencol2,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx-bs-1,y+bsh+1,cx,y+3,pencol,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx,y+3,cx+bs+1,y+bsh+1,pencol,1.0f,0,butaa);
LICE_LINEROT(drawbm,cx+bs+1,y+bsh+1, cx-bs-1,y+bsh+1, pencol,1.0f,0,butaa);
}
#undef LICE_LINEROT
}
}
}
if (!mainbk)
{
LICE_Line(drawbm,r.left,r.bottom-1,r.left,r.top,pencol,1.0f,0,false);
LICE_Line(drawbm,r.left,r.top,r.right-1,r.top,pencol,1.0f,0,false);
LICE_Line(drawbm,r.right-1,r.top,r.right-1,r.bottom-1,pencol2,1.0f,0,false);
LICE_Line(drawbm,r.right-1,r.bottom-1,r.left,r.bottom-1,pencol2,1.0f,0,false);
}
}
bool WDL_VirtualListBox::HandleScrollClicks(int xpos, int ypos, int leftrightbuttonsize, int updownbuttonsize, int nrows, int num_cols, int num_items, int usedw)
{
if (leftrightbuttonsize && (xpos<m_scrollbuttonsize || xpos >= usedw-m_scrollbuttonsize))
{
if (xpos<m_scrollbuttonsize)
{
if (m_viewoffs>0)
{
m_viewoffs-=nrows;
if (m_viewoffs<0)m_viewoffs=0;
RequestRedraw(NULL);
}
}
else
{
if (m_viewoffs+nrows*num_cols < num_items)
{
m_viewoffs+=nrows;
RequestRedraw(NULL);
}
}
m_cap_state=0;
m_cap_startitem=-1;
return true;
}
if (updownbuttonsize && ypos >= nrows*m_rh)
{
if (ypos < (nrows)*m_rh + m_scrollbuttonsize)
{
if (xpos < usedw/2)
{
if (m_viewoffs>0)
{
m_viewoffs--;
RequestRedraw(NULL);
}
}
else
{
if (m_viewoffs+nrows*num_cols < num_items)
{
m_viewoffs++;
RequestRedraw(NULL);
}
}
}
m_cap_state=0;
m_cap_startitem=-1;
return true;
}
return false;
}
int WDL_VirtualListBox::OnMouseDown(int xpos, int ypos)
{
if (m_grayed) return false;
int num_items = m_GetItemInfo ? m_GetItemInfo(this,-1,NULL,0,NULL,NULL) : 0;
int nrows,num_cols,updownbuttonsize,leftrightbuttonsize,startpos,usedw;
CalcLayout(num_items,&nrows,&num_cols,&leftrightbuttonsize,&updownbuttonsize,&startpos,&usedw);
if (xpos >= usedw) return 0;
if (HandleScrollClicks(xpos,ypos,leftrightbuttonsize,updownbuttonsize,nrows,num_cols,num_items,usedw)) return 1;
m_cap_state=0x1000;
int usewid=(usedw-leftrightbuttonsize*2);
int col = num_cols > 0 && usewid>0 ? ((xpos-leftrightbuttonsize)*num_cols)/usewid : 0;
m_cap_startitem=startpos + (ypos)/m_rh + col*nrows;
RequestRedraw(NULL);
return 1;
}
bool WDL_VirtualListBox::OnMouseDblClick(int xpos, int ypos)
{
if (m_grayed) return false;
int num_items = m_GetItemInfo ? m_GetItemInfo(this,-1,NULL,0,NULL,NULL) : 0;
int nrows,num_cols,updownbuttonsize,leftrightbuttonsize,startpos,usedw;
CalcLayout(num_items,&nrows,&num_cols,&leftrightbuttonsize,&updownbuttonsize,&startpos,&usedw);
if (xpos >= usedw) return false;
if (HandleScrollClicks(xpos,ypos,leftrightbuttonsize,updownbuttonsize,nrows,num_cols,num_items,usedw)) return true;
return false;
}
bool WDL_VirtualListBox::OnMouseWheel(int xpos, int ypos, int amt)
{
if (m_grayed) return false;
int num_items = m_GetItemInfo ? m_GetItemInfo(this,-1,NULL,0,NULL,NULL) : 0;
int nrows,num_cols,updownbuttonsize,leftrightbuttonsize,startpos,usedw;
CalcLayout(num_items,&nrows,&num_cols,&leftrightbuttonsize,&updownbuttonsize,&startpos,&usedw);
if (xpos >= usedw) return false;
if (num_items > nrows*num_cols)
{
if (amt>0 && m_viewoffs>0)
{
m_viewoffs-=(num_cols>1?nrows:1);
if (m_viewoffs<0)m_viewoffs=0;
RequestRedraw(NULL);
}
else if (amt<0)
{
if (m_viewoffs+nrows*num_cols < num_items)
{
m_viewoffs+=(num_cols>1?nrows:1);
RequestRedraw(NULL);
}
}
}
return true;
}
void WDL_VirtualListBox::OnMouseMove(int xpos, int ypos)
{
if (m_grayed) return;
if (m_cap_state>=0x1000)
{
m_cap_state++;
if (m_cap_state==0x1008)
{
if (m_dragbeginmsg)
{
SendCommand(m_dragbeginmsg,(INT_PTR)this,m_cap_startitem,this);
}
}
}
else if (m_cap_state==0)
{
int a=IndexFromPt(xpos,ypos);
if (a>=0)
{
m_cap_startitem=a;
m_cap_state=1;
RequestRedraw(NULL);
}
}
else if (m_cap_state==1)
{
int a=IndexFromPt(xpos,ypos);
if (a>=0 && a != m_cap_startitem)
{
m_cap_startitem=a;
m_cap_state=1;
RequestRedraw(NULL);
}
else if (a<0)
{
m_cap_state=0;
RequestRedraw(NULL);
}
}
}
void WDL_VirtualListBox::OnMouseUp(int xpos, int ypos)
{
if (m_grayed) return;
int hit=IndexFromPt(xpos,ypos);
if (m_cap_state>=0x1000 && m_cap_state<0x1008 && hit==m_cap_startitem)
{
if (m_clickmsg)
{
SendCommand(m_clickmsg,(INT_PTR)this,hit,this);
}
}
else if (m_cap_state>=0x1008)
{
// send a message saying drag & drop occurred
if (m_dropmsg)
SendCommand(m_dropmsg,(INT_PTR)this,m_cap_startitem,this);
}
m_cap_state=0;
RequestRedraw(NULL);
}
bool WDL_VirtualListBox::GetItemRect(int item, RECT *r)
{
int num_items = m_GetItemInfo ? m_GetItemInfo(this,-1,NULL,0,NULL,NULL) : 0;
int nrows,num_cols,updownbuttonsize,leftrightbuttonsize,startpos, usedw;
CalcLayout(num_items,&nrows,&num_cols,&leftrightbuttonsize,&updownbuttonsize,&startpos,&usedw);
item -= startpos;
if (r)
{
int col = item / nrows;
int row = item % nrows;
r->top = row * m_rh;
r->bottom = (row+1)*m_rh;
r->left = leftrightbuttonsize + (col * (usedw - leftrightbuttonsize*2)) / num_cols;
r->right = leftrightbuttonsize + ((col+1) * (usedw - leftrightbuttonsize*2)) / num_cols;
}
return item >= startpos && item < startpos + nrows*num_cols;;
}
int WDL_VirtualListBox::IndexFromPt(int x, int y)
{
int num_items = m_GetItemInfo ? m_GetItemInfo(this,-1,NULL,0,NULL,NULL) : 0;
int nrows,num_cols,updownbuttonsize,leftrightbuttonsize,startpos,usedw;
CalcLayout(num_items,&nrows,&num_cols,&leftrightbuttonsize,&updownbuttonsize,&startpos,&usedw);
if (x>=usedw) return -2;
if (y < 0 || y >= nrows*m_rh ||x<leftrightbuttonsize || x >= (usedw-leftrightbuttonsize)) return -1;
int usewid=(usedw-leftrightbuttonsize*2);
int col = num_cols > 0 && usewid>0 ? ((x-leftrightbuttonsize)*num_cols)/usewid : 0;
return startpos + (y)/m_rh + col * nrows;
}
void WDL_VirtualListBox::SetViewOffset(int offs)
{
int num_items = m_GetItemInfo ? m_GetItemInfo(this,-1,NULL,0,NULL,NULL) : 0;
if (num_items)
{
if (offs < 0) offs=0;
else if (offs >= num_items) offs = num_items-1;
if (offs != m_viewoffs)
{
m_viewoffs = offs;
RequestRedraw(0);
}
}
}
int WDL_VirtualListBox::GetViewOffset()
{
return m_viewoffs;
}
| [
"[email protected]"
] | [
[
[
1,
670
]
]
] |
762bcf9cb27ed9f3f386f6927efd35abf52cfbed | b14d5833a79518a40d302e5eb40ed5da193cf1b2 | /cpp/extern/xercesc++/2.6.0/src/xercesc/internal/MemoryManagerArrayImpl.hpp | ecb21090db5c5d46e21c1400c30c5dd60f2f25b9 | [
"Apache-2.0"
] | permissive | andyburke/bitflood | dcb3fb62dad7fa5e20cf9f1d58aaa94be30e82bf | fca6c0b635d07da4e6c7fbfa032921c827a981d6 | refs/heads/master | 2016-09-10T02:14:35.564530 | 2011-11-17T09:51:49 | 2011-11-17T09:51:49 | 2,794,411 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,536 | hpp | /*
* Copyright 2003,2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* $Id: MemoryManagerArrayImpl.hpp,v 1.2 2004/09/08 13:56:13 peiyongz Exp $
*/
#if !defined(MEMORYMANAGERARRAYIMPL_HPP)
#define MEMORYMANAGERARRAYIMPL_HPP
#include <xercesc/framework/MemoryManager.hpp>
XERCES_CPP_NAMESPACE_BEGIN
/**
* Configurable memory manager
*
* <p>This is specialized version of a Xerces
* memory manager, which allocates memory using
* using new[](size) syntax. Such memory may
* legally be deleted with delete[].
* </p>
* <p>This version is used in special cases where it is desired
* that allocated memory be able to be delete[]d.
* </p>
*/
class XMLUTIL_EXPORT MemoryManagerArrayImpl : public MemoryManager
{
public:
/** @name Constructor */
//@{
/**
* Default constructor
*/
MemoryManagerArrayImpl()
{
}
//@}
/** @name Destructor */
//@{
/**
* Default destructor
*/
virtual ~MemoryManagerArrayImpl()
{
}
//@}
/** @name The virtual methods in MemoryManager */
//@{
/**
* This method allocates requested memory.
*
* @param size The requested memory size
*
* @return A pointer to the allocated memory
*/
virtual void* allocate(size_t size);
/**
* This method deallocates memory
*
* @param p The pointer to the allocated memory to be deleted
*/
virtual void deallocate(void* p);
//@}
private:
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
MemoryManagerArrayImpl(const MemoryManagerArrayImpl&);
MemoryManagerArrayImpl& operator=(const MemoryManagerArrayImpl&);
};
XERCES_CPP_NAMESPACE_END
#endif
| [
"[email protected]"
] | [
[
[
1,
100
]
]
] |
0adb270f125b6f0b6e0278198871cc3a49c4e878 | bc6e0bcbe791cd2210277a87c1646eb20c100382 | /src/EntityProcessingSystem.cpp | bea75c0b7dc2b377135e90b37d49ee9d7630bb9c | [] | no_license | dstratman/entity_system | d64bd104468c1b9432a1de130ba71ba43895ff00 | afc19fdd8c806d3aff4ec0a24958505f9919eb0b | refs/heads/master | 2016-09-08T01:34:51.554400 | 2011-06-11T19:22:47 | 2011-06-11T19:22:47 | 1,878,722 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 262 | cpp | #include "EntityProcessingSystem.h"
void EntityProcessingSystem::processEntities(std::vector<int> mAllEntities, float timeDelta)
{
mDelta = timeDelta;
for(int i=0, s= mAllEntities.size(); s>i; i++)
{
process(mAllEntities.at(i));
}
}
| [
"[email protected]"
] | [
[
[
1,
10
]
]
] |
be892fff368cd480f81c9f8bfd23ab645e85935c | bef7d0477a5cac485b4b3921a718394d5c2cf700 | /testShadows/src/demo/Shadows.h | 6d1a8c9c5f781fcc7cbe7d7c0e2c7a31151486ab | [
"MIT"
] | permissive | TomLeeLive/aras-p-dingus | ed91127790a604e0813cd4704acba742d3485400 | 22ef90c2bf01afd53c0b5b045f4dd0b59fe83009 | refs/heads/master | 2023-04-19T20:45:14.410448 | 2011-10-04T10:51:13 | 2011-10-04T10:51:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,169 | h | #ifndef __SHADOWS_H
#define __SHADOWS_H
#include "Entity.h"
#include "DemoResources.h"
#include <dingus/renderer/RenderableMesh.h>
class SceneEntity;
struct Light;
struct ShadowBuffer;
typedef std::vector<SceneEntity*> SceneEntityPtrs;
typedef std::vector<Light*> LightPtrs;
typedef std::vector<ShadowBuffer*> ShadowBufferPtrs;
const int kShaderShadowTextureIndex = 4;
// --------------------------------------------------------------------------
class SceneEntity : public CAbstractEntity {
public:
SceneEntity( const std::string& name );
virtual ~SceneEntity();
float getRadius() const { return mRadius; }
/// Updates WVP, adds to render context
void render( eRenderMode renderMode, bool updateWVP, bool direct );
CRenderableMesh* getRenderMesh( eRenderMode renderMode ) { return mRenderMeshes[renderMode]; }
private:
CRenderableMesh* mRenderMeshes[RMCOUNT];
CMesh* mMesh;
float mRadius;
public:
ShadowBufferPtrs m_ShadowBuffers;
SVector3 m_Color;
bool m_CanAnimate;
};
extern SceneEntityPtrs gScene;
// --------------------------------------------------------------------------
struct ShadowBuffer
{
Light* m_Light; // light this SB belongs to
float m_PixelDensity; // pixel density of this SB
#if _DEBUG
SceneEntityPtrs m_Entities; // entities using this SB
#endif
SceneEntityPtrs m_Casters; // casters in this SB
ViewCone m_LSpaceCone; // light space cone of this SB
// render target data
SMatrix4x4 m_TextureProjMatrix;
int m_RTSize;
CD3DTexture* m_RTTexture;
CD3DSurface* m_RTSurface;
void SetOntoRenderContext();
};
extern ShadowBufferPtrs gShadowBuffers;
// --------------------------------------------------------------------------
struct Light : public CCameraEntity
{
ShadowBufferPtrs m_ShadowBuffers; // SBs that this light uses
SceneEntityPtrs m_Entities; // objects in light
SVector3 m_Color;
};
extern LightPtrs gLights;
// --------------------------------------------------------------------------
void RenderSceneWithShadows( CCameraEntity& camera, float shadowQuality );
#endif
| [
"[email protected]"
] | [
[
[
1,
91
]
]
] |
e05f74c3d36265b96d31511666febe9b22cac44e | 444a151706abb7bbc8abeb1f2194a768ed03f171 | /trunk/ENIGMAsystem/SHELL/Graphics_Systems/OpenGL/GSmiscextra.cpp | c093a8a5bc76f19d0a171d8fe0f25bd472d6ff85 | [] | no_license | amorri40/Enigma-Game-Maker | 9d01f70ab8de42f7c80af9a0f8c7a66e412d19d6 | c6b701201b6037f2eb57c6938c184a5d4ba917cf | refs/heads/master | 2021-01-15T11:48:39.834788 | 2011-11-22T04:09:28 | 2011-11-22T04:09:28 | 1,855,342 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,634 | cpp | /** Copyright (C) 2008-2011 Josh Ventura
***
*** This file is a part of the ENIGMA Development Environment.
***
*** ENIGMA 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, version 3 of the license or any later version.
***
*** This application and its source code is distributed AS-IS, 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 code. If not, see <http://www.gnu.org/licenses/>
**/
#include "OpenGLHeaders.h"
#include <string>
#include <stdio.h>
using namespace std;
#include "GSmiscextra.h"
//Fuck whoever did this to the spec
#ifndef GL_BGR
#define GL_BGR 0x80E0
#endif
extern int window_get_width();
extern int window_get_height();
int screen_save(string filename) //Assumes native integers are little endian
{
unsigned int w=window_get_width(),h=window_get_height(),sz=w*h;
FILE *bmp = fopen(filename.c_str(),"wb");
if(!bmp) return -1;
char *scrbuf = new char[sz*3];
glReadPixels(0,0,w,h,GL_BGR,GL_UNSIGNED_BYTE,scrbuf);
fwrite("BM",2,1,bmp);
sz <<= 2;
fwrite(&sz,4,1,bmp);
fwrite("\0\0\0\0\x36\0\0\0\x28\0\0",12,1,bmp);
fwrite(&w,4,1,bmp);
fwrite(&h,4,1,bmp);
fwrite("\1\0\x18\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",28,1,bmp);
if (w & 3)
{
size_t pad=w&3;
w*=3;
sz-=sz>>2;
for(unsigned int i=0;i<sz;i+=w)
{
fwrite(scrbuf+i,w,1,bmp);
fwrite("\0\0",pad,1,bmp);
}
} else fwrite(scrbuf,w*3,h,bmp);
fclose(bmp);
delete[] scrbuf;
return 0;
}
int screen_save_part(string filename,unsigned x,unsigned y,unsigned w,unsigned h) //Assumes native integers are little endian
{
unsigned sz = w * h;
FILE *bmp=fopen(filename.c_str(), "wb");
if (!bmp) return -1;
fwrite("BM", 2, 1, bmp);
char *scrbuf = new char[sz*3];
glReadPixels(x, y, w, h, GL_BGR, GL_UNSIGNED_BYTE, scrbuf);
sz <<= 2;
fwrite(&sz,4,1,bmp);
fwrite("\0\0\0\0\x36\0\0\0\x28\0\0",12,1,bmp);
fwrite(&w,4,1,bmp);
fwrite(&h,4,1,bmp);
fwrite("\1\0\x18\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",28,1,bmp);
if (w & 3)
{
size_t pad = w & 3;
w *= 3;
sz -= sz >> 2;
for(unsigned i = 0; i < sz; i += w)
{
fwrite(scrbuf+i,w,1,bmp);
fwrite("\0\0",pad,1,bmp);
}
}
else fwrite(scrbuf, w*3, h, bmp);
fclose(bmp);
delete[] scrbuf;
return 0;
}
| [
"[email protected]"
] | [
[
[
1,
100
]
]
] |
6df03b1a03d55e139f76345553467abda8a4b8b0 | c3531ade6396e9ea9c7c9a85f7da538149df2d09 | /Param/src/Graphite/OGF/basic/types/counted.h | 6c0d124963157f5b1f638d90ff9a53ae0b01d93d | [] | 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 | 2,956 | h | /*
* OGF/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000 Bruno Levy
*
* 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* If you modify this software, you should include a notice giving the
* name of the person performing the modification, the date of modification,
* and the reason for such modification.
*
* Contact: Bruno Levy
*
* [email protected]
*
* ISA Project
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* Note that the GNU General Public License does not permit incorporating
* the Software into proprietary programs.
*/
#ifndef __OGF_BASIC_TYPES_COUNTED__
#define __OGF_BASIC_TYPES_COUNTED__
#include <OGF/basic/common/common.h>
#include <OGF/basic/types/types.h>
#include <OGF/basic/types/smart_pointer.h>
#include <OGF/basic/debug/assert.h>
namespace OGF {
//____________________________________________________________________________
/**
* This is the base class to be used for objects having
* "reference count" memory management. They can be
* referred to by using SmartPointer<T>, calling ref()
* and unref() when necessary.
* @see SmartPointer
*/
class BASIC_API Counted {
public:
Counted() ;
virtual ~Counted() ;
void ref() const ;
void unref() const ;
bool is_shared() const ;
static void ref(const Counted* counted) ;
static void unref(const Counted* counted) ;
protected:
private:
int nb_refs_ ;
} ;
//____________________________________________________________________________
inline Counted::Counted() : nb_refs_(0) {
}
inline void Counted::ref() const {
Counted* non_const_this = (Counted *)this ;
non_const_this-> nb_refs_++ ;
}
inline void Counted::unref() const {
Counted* non_const_this = (Counted *)this ;
non_const_this-> nb_refs_-- ;
ogf_assert(nb_refs_ >= 0) ;
if(nb_refs_ == 0) {
delete this ;
}
}
inline bool Counted::is_shared() const {
return (nb_refs_ > 1) ;
}
}
#endif
| [
"[email protected]"
] | [
[
[
1,
105
]
]
] |
2409b901a6362f7f4c3aa1b3d72754298e1e1559 | ea12fed4c32e9c7992956419eb3e2bace91f063a | /zombie/code/zombie/zombieentity/src/zombieentity/nctransformclass_main.cc | aded1d3709ab42ba972ad13f246d48517db496ba | [] | no_license | ugozapad/TheZombieEngine | 832492930df28c28cd349673f79f3609b1fe7190 | 8e8c3e6225c2ed93e07287356def9fbdeacf3d6a | refs/heads/master | 2020-04-30T11:35:36.258363 | 2011-02-24T14:18:43 | 2011-02-24T14:18:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 943 | cc | #include "precompiled/pchncshared.h"
//------------------------------------------------------------------------------
// nctransformclass_main.cc
// (C) 2005 Conjurer Services, S.A.
//------------------------------------------------------------------------------
#include "zombieentity/nctransformclass.h"
//------------------------------------------------------------------------------
nNebulaComponentClass(ncTransformClass, nComponentClass);
//------------------------------------------------------------------------------
NSCRIPT_INITCMDS_BEGIN(ncTransformClass)
NSCRIPT_INITCMDS_END()
//------------------------------------------------------------------------------
/**
constructor
*/
ncTransformClass::ncTransformClass()
{
// empty
}
//------------------------------------------------------------------------------
/**
destructor
*/
ncTransformClass::~ncTransformClass()
{
// empty
}
| [
"magarcias@c1fa4281-9647-0410-8f2c-f027dd5e0a91"
] | [
[
[
1,
31
]
]
] |
78fa3d94fa10a1afd92bc20c723467e84dea51a0 | f177993b13e97f9fecfc0e751602153824dfef7e | /ImProSln/SyncFilter/SyncFilter.cpp | ef956147b5280af96dbf1c4a61b773b020d80f6d | [] | 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 | 21,286 | cpp | #include "stdafx.h"
#include "SyncFilter.h"
#include "SyncFilterApp.h"
#include "MyMediaSample.h"
#include "MyARTagMediaSample.h"
SyncFilter::SyncFilter(IUnknown * pOuter, HRESULT * phr, BOOL ModifiesData)
: CMuxTransformFilter(NAME("Sync Filter"), 0, CLSID_SyncFilter)
{
setDirty(false);
setBlock(false);
}
SyncFilter::~SyncFilter()
{
}
CUnknown *WINAPI SyncFilter::CreateInstance(LPUNKNOWN punk, HRESULT *phr)
{
ASSERT(phr);
// assuming we don't want to modify the data
SyncFilter *pNewObject = new SyncFilter(punk, phr, FALSE);
if(pNewObject == NULL) {
if (phr)
*phr = E_OUTOFMEMORY;
}
return pNewObject;
}
HRESULT SyncFilter::NonDelegatingQueryInterface(REFIID iid, void **ppv)
{
if (iid == IID_ISyncFilter)
{
return GetInterface(static_cast<ISyncFilter*>(this), ppv);
}
else
{
// Call the parent class.
return CBaseFilter::NonDelegatingQueryInterface(iid, ppv);
}
}
HRESULT SyncFilter::ReceiveCameraImg(IMediaSample *pSample, const IPin* pReceivePin)
{
if (m_pOutputPins.size() < 1)
{
return S_FALSE;
}
AM_SAMPLE2_PROPERTIES * const pProps = ((CMuxTransformInputPin*)pReceivePin)->SampleProps();
if (pProps->dwStreamId != AM_STREAM_MEDIA) {
return S_OK;
}
ASSERT(pSample);
IMediaSample * pOutSample = NULL;
ASSERT (m_pOutputPins.size() != NULL);
HRESULT hr = S_OK;
MSR_START(m_idTransform);
pOutSample = pSample;
pOutSample->AddRef();
MSR_STOP(m_idTransform);
if (FAILED(hr)) {
DbgLog((LOG_TRACE,1,TEXT("Error from transform")));
} else {
if (hr == NOERROR) {
hr = GetConnectedOutputPin(0)->Deliver(pOutSample);// m_pInputPin->Receive(pOutSample);
m_bSampleSkipped = FALSE; // last thing no longer dropped
} else {
if (S_FALSE == hr) {
pOutSample->Release();
m_bSampleSkipped = TRUE;
if (!m_bQualityChanged) {
NotifyEvent(EC_QUALITY_CHANGE,0,0);
m_bQualityChanged = TRUE;
}
return NOERROR;
}
}
}
pOutSample->Release();
return S_OK;
}
HRESULT SyncFilter::ReceiveDirty(IMediaSample *pSample, const IPin* pReceivePin){
CAutoLock lck(&locMarkerInfo);
ARLayoutConfigData* pARTagResult = NULL;
pSample->GetPointer((BYTE**)&pARTagResult);
if (pARTagResult == NULL)
{
return S_FALSE;
}
tagConfig = *pARTagResult;
setDirty(true);
return S_OK;
}
HRESULT SyncFilter::CopyInRT2OutTexture()
{
CCritSec* pD3DCS = NULL;
QueryD3DDeviceCS(NULL, pD3DCS);
if (pD3DCS == NULL)
return S_FALSE;
CAutoLock lck(pD3DCS);
IDirect3DSurface9* pInSurface = NULL, *pOutSurface = NULL;
m_pInTexture->GetSurfaceLevel(0, &pInSurface);
m_pOutTexture->GetSurfaceLevel(0, &pOutSurface);
IDirect3DDevice9* pDevice = m_pD3DDisplay->GetD3DDevice();
pDevice->GetRenderTargetData(pInSurface, pOutSurface);
if (pInSurface != NULL)
{
pInSurface->Release();
pInSurface = NULL;
}
if (pOutSurface != NULL)
{
pOutSurface->Release();
pOutSurface = NULL;
}
return S_OK;
}
HRESULT SyncFilter::ReceiveLayoutImg(IMediaSample *pSample, const IPin* pReceivePin)
{
if (m_pOutputPins.size() < 2)
{
return S_FALSE;
}
AM_SAMPLE2_PROPERTIES * const pProps = ((CMuxTransformInputPin*)pReceivePin)->SampleProps();
if (pProps->dwStreamId != AM_STREAM_MEDIA) {
return S_OK;
}
ASSERT(pSample);
IMediaSample* pOutSampleD3D = NULL;
IMediaSample* pOutSampleRGB = NULL;
CMediaSample* pOutSampleConfig = NULL ;
CMuxTransformOutputPin* pOutBGPin = GetConnectedOutputPin(1);
CMuxTransformOutputPin* pOutRenderPin = GetConnectedOutputPin(2);
ARLayoutConfigData sendData ;
// If no output to deliver to then no point sending us data
ASSERT (m_pOutputPins.size() != NULL);
HRESULT hr = S_FALSE;
// Set up the output sample
MSR_START(m_idTransform);
if(pOutRenderPin != NULL && pOutRenderPin->IsConnected()){
hr = InitializeOutputSample(pSample, pReceivePin, pOutRenderPin, &pOutSampleD3D);
hr = LayoutTransform(pSample, pOutSampleD3D);
}
if(pOutBGPin != NULL && pOutBGPin->IsConnected() && getDirty() == true){
if(layoutType == 0){
hr = InitializeOutputSample(pSample, pReceivePin, pOutBGPin, &pOutSampleRGB);
hr = CopyRenderTarget2OutputTexture();
hr = CopyOutputTexture2OutputData(pOutSampleRGB,&pOutBGPin->CurrentMediaType(),0);
}
else if(layoutType == 1){
{
CAutoLock lck(&locMarkerInfo);
sendData.m_ARMarkers = tagConfig.m_ARMarkers;
sendData.m_numMarker = tagConfig.m_numMarker;
IMemAllocator* pAllocator = m_pOutputPins[1]->Allocator();
pAllocator->GetBuffer((IMediaSample**)&pOutSampleConfig, NULL, NULL, 0);
if (pOutSampleConfig == NULL)
{
sendData.m_ARMarkers = NULL;
sendData.m_numMarker = 0;
return S_FALSE;
}
pOutSampleConfig->SetPointer((BYTE*)&sendData, sizeof(ARLayoutConfigData));
}
}
}
if (FAILED(hr)) {
return hr;
}
if(getDirty() == true){
setBlock(true);
}
//MSR_STOP(m_idTransform);
if (FAILED(hr)) {
DbgLog((LOG_TRACE,1,TEXT("Error from transform")));
} else {
if (hr == NOERROR) {
if(pOutSampleRGB != NULL && layoutType == 0 && getDirty()== true){
hr = GetConnectedOutputPin(1)->Deliver(pOutSampleRGB);// Pin1 :: BG only deliver in layout change
setDirty(false);
}
if(pOutSampleConfig != NULL && layoutType == 1 && getDirty()== true){
hr = GetConnectedOutputPin(1)->Deliver(pOutSampleConfig);
setDirty(false);
}
if( pOutSampleD3D != NULL){
hr = GetConnectedOutputPin(2)->Deliver(pOutSampleD3D);// Pin2 :: Render every frame deliver
}
setBlock(false);
m_bSampleSkipped = FALSE; // last thing no longer dropped
} else {
if (S_FALSE == hr) {
if (pOutSampleRGB != NULL)
{
pOutSampleRGB->Release();
pOutSampleRGB = NULL;
}
if (pOutSampleD3D != NULL)
{
pOutSampleD3D->Release();
pOutSampleD3D = NULL;
}
m_bSampleSkipped = TRUE;
if (!m_bQualityChanged) {
NotifyEvent(EC_QUALITY_CHANGE,0,0);
m_bQualityChanged = TRUE;
}
return NOERROR;
}
}
}
sendData.m_ARMarkers = NULL;
sendData.m_numMarker = 0;
if(pOutSampleRGB != NULL)
{
pOutSampleRGB->Release();
pOutSampleRGB = NULL;
}
if(pOutSampleD3D != NULL)
{
pOutSampleD3D->Release();
pOutSampleD3D = NULL;
}
if (pOutSampleConfig != NULL)
{
pOutSampleConfig->Release();
pOutSampleConfig = NULL;
}
return S_OK;
}
CMuxTransformOutputPin* SyncFilter::GetConnectedOutputPin(int pinNum )
{
if (m_pOutputPins[pinNum]->IsConnected())
{
return m_pOutputPins[pinNum];
}
return NULL;
}
HRESULT SyncFilter::Receive(IMediaSample *pSample, const IPin* pReceivePin)
{
HRESULT hr = S_OK;
if (m_pInputPins.size() >= 3 && pReceivePin == m_pInputPins[0] && !getBlock())
{
hr = ReceiveCameraImg(pSample, pReceivePin);
}
if (m_pInputPins.size() >= 3 && pReceivePin == m_pInputPins[1])
{
hr = ReceiveDirty(pSample, pReceivePin);
}
if (m_pInputPins.size() >= 3 && pReceivePin == m_pInputPins[2])
{
hr = ReceiveLayoutImg(pSample, pReceivePin);
}
return hr;
}
HRESULT SyncFilter::CreatePins()
{
HRESULT hr = S_OK;
if (m_pInputPins.size() < 3 || m_pOutputPins.size() < 3) {
for (int c = 0; c< m_pInputPins.size(); c++)
{
delete m_pInputPins[c];
m_pInputPins[c] = NULL;
}
m_pInputPins.clear();
for (int c = 0; c< m_pOutputPins.size(); c++)
{
delete m_pOutputPins[c];
m_pOutputPins[c] = NULL;
}
m_pOutputPins.clear();
CMuxTransformInputPin* pInput0 = new CMuxTransformInputPin(NAME("Camera input pin"),
this, // Owner filter
&hr, // Result code
L"camInput"); // Pin name
// Can't fail
CMuxTransformInputPin* pInput1 = new CMuxTransformInputPin(NAME("Dirty pin"),
this, // Owner filter
&hr, // Result code
L"Dirty"); // Pin name
// Can't fail
CMuxTransformInputPin* pInput2 = new CMuxTransformInputPin(NAME("Layout input pin"),
this, // Owner filter
&hr, // Result code
L"Layout"); // Pin name
// Can't fail
CMuxTransformOutputPin* pOut0 = new CMuxTransformOutputPin(NAME("camera output pin"),
this, // Owner filter
&hr, // Result code
L"CamOut"); // Pin name
// Can't fail
CMuxTransformOutputPin* pOut1 = new CMuxTransformOutputPin(NAME("BG output pin"),
this, // Owner filter
&hr, // Result code
L"BG"); // Pin name
// Can't fail
CMuxTransformOutputPin* pOut2 = new CMuxTransformOutputPin(NAME("Render output pin"),
this, // Owner filter
&hr, // Result code
L"Render"); // Pin name
// Can't fail
m_pInputPins.push_back(pInput0);
m_pInputPins.push_back(pInput1);
m_pInputPins.push_back(pInput2);
m_pOutputPins.push_back(pOut0);
m_pOutputPins.push_back(pOut1);
m_pOutputPins.push_back(pOut2);
}
return S_OK;
}
HRESULT SyncFilter::CheckInputType( const CMediaType * pmt , const IPin* pPin)
{
CheckPointer(pmt, E_POINTER);
if (m_pInputPins.size() >= 1 && m_pInputPins[0] == pPin) // camera image
{
if (*pmt->FormatType() != FORMAT_VideoInfo) {
return E_INVALIDARG;
}
if (IsEqualGUID(*pmt->Type(), MEDIATYPE_Video) &&
(IsEqualGUID(MEDIASUBTYPE_RGB24, *pmt->Subtype()) || IsEqualGUID(MEDIASUBTYPE_RGB32, *pmt->Subtype())))
return NOERROR;
}
else if (m_pInputPins.size() >= 1 && m_pInputPins[1] == pPin) // dirty Pin
{
if (IsEqualGUID(*pmt->Type(), GUID_IMPRO_FeedbackTYPE) &&
(IsEqualGUID(GUID_ARLayoutConfigData, *pmt->Subtype()) ))
return NOERROR;
}
else if (m_pInputPins.size() >= 1 && m_pInputPins[2] == pPin) // layout image
{
CheckPointer(pmt, E_POINTER);
if (!IsEqualGUID(*pmt->FormatType(), FORMAT_VideoInfo) &&
!IsEqualGUID(*pmt->FormatType(), GUID_FORMATTYPE_D3DXTEXTURE9DESC))
{
return E_INVALIDARG;
}
// Can we transform this type
if(IsAcceptedType(pmt)){
return NOERROR;
}
}
return E_FAIL;
}
bool SyncFilter::IsAcceptedType(const CMediaType *pmt){
GUID guidSubType = *pmt->Subtype();
if (IsEqualGUID(*pmt->Type(), MEDIATYPE_Video))
{
if(IsEqualGUID(guidSubType, MEDIASUBTYPE_RGB24))
{
return true;
}
else if(IsEqualGUID(guidSubType, MEDIASUBTYPE_RGB32))
{
return true;
}
}
else if (IsEqualGUID(*pmt->Type(), GUID_D3DMEDIATYPE) &&
IsEqualGUID(guidSubType, GUID_D3DXTEXTURE9_POINTER))
{
return true;
}
else if (IsEqualGUID(*pmt->Type(), GUID_D3DMEDIATYPE) &&
IsEqualGUID(guidSubType, GUID_D3DSHARE_RTTEXTURE_POINTER))
{
return true;
}
return false;
}
HRESULT SyncFilter::CheckOutputType( const CMediaType * pmt , const IPin* pPin)
{
if (m_pOutputPins.size() > 0 && m_pOutputPins[0] == pPin) // camera Image
{
CheckPointer(pmt, E_POINTER);
if (*pmt->FormatType() != FORMAT_VideoInfo) {
return E_INVALIDARG;
}
// Can we transform this type
if(IsAcceptedType(pmt)){
return NOERROR;
}
}
if (m_pOutputPins.size() > 1 && m_pOutputPins[1] == pPin)
{
CheckPointer(pmt, E_POINTER);
if (*pmt->FormatType() != FORMAT_VideoInfo && *pmt->Subtype() != GUID_ARLayoutConfigData) {
return E_INVALIDARG;
}
if (IsEqualGUID(*pmt->Type(), GUID_IMPRO_FeedbackTYPE) &&
IsEqualGUID(*pmt->Subtype(), GUID_ARLayoutConfigData))
{
layoutType = 1 ;
return NOERROR;
}
// Can we transform this type
if(IsAcceptedType(pmt)){
layoutType = 0 ;
return NOERROR;
}
}
if (m_pOutputPins.size() > 2 && m_pOutputPins[2] == pPin) // Render
{
CheckPointer(pmt, E_POINTER);
if (*pmt->FormatType() != FORMAT_VideoInfo &&
*pmt->FormatType() != GUID_FORMATTYPE_D3DXTEXTURE9DESC)
{
return E_INVALIDARG;
}
// Can we transform this type
if(IsAcceptedType(pmt)){
return NOERROR;
}
}
return E_FAIL;
}
HRESULT SyncFilter::CompleteConnect(PIN_DIRECTION direction, const IPin* pMyPin, const IPin* pOtherPin)
{
HRESULT hr = S_OK;
if (direction == PINDIR_INPUT && m_pInputPins.size() > 0 && m_pInputPins[0] == pMyPin)
{
CMediaType inputMT = ((CMuxTransformInputPin*)pMyPin)->CurrentMediaType();
VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *) inputMT.pbFormat;
BITMAPINFOHEADER bitHeader = pvi->bmiHeader;
GUID guidSubType = inputMT.subtype;
return S_OK;
}
else if (direction == PINDIR_INPUT && m_pInputPins.size() > 1 && m_pInputPins[2] == pMyPin) // Layout
{
CMediaType inputMT = ((CMuxTransformInputPin*)pMyPin)->CurrentMediaType();
if (IsEqualGUID(*inputMT.Type(), GUID_D3DMEDIATYPE) &&
IsEqualGUID(*inputMT.Subtype(), GUID_D3DXTEXTURE9_POINTER))
{
D3DSURFACE_DESC* desc = (D3DSURFACE_DESC*)inputMT.pbFormat;
initD3D(desc->Width, desc->Height);
return S_OK;
}
if (IsEqualGUID(*inputMT.Type(), GUID_D3DMEDIATYPE) &&
IsEqualGUID(*inputMT.Subtype(), GUID_D3DSHARE_RTTEXTURE_POINTER))
{
D3DSURFACE_DESC* desc = (D3DSURFACE_DESC*)inputMT.pbFormat;
IDirect3DDevice9* pDevice = NULL;
m_pInputPins[2]->QueryD3DDevice(pDevice);
if (pDevice == NULL)
return S_FALSE;
initD3D(desc->Width, desc->Height, pDevice);
pDevice->Release();
pDevice = NULL;
return S_OK;
}
else
{
VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *) inputMT.pbFormat;
BITMAPINFOHEADER bitHeader = pvi->bmiHeader;
initD3D(bitHeader.biWidth, bitHeader.biHeight);
return S_OK;
}
}
return S_OK;
}
HRESULT SyncFilter::BreakConnect(PIN_DIRECTION dir, const IPin* pPin)
{
return __super::BreakConnect(dir, pPin);
}
HRESULT SyncFilter::CamTransform( IMediaSample *pIn, IMediaSample *pOut)
{
HRESULT hr = S_OK;
long cbData;
BYTE* outByte = NULL;
// Access the sample's data buffer
BYTE* CamData = NULL;
pIn->GetPointer(&CamData);
pOut->GetPointer(&outByte);
cbData = pOut->GetSize();
memcpy (outByte,CamData,cbData);
return S_OK;
}
HRESULT SyncFilter::LayoutTransform( IMediaSample *pIn, IMediaSample *pOut)
{
HRESULT hr = S_OK;
if (m_pD3DDisplay != NULL)
{
if (m_pInputPins.size() <= 0 || m_pOutputPins.size() <= 0)
{
return S_FALSE;
}
CCritSec* pD3DCS = NULL;
QueryD3DDeviceCS(NULL, pD3DCS);
if (pD3DCS == NULL)
return S_FALSE;
CAutoLock lck(pD3DCS);
CMuxTransformOutputPin* pOutPin = GetConnectedOutputPin(2);
if (pOutPin == NULL)
{
return S_FALSE;
}
CMediaType mt;
mt = pOutPin->CurrentMediaType();
DoTransform(pIn, pOut, &m_pInputPins[2]->CurrentMediaType(), &pOutPin->CurrentMediaType());
}
return S_OK;
}
HRESULT SyncFilter::DecideBufferSize(IMemAllocator *pAlloc, const IPin* pOutPin, ALLOCATOR_PROPERTIES *pProp)
{
HRESULT hr = NOERROR;
if (m_pInputPins.size() <= 2)
{
return S_FALSE;
}
CMediaType outPin0MT = m_pOutputPins[0]->CurrentMediaType();
CMediaType outPin1MT = m_pOutputPins[1]->CurrentMediaType();
CMediaType outPin2MT = m_pOutputPins[2]->CurrentMediaType();
if (outPin0MT.Type() == NULL || outPin1MT.Type() == NULL|| outPin2MT.Type() == NULL)
{
return S_FALSE;
}
if (m_pOutputPins.size() > 0 && m_pOutputPins[0] == pOutPin )
{
VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *) outPin0MT.pbFormat;
BITMAPINFOHEADER bitHeader = pvi->bmiHeader;
pProp->cBuffers = 1;
pProp->cbBuffer = outPin0MT.GetSampleSize();//bitHeader.biWidth*bitHeader.biHeight;
ALLOCATOR_PROPERTIES Actual;
hr = pAlloc->SetProperties(pProp,&Actual);
if (FAILED(hr)) {
return hr;
}
ASSERT( Actual.cBuffers == 1 );
if (pProp->cBuffers > Actual.cBuffers ||
pProp->cbBuffer > Actual.cbBuffer) {
return E_FAIL;
}
}
if (m_pOutputPins.size() > 1 && m_pOutputPins[1] == pOutPin )
{
pProp->cBuffers = 1;
pProp->cbBuffer = outPin1MT.GetSampleSize();
ALLOCATOR_PROPERTIES Actual;
hr = pAlloc->SetProperties(pProp,&Actual);
if (FAILED(hr)) {
return hr;
}
ASSERT( Actual.cBuffers == 1 );
if (pProp->cBuffers > Actual.cBuffers ||
pProp->cbBuffer > Actual.cbBuffer) {
return E_FAIL;
}
}
if (m_pOutputPins.size() > 0 && m_pOutputPins[2] == pOutPin )
{
VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *) outPin2MT.pbFormat;
BITMAPINFOHEADER bitHeader = pvi->bmiHeader;
pProp->cBuffers = 1;
pProp->cbBuffer = outPin2MT.GetSampleSize();//bitHeader.biWidth*bitHeader.biHeight;
ALLOCATOR_PROPERTIES Actual;
hr = pAlloc->SetProperties(pProp,&Actual);
if (FAILED(hr)) {
return hr;
}
ASSERT( Actual.cBuffers == 1 );
if (pProp->cBuffers > Actual.cBuffers ||
pProp->cbBuffer > Actual.cbBuffer) {
return E_FAIL;
}
}
return NOERROR;
}
HRESULT SyncFilter::GetMediaType(int iPosition, const IPin* pOutPin, __inout CMediaType *pMediaType)
{
if (m_pInputPins.size() <= 0)
{
return S_FALSE;
}
if (m_pOutputPins.size() > 0 && m_pOutputPins[0] == pOutPin) // camera pin output camera Image
{
if (iPosition < 0) {
return E_INVALIDARG;
}
if (iPosition >= 1) {
return VFW_S_NO_MORE_ITEMS;
}
CMediaType inputMT = m_pInputPins[0]->CurrentMediaType();
long size = inputMT.GetSampleSize();
*pMediaType = inputMT;
return S_OK;
}
// BG pin
else if (m_pOutputPins.size() > 1 && m_pInputPins[2] != NULL && m_pOutputPins[1] == pOutPin)
{
if (m_pOutTexture == NULL)
return S_FALSE;
if (iPosition == 0)
{
CMediaType mt;
mt.SetType(&GUID_IMPRO_FeedbackTYPE);
mt.SetSubtype(&GUID_ARLayoutConfigData);
mt.SetSampleSize(sizeof(ARLayoutConfigData));
*pMediaType = mt;
return S_OK;
}
else if (iPosition == 1)
{
CMediaType mt;
D3DSURFACE_DESC desc;
m_pOutTexture->GetLevelDesc(0, &desc);
mt.SetType(&MEDIATYPE_Video);
mt.SetFormatType(&FORMAT_VideoInfo);
mt.SetTemporalCompression(FALSE);
mt.SetSubtype(&MEDIASUBTYPE_RGB32);
mt.SetSampleSize(desc.Width*desc.Height*4);
VIDEOINFOHEADER pvi;
memset((void*)&pvi, 0, sizeof(VIDEOINFOHEADER));
pvi.bmiHeader.biSizeImage = 0; //for uncompressed image
pvi.bmiHeader.biWidth = desc.Width;
pvi.bmiHeader.biHeight = desc.Height;
pvi.bmiHeader.biBitCount = 32;
SetRectEmpty(&(pvi.rcSource));
SetRectEmpty(&(pvi.rcTarget));
mt.SetFormat((BYTE*)&pvi, sizeof(VIDEOINFOHEADER));
*pMediaType = mt;
return S_OK;
}
else
{
return VFW_S_NO_MORE_ITEMS;
}
}
// Render Pin
else if (m_pOutputPins.size() > 2 && m_pInputPins[2] != NULL && m_pOutputPins[2] == pOutPin)
{
if (iPosition == 0) // share Texture
{
CMediaType mt;
mt.SetType(&GUID_D3DMEDIATYPE);
mt.SetSubtype(&GUID_D3DSHARE_RTTEXTURE_POINTER);
mt.SetSampleSize(sizeof(LPDIRECT3DTEXTURE9));
D3DSURFACE_DESC desc;
m_pRenderTarget->GetLevelDesc(0, &desc);
mt.SetFormat((BYTE*)&desc, sizeof(D3DSURFACE_DESC));
mt.SetFormatType(&GUID_FORMATTYPE_D3DXTEXTURE9DESC);
*pMediaType = mt;
return S_OK;
}
else if (iPosition == 1) //d3d texture
{
CMediaType mt;
mt.SetType(&GUID_D3DMEDIATYPE);
mt.SetSubtype(&GUID_D3DXTEXTURE9_POINTER);
mt.SetSampleSize(sizeof(LPDIRECT3DTEXTURE9));
D3DSURFACE_DESC desc;
m_pOutTexture->GetLevelDesc(0, &desc);
mt.SetFormat((BYTE*)&desc, sizeof(D3DSURFACE_DESC));
mt.SetFormatType(&GUID_FORMATTYPE_D3DXTEXTURE9DESC);
*pMediaType = mt;
return S_OK;
}
}
return VFW_S_NO_MORE_ITEMS;
}
bool SyncFilter::getDirty(){
CAutoLock lck(&locDirty);
return Dirty;
}
HRESULT SyncFilter::setDirty(bool isDirty){
CAutoLock lck(&locDirty);
Dirty = isDirty;
return S_OK;
}
bool SyncFilter::getBlock(){
CAutoLock lck(&locBlock);
return Block;
}
HRESULT SyncFilter::setBlock(bool isBlock){
CAutoLock lck(&locBlock);
Block = isBlock;
return S_OK;
}
//for implement D3DTransformFilterBase Method
MS3DDisplay* SyncFilter::Create3DDisplay(IDirect3D9* pD3D, int rtWidth, int rtHeight)
{
MS3DDisplay* newMS3DDisplay = new MS3DDisplay(pD3D,rtWidth,rtHeight);
return newMS3DDisplay;
}
MS3DDisplay* SyncFilter::Create3DDisplay(IDirect3DDevice9* pDevice, int rtWidth, int rtHeight)
{
MS3DDisplay* newMS3DDisplay = new MS3DDisplay(pDevice,rtWidth,rtHeight);
return newMS3DDisplay;
}
HRESULT SyncFilter::QueryD3DDevice(IDXBasePin* pPin, IDirect3DDevice9*& outDevice)
{
if (m_pD3DDisplay == NULL)
return S_FALSE;
outDevice = m_pD3DDisplay->GetD3DDevice();
if (outDevice != NULL)
{
outDevice->AddRef();
}
return S_OK;
}
HRESULT SyncFilter::QueryD3DDeviceCS(IDXBasePin* pPin, CCritSec*& cs)
{
if (m_pD3DDisplay == NULL || m_pInputPins.size() <= 0 || m_pInputPins[0] == NULL)
return S_FALSE;
if (m_pD3DDisplay->IsDeviceFromOther())
{
IDXBasePin* pDXInPin = NULL;
m_pInputPins[2]->QueryInterface(IID_IDXBasePin, (void**)&pDXInPin);
if (pDXInPin == NULL)
return S_FALSE;
pDXInPin->QueryD3DDeviceCS(cs);
pDXInPin->Release();
pDXInPin = NULL;
return S_OK;
}
else
{
cs = &m_csD3DDisplay;
return S_OK;
}
return S_OK;
} | [
"claire3kao@fa729b96-8d43-11de-b54f-137c5e29c83a",
"ndhumuscle@fa729b96-8d43-11de-b54f-137c5e29c83a"
] | [
[
[
1,
58
],
[
60,
60
],
[
62,
63
],
[
66,
104
],
[
120,
120
],
[
134,
159
],
[
163,
163
],
[
166,
192
],
[
194,
196
],
[
200,
215
],
[
217,
223
],
[
234,
245
],
[
256,
816
]
],
[
[
59,
59
],
[
61,
61
],
[
64,
65
],
[
105,
119
],
[
121,
133
],
[
160,
162
],
[
164,
165
],
[
193,
193
],
[
197,
199
],
[
216,
216
],
[
224,
233
],
[
246,
255
]
]
] |
89e608396a0ae86b867b36024d96f20acdf2859a | c1bcff0f1321de8a6425723cdfa0b5aa65b5c81f | /TransX/tags/3.12/transx.cpp | f3a0c7adfaeeed39d41d3669770fa4e2910f664a | [
"MIT"
] | permissive | net-lisias-orbiter/transx | 560266e7a4ef73ed29d9004e406fd8db28da9a43 | b9297027718a7499934a9614430aebb47422ce7f | refs/heads/master | 2023-06-27T14:16:10.697238 | 2010-09-05T01:18:54 | 2010-09-05T01:18:54 | 390,398,358 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,146 | cpp | /* Copyright (c) 2007 Duncan Sharpe, Steve Arch
**
** 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.*/
#define STRICT
#define ORBITER_MODULE
#include <windows.h>
#include <stdio.h>
#include <math.h>
#include "orbitersdk.h"
#include "mfd.h"
#include "graph.h"
#include "intercept.h"
#include "mfdvarhandler.h"
#include "basefunction.h"
#include "viewstate.h"
#include "shiplist.h"
#include "transx.h"
int TransxMFD::MfdCount=0;
double debug;
TransxMFD::TransxMFD (DWORD w, DWORD h, VESSEL *vessel, UINT mfd)
: MFD (w, h, vessel)
// Initialise TransXMFD
{
//Check to see if new Transxstate is required
valid=false;
viewstate=NULL;
if (mfd>20) mfd=1;//Set to safe value in this instance
class shipptrs *shptr=shipptrs::getshipptrs();//Knows ship must be current focus
viewstate=shptr->getviewstate(mfd,this);
viewstate->setmfdactive(true);
++MfdCount;
}
TransxMFD::~TransxMFD()
{
viewstate->setmfdactive(false);
if (!viewstate->getrenderviewport())//If we're closing, take the state with you, otherwise leave it.
{
shipptrs::destroyshipptrs();//destroy all pointer structures
}
--MfdCount;
}
// Called by Orbiter when a screen update is needed
void TransxMFD::Update (HDC hDC)
{
Title (hDC, "TransX MFD");
HPEN pen=SelectDefaultPen(hDC,TransXFunction::Green);//Selects an Orbiter default pen, and retrieves called pen
valid=viewstate->doupdate(hDC,W,H,this);
shipptrs::refreshsave();//allow save again, as new values are now available
SelectObject(hDC,pen);//Replaces initial pen back into hDC. Now the MFD causes no pen creation
if (!valid) return;
int linespacing=H/24;
if (debug!=0)
{
char buffer[20];
int length=sprintf(buffer,"Debug:%g",debug);
TextOut(hDC,0,linespacing*22,buffer,length);
}
MFDvariable *varpointer=viewstate->GetCurrVariable();
if (varpointer==NULL) return;
varpointer->show(hDC,W,linespacing);
}
int TransxMFD::getwidth()
{
return W;
}
int TransxMFD::getheight()
{
return H;
}
int TransxMFD::MsgProc (UINT msg, UINT mfd, WPARAM wparam, LPARAM lparam)
// Standard message parser for messages passed from Orbiter
{
switch (msg) {
case OAPI_MSG_MFD_OPENED:
return (int) new TransxMFD (LOWORD(wparam), HIWORD(wparam), (VESSEL*)lparam, mfd);
}
return 0;
}
char *TransxMFD::ButtonLabel (int bt)
// Routine to pass button label back to Orbiter. Called by Orbiter
{
char *label[11] = {"HLP","FWD","BCK", "VW","VAR","-VR", "ADJ", "-AJ","++", "--","EXE"};
return (bt < 11 ? label[bt] : 0);
}
int TransxMFD::ButtonMenu (const MFDBUTTONMENU **menu) const
// Routine to pass menu description for buttons back to Orbiter. Called by Orbiter
{
static const MFDBUTTONMENU mnu[11] = {
{"Toggle Help","On/Off",'H'},
{"Step Forward","/ Add Step",'F'},
{"Step Back",0,'R'},
{"Select View",0,'W'},
{"Next Variable", 0, '.'},
{"Prev. Variable", 0, ','},
{"Set adjustment", "method (+)", '{'},
{"Set adjustment", "method (-)", '}'},
{"Increment", "variable", '='},
{"Decrement", "variable", '-'},
{"Execute","Command",'X'}
};
if (menu) *menu = mnu;
return 11;
}
bool TransxMFD::ConsumeKeyImmediate(char *kstate)
// Routine which processes the keyboard state. Allows continuous change of variable.
{
if (!valid) return false;
MFDvariable *varpointer=viewstate->GetCurrVariable();
if (varpointer==NULL) return false;
if (*(kstate+OAPI_KEY_MINUS)==-128)
{
varpointer->dec_variable();
return true;
}
if (*(kstate+OAPI_KEY_EQUALS)==-128)
{
varpointer->inc_variable();
return true;
}
return false;
}
bool TransxMFD::ConsumeButton(int bt, int event)
// Deal with mouse pressing of keys
{
static const DWORD btkey[11]={OAPI_KEY_H, OAPI_KEY_F, OAPI_KEY_R, OAPI_KEY_W, OAPI_KEY_PERIOD,
OAPI_KEY_COMMA, OAPI_KEY_LBRACKET, OAPI_KEY_RBRACKET, OAPI_KEY_EQUALS, OAPI_KEY_MINUS, OAPI_KEY_X};
if (!valid) return false;
MFDvariable *varpointer=viewstate->GetCurrVariable();
if ((event & PANEL_MOUSE_LBDOWN) && (bt<8 || bt==10)) return ConsumeKeyBuffered (btkey[bt]);
if (bt>9) return false; //No buttons above 10
if (varpointer==NULL) return false;
if ((event & PANEL_MOUSE_LBDOWN) && varpointer->getadjtype()==0)
{
// Button 8 or 9 is pressed and the mode is discrete
return ConsumeKeyBuffered (btkey[bt]);
}
// At this point, only the possibility of immediate consumption...
if (!(event & PANEL_MOUSE_LBPRESSED) || !varpointer->IsContinuous()) return false; //Mouse button is down on 9 or 10
if (bt==9)
varpointer->dec_variable();
if (bt==8)
varpointer->inc_variable();
return true;
}
bool TransxMFD::ConsumeKeyBuffered (DWORD key)
{
if (!valid) return false;
MFDvariable *currvar=viewstate->GetCurrVariable();
bool access=(currvar!=NULL);
switch (key) {
case OAPI_KEY_H:
viewstate->fliphelpsystem();
return true;
case OAPI_KEY_F:
viewstate->movetonextfunction();
return true;
case OAPI_KEY_R:
viewstate->movetopreviousfunction();
return true;
case OAPI_KEY_W:
viewstate->inc_viewmode();
return true;
case OAPI_KEY_X:
if (access) currvar->execute();
return true;
case OAPI_KEY_PERIOD: //Switch variable
{
int viewmode=viewstate->getvariableviewmode();
viewstate->GetVarhandler()->setnextcurrent(viewmode);
}
return true;
case OAPI_KEY_COMMA:
{
int viewmode=viewstate->getvariableviewmode();
viewstate->GetVarhandler()->setprevcurrent(viewmode);
}
return true;
case OAPI_KEY_LBRACKET:
if (access) currvar->ch_adjmode();
return true;
case OAPI_KEY_RBRACKET:
if (access) currvar->chm_adjmode();
return true;
case OAPI_KEY_MINUS:
if (access) currvar->dec_variable();
return true;
case OAPI_KEY_EQUALS:
if (access) currvar->inc_variable();
return true;
}
return false; //Key not one of cases above
}
void TransxMFD::WriteStatus(FILEHANDLE scn) const
{
if (!valid)
return;
shipptrs::saveallships(scn);
}
void TransxMFD::ReadStatus(FILEHANDLE scn)
{
shipptrs::restoreallships(scn);
}
| [
"steve@5a6c10e1-6920-0410-8c7b-9669c677a970"
] | [
[
[
1,
242
]
]
] |
efd0b69e0288ccea831b46b16781efdcf3d0731e | 23c0843109bcc469d7eaf369809a35e643491500 | /Graphics/GraphicsFader.h | afc281fa1ca408e784ea45a8a17ec5db30a2601c | [] | no_license | takano32/d4r | eb2ab48b324c02634a25fc943e7a805fea8b93a9 | 0629af9d14035b2b768d21982789fc53747a1cdb | refs/heads/master | 2021-01-19T00:46:58.672055 | 2009-01-07T01:28:38 | 2009-01-07T01:28:38 | 102,349 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 295 | h | #pragma once
#include "GraphicsSystem.h"
namespace base{
class GraphicsFader{
GraphicsSystem *_pSystem;
DWORD _color;
public:
GraphicsFader( GraphicsSystem *pSystem );
~GraphicsFader();
BOOL SetFade( int red, int green, int blue, int alpha );
DWORD GetFade();
};
} | [
"[email protected]"
] | [
[
[
1,
15
]
]
] |
da1002e5fd442f746ff11889ae4fd6bda8798a58 | 2b80036db6f86012afcc7bc55431355fc3234058 | /src/contrib/cddadecoder/cddadecoder_plugin.cpp | a1aa5999883a5ccaff713c36bc657d5e84a08b71 | [
"BSD-3-Clause"
] | permissive | leezhongshan/musikcube | d1e09cf263854bb16acbde707cb6c18b09a0189f | e7ca6a5515a5f5e8e499bbdd158e5cb406fda948 | refs/heads/master | 2021-01-15T11:45:29.512171 | 2011-02-25T14:09:21 | 2011-02-25T14:09:21 | null | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 2,555 | cpp | //////////////////////////////////////////////////////////////////////////////
//
// License Agreement:
//
// The following are Copyright © 2008, Björn Olievier
//
// 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 author nor the names of other 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 "stdafx.h"
#include "CDDASourceSupplier.h"
#include <core/IPlugin.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
return true;
}
class CDDADecoderPlugin : public musik::core::IPlugin
{
void Destroy() { delete this; };
const utfchar* Name() { return TEXT("CDDA decoder"); };
const utfchar* Version() { return TEXT("1"); };
const utfchar* Author() { return TEXT("Björn Olievier"); };
};
extern "C" __declspec(dllexport) musik::core::IPlugin* GetPlugin()
{
return new CDDADecoderPlugin();
}
extern "C" __declspec(dllexport) IAudioSourceSupplier* CreateAudioSourceSupplier()
{
return new CDDASourceSupplier();
}
| [
"onnerby@6a861d04-ae47-0410-a6da-2d49beace72e"
] | [
[
[
1,
64
]
]
] |
3e322895f711bde1dcc6e0d79c4ed9de456fada4 | a30b091525dc3f07cd7e12c80b8d168a0ee4f808 | /EngineAll/Windows Controller/WinMain.cpp | 90cc69738995f3cc97876faaff04172900ddf5cd | [] | no_license | ghsoftco/basecode14 | f50dc049b8f2f8d284fece4ee72f9d2f3f59a700 | 57de2a24c01cec6dc3312cbfe200f2b15d923419 | refs/heads/master | 2021-01-10T11:18:29.585561 | 2011-01-23T02:25:21 | 2011-01-23T02:25:21 | 47,255,927 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 619 | cpp | /*
WinMain.cpp
Written by Matthew Fisher
The WinMain function itself. Just creates the App class and runs it. See App.h/App.cpp
*/
#include "..\\..\\Main.h"
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpszCmdLine, int nCmdShow)
{
App *A = new App; //create a new App
A->Init(hInstance, nCmdShow); //initalize App
A->MessageLoop(hInstance, nCmdShow); //begin App's "lifetime" (looping for messages. all frames occur here.)
A->FreeMemory(); //kill App
return 0; //exit Main
} | [
"zhaodongmpii@7e7f00ea-7cf8-66b5-cf80-f378872134d2"
] | [
[
[
1,
17
]
]
] |
906945136ad1ae7bfa13cfd074384e7cc9eb3e80 | c1a2953285f2a6ac7d903059b7ea6480a7e2228e | /deitel/ch15/Fig15_19/Fig15_19.cpp | 4ad74d49e5933a83c32714e7818abc55d5fcd55e | [] | no_license | tecmilenio/computacion2 | 728ac47299c1a4066b6140cebc9668bf1121053a | a1387e0f7f11c767574fcba608d94e5d61b7f36c | refs/heads/master | 2016-09-06T19:17:29.842053 | 2008-09-28T04:27:56 | 2008-09-28T04:27:56 | 50,540 | 4 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 1,667 | cpp | // Fig. 15.19: Fig15_19.cpp
// Stream-manipulator uppercase.
#include <iostream>
using std::cout;
using std::endl;
using std::hex;
using std::showbase;
using std::uppercase;
int main()
{
cout << "Printing uppercase letters in scientific" << endl
<< "notation exponents and hexadecimal values:" << endl;
// use std:uppercase to display uppercase letters; use std::hex and
// std::showbase to display hexadecimal value and its base
cout << uppercase << 4.345e10 << endl
<< hex << showbase << 123456789 << endl;
return 0;
} // end main
/**************************************************************************
* (C) Copyright 1992-2008 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. These efforts include the *
* development, research, and testing of the theories and programs *
* to determine their effectiveness. The authors and publisher make *
* no warranty of any kind, expressed or implied, with regard to these *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or *
* consequential damages in connection with, or arising out of, the *
* furnishing, performance, or use of these programs. *
**************************************************************************/
| [
"[email protected]"
] | [
[
[
1,
35
]
]
] |
eb011b4c511465cfe63b9cf720533af9496907f5 | df5277b77ad258cc5d3da348b5986294b055a2be | /Spaceships/wndproc.cpp | ce70b5b57d82bbcaf86d11a65f3fac03e29bd3d2 | [] | no_license | beentaken/cs260-last2 | 147eaeb1ab15d03c57ad7fdc5db2d4e0824c0c22 | 61b2f84d565cc94a0283cc14c40fb52189ec1ba5 | refs/heads/master | 2021-03-20T16:27:10.552333 | 2010-04-26T00:47:13 | 2010-04-26T00:47:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 168 | cpp | #include "wndproc.h"
LRESULT CALLBACK MainWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam){
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
| [
"ProstheticMind43@af704e40-745a-32bd-e5ce-d8b418a3b9ef"
] | [
[
[
1,
8
]
]
] |
a3e2d6079e871d47744fe3772655b28bdd0ab7b2 | ab41c2c63e554350ca5b93e41d7321ca127d8d3a | /glm/gtx/number_precision.inl | 37b94195e2a3610ae1f52d3df033e54f7a98bfd2 | [] | no_license | burner/e3rt | 2dc3bac2b7face3b1606ee1430e7ecfd4523bf2e | 775470cc9b912a8c1199dd1069d7e7d4fc997a52 | refs/heads/master | 2021-01-11T08:08:00.665300 | 2010-04-26T11:42:42 | 2010-04-26T11:42:42 | 337,021 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 550 | inl | ///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-05-10
// Updated : 2007-05-10
// Licence : This source is under MIT License
// File : glm/gtx/number_precision.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
}
| [
"[email protected]"
] | [
[
[
1,
13
]
]
] |
bf3d2b4da080f54f6f710874e7028229f11705d9 | ed8c6c3579a4e65e105bee399031459f38dba5eb | /trunk/VirtualSpaces/global.cpp | 1922bba6e2d242a780617b374c7f4e87899b69e9 | [] | no_license | BackupTheBerlios/virtualspaces-svn | 719fd56982bf1c91e7e13f038e930a84de9ff9fd | e15496df0e36173079ad5272da74b8205119af2e | refs/heads/master | 2020-05-19T23:47:34.765119 | 2006-09-20T06:19:15 | 2006-09-20T06:19:15 | 40,775,589 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,232 | cpp |
#include "global.h"
ULONGLONG GetDllVersion(TCHAR* lpszDllName)
{
HINSTANCE hinstDll;
ULONGLONG dwVersion = 0;
/* For security purposes, LoadLibrary should be provided with a
fully-qualified path to the DLL. The lpszDllName variable should be
tested to ensure that it is a fully qualified path before it is used. */
hinstDll = LoadLibrary(lpszDllName);
if(hinstDll)
{
DLLGETVERSIONPROC pDllGetVersion;
pDllGetVersion = (DLLGETVERSIONPROC)GetProcAddress(hinstDll, "DllGetVersion");
/* Because some DLLs might not implement this function, you
must test for it explicitly. Depending on the particular
DLL, the lack of a DllGetVersion function can be a useful
indicator of the version. */
if(pDllGetVersion)
{
DLLVERSIONINFO dvi;
HRESULT hr;
ZeroMemory(&dvi, sizeof(dvi));
dvi.cbSize = sizeof(dvi);
hr = (*pDllGetVersion)(&dvi);
if(SUCCEEDED(hr))
dwVersion = MAKEDLLVERULL(dvi.dwMajorVersion, dvi.dwMinorVersion, dvi.dwBuildNumber, 0);
}
FreeLibrary(hinstDll);
}
return dwVersion;
}
| [
"exgen@025071a7-801d-0410-b229-f1a4ac5ea7bb"
] | [
[
[
1,
41
]
]
] |
38faa7e3a016fe77e923b42c2b2cb7dd9f790dbd | c9390a163ae5f0bc6fdc1560be59939dcbe3eb07 | /multifxVSTeditor.h | 7d0718e2821f96ab0364015f949679b2adcacb13 | [] | no_license | trimpage/multifxvst | 2ceae9da1768428288158319fcf03d603ba47672 | 1cb40f8e0cc873f389f2818b2f40665d2ba2b18b | refs/heads/master | 2020-04-06T13:23:41.059632 | 2010-11-04T14:32:54 | 2010-11-04T14:32:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,753 | h | //------------------------------------------------------//
//- CopyLeft : CTAF
//-
//- gestion du VST (affichage dans l'host)
//-
//------------------------------------------------------//
#ifndef __multifxVSTeditor__
#define __multifxVSTeditor__
#ifndef __vstgui__
#include "vstgui.h"
#endif
//class CChainDlg;
//class CStockEffetLst;
//class CCVSTHost;
class CMainDlg;
class CAppPointer;
//class Test;
//-----------------------------------------------------------------------------
class multifxVSTEditor : public AEffGUIEditor, public CControlListener
{
public:
multifxVSTEditor (AudioEffect *effect);
virtual ~multifxVSTEditor ();
/*void suspend ();
void resume ();*/
bool keysRequired ();
void SetAPP(CAppPointer * m_cheff = NULL);
void setParameter (long index, float value);
protected:
virtual long open (void *ptr);
virtual void idle ();
virtual void close ();
virtual void update();
// VST 2.1
virtual long onKeyDown (VstKeyCode &keyCode);
virtual long onKeyUp (VstKeyCode &keyCode);
virtual long getRect(ERect **rect);
private:
void valueChanged (CDrawContext* context, CControl* control);
bool visible;
CHorizontalSlider *cHorizontalSlider;
CHorizontalSlider *cHorizontalSlider2;
CSpecialDigit *cSpecialDigit;
COnOffButton *cKickButton;
// others
CAppPointer * APP;
/*CChainDlg * dlg;
CMainDlg * maindlg;
CStockEffetLst * chaine_eff;
CCVSTHost * host;*/
ERect WinRect;
long oldTicks;
int UpdateType;
public:
friend CMainDlg; //pour l'access au pointeur frame
};
#endif
| [
"CTAF@3e78e570-a0aa-6544-9a6b-7e87a0c009bc"
] | [
[
[
1,
75
]
]
] |
2247873a8cd7c8ebca09b5ec92847de109bdd6dc | 0f8559dad8e89d112362f9770a4551149d4e738f | /Wall_Destruction/Havok/Source/ContentTools/Common/SceneExport/Memory/hctSceneExportMemory.h | 5b0461707cdab9d98a37361addb61a05f6296783 | [] | no_license | TheProjecter/olafurabertaymsc | 9360ad4c988d921e55b8cef9b8dcf1959e92d814 | 456d4d87699342c5459534a7992f04669e75d2e1 | refs/heads/master | 2021-01-10T15:15:49.289873 | 2010-09-20T12:58:48 | 2010-09-20T12:58:48 | 45,933,002 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,252 | h | /*
*
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2009 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
#ifndef HK_SCENE_EXPORT_MEMORY_H
#define HK_SCENE_EXPORT_MEMORY_H
#include <Common/Base/Memory/System/Util/hkMemoryInitUtil.h>
class hkSceneExportMemThreadCallback
{
public:
/// Null on thread delete
virtual void initThread( hkMemoryRouter* m_memoryRouter ) = 0;
};
class hkDefaultSceneExportMemThreadCallback : public hkSceneExportMemThreadCallback
{
public:
virtual void initThread( hkMemoryRouter* m_memoryRouter );
};
/// Functions in this namespace are used to initialize thread memory as well as to retrieve information
/// about singletons.
namespace hkSceneExportMemory
{
/// Initialized Havok's base system using thread-safe memory
void HK_CALL baseSystemInit(bool debugMem = false);
/// Quits Havok's bases system
void HK_CALL baseSystemQuit();
/// Retrieves information about the singletons used by this module (DLL or EXE)
void HK_CALL getBaseSystemSyncInfo( hkMemoryInitUtil::SyncInfo& baseSystemInfo );
static hkDefaultSceneExportMemThreadCallback g_defaultThreadCallback;
}
#endif //HK_SCENE_EXPORT_MEMORY_H
/*
* Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20091222)
*
* Confidential Information of Havok. (C) Copyright 1999-2009
* Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
* Logo, and the Havok buzzsaw logo are trademarks of Havok. Title, ownership
* rights, and intellectual property rights in the Havok software remain in
* Havok and/or its suppliers.
*
* Use of this software for evaluation purposes is subject to and indicates
* acceptance of the End User licence Agreement for this product. A copy of
* the license is included with this software and is also available at www.havok.com/tryhavok.
*
*/
| [
"[email protected]"
] | [
[
[
1,
58
]
]
] |
f014a27863c88f8763f31c370d80fb91dca772e7 | 2982a765bb21c5396587c86ecef8ca5eb100811f | /util/wm5/LibCore/DataTypes/Wm5Table.h | 12c063c909994f55b737900522992a61a6871882 | [] | no_license | evanw/cs224final | 1a68c6be4cf66a82c991c145bcf140d96af847aa | af2af32732535f2f58bf49ecb4615c80f141ea5b | refs/heads/master | 2023-05-30T19:48:26.968407 | 2011-05-10T16:21:37 | 2011-05-10T16:21:37 | 1,653,696 | 27 | 9 | null | null | null | null | UTF-8 | C++ | false | false | 2,161 | h | // Geometric Tools, LLC
// Copyright (c) 1998-2010
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
//
// File Version: 5.0.2 (2011/03/27)
#ifndef WM5TABLE_H
#define WM5TABLE_H
#include "Wm5Tuple.h"
// The class TYPE is either native data or is class data that has the
// following member functions:
// TYPE::TYPE ()
// TYPE::TYPE (const TYPE&);
// TYPE& TYPE::operator= (const TYPE&)
namespace Wm5
{
template <int NUMROWS, int NUMCOLS, typename TYPE>
class Table
{
public:
// Construction and destruction. The default constructor does not
// initialize the array elements for native elements. The array elements
// are initialized for class data whenever TYPE initializes during its
// default construction.
Table ();
Table (const Table& table);
~Table ();
// Coordinate access.
inline operator const TYPE* () const;
inline operator TYPE* ();
inline const TYPE* operator[] (int row) const;
inline TYPE* operator[] (int row);
inline const TYPE& operator() (int row, int col) const;
inline TYPE& operator() (int row, int col);
void SetRow (int row, const Tuple<NUMCOLS,TYPE>& tuple);
Tuple<NUMCOLS,TYPE> GetRow (int row) const;
void SetColumn (int col, const Tuple<NUMROWS,TYPE>& tuple);
Tuple<NUMROWS,TYPE> GetColumn (int col) const;
// Assignment.
Table& operator= (const Table& table);
// Comparison. The inequalities make the comparisons using memcmp, thus
// treating the tuple as an array of unsigned bytes.
bool operator== (const Table& table) const;
bool operator!= (const Table& table) const;
bool operator< (const Table& table) const;
bool operator<= (const Table& table) const;
bool operator> (const Table& table) const;
bool operator>= (const Table& table) const;
protected:
// The array is stored in row-major order.
enum { NUMENTRIES = NUMROWS*NUMCOLS };
TYPE mEntry[NUMENTRIES];
};
#include "Wm5Table.inl"
}
#endif
| [
"[email protected]"
] | [
[
[
1,
69
]
]
] |
4c3e03e18beada42ce4a7fae703e89dda04f3cf0 | bf19f77fdef85e76a7ebdedfa04a207ba7afcada | /NewAlpha/TMNT Tactics Tech Demo/Source/Messages.h | 04ebb698cf5563d712ac5d8a809e6f4166fe5a02 | [] | no_license | marvelman610/tmntactis | 2aa3176d913a72ed985709843634933b80d7cb4a | a4e290960510e5f23ff7dbc1e805e130ee9bb57d | refs/heads/master | 2020-12-24T13:36:54.332385 | 2010-07-12T08:08:12 | 2010-07-12T08:08:12 | 39,046,976 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,127 | h | ////////////////////////////////////////////////////////////////////////////
// File Name : "Messages.h"
//
// Author : Matt DiMatteo (MD)
//
// Purpose : This file contains all messages to be used throught the game.
//
////////////////////////////////////////////////////////////////////////////
#ifndef MESSAGES_H
#define MESSAGES_H
typedef int MSGID;
enum eMsgTypes { MSG_NULL = 0, MSG_CREATE_ITEM, MSG_DESTROY_ITEM, MSG_CREATE_WEAPON, MSG_DESTROY_WEAPON,MSG_MAX };
class CNinja;
class CBattleItem;
class CBase;
class CBaseMessage
{
private:
MSGID m_msgID;
public:
///////////////////////////////////////////////////////////////////
// Function: "CBaseMessage(Constructor)"
///////////////////////////////////////////////////////////////////
CBaseMessage(MSGID msgID) {m_msgID = msgID;}
///////////////////////////////////////////////////////////////////
// Function: "~CBaseMessage(Destructor)"
///////////////////////////////////////////////////////////////////
virtual ~CBaseMessage(void) {}
//////////////////////////////////////
// Function: Accessors
// Purpose : To get the specified type
///////////////////////////////////////
inline MSGID GetMsgID(void) { return m_msgID; }
};
class CCreateItem : public CBaseMessage
{
CNinja* m_pNinja;
public:
///////////////////////////////////////////////////////////////////
// Function: "CCreateItem(Constructor)"
///////////////////////////////////////////////////////////////////
CCreateItem(CNinja* pNinja): CBaseMessage(MSG_CREATE_ITEM){m_pNinja = pNinja;}
///////////////////////////////////////////////////////////////////
// Function: "~CCreateItem(Destructor)"
///////////////////////////////////////////////////////////////////
~CCreateItem(){}
//////////////////////////////////////
// Function: Accessors
// Purpose : To get the specified type
///////////////////////////////////////
inline CNinja* GetNinja() {return m_pNinja;}
};
class CDestroyItem : public CBaseMessage
{
CBattleItem* m_pItem;
public:
///////////////////////////////////////////////////////////////////
// Function: "CDestroyItem(Constructor)"
///////////////////////////////////////////////////////////////////
CDestroyItem(CBattleItem* item):CBaseMessage(MSG_DESTROY_ITEM){m_pItem = item;}
///////////////////////////////////////////////////////////////////
// Function: "~CDestroyItem(Destructor)"
///////////////////////////////////////////////////////////////////
~CDestroyItem(){}
//////////////////////////////////////
// Function: Accessors
// Purpose : To get the specified type
///////////////////////////////////////
inline CBattleItem* GetItem() {return m_pItem;}
};
class CCreateWeapon : public CBaseMessage
{
CNinja* m_pNinja;
public:
///////////////////////////////////////////////////////////////////
// Function: "CCreateWeapon(Constructor)"
///////////////////////////////////////////////////////////////////
CCreateWeapon(CNinja* pNinja): CBaseMessage(MSG_CREATE_WEAPON){m_pNinja = pNinja;}
///////////////////////////////////////////////////////////////////
// Function: "~CCreateWeapon(Destructor)"
///////////////////////////////////////////////////////////////////
~CCreateWeapon(){}
//////////////////////////////////////
// Function: Accessors
// Purpose : To get the specified type
///////////////////////////////////////
inline CNinja* GetNinja() {return m_pNinja;}
};
class CDestroyWeapon : public CBaseMessage
{
CBase* m_pWeapon;
public:
///////////////////////////////////////////////////////////////////
// Function: "CDestroyWeapon(Constructor)"
///////////////////////////////////////////////////////////////////
CDestroyWeapon(CBase* weapon):CBaseMessage(MSG_DESTROY_WEAPON){m_pWeapon = weapon;}
///////////////////////////////////////////////////////////////////
// Function: "~CDestroyWeapon(Destructor)"
///////////////////////////////////////////////////////////////////
~CDestroyWeapon(){}
inline CBase* GetWeapon() {return m_pWeapon;}
};
#endif
| [
"AllThingsCandid@7dc79cba-3e6d-11de-b8bc-ddcf2599578a",
"marvelman610@7dc79cba-3e6d-11de-b8bc-ddcf2599578a"
] | [
[
[
1,
16
],
[
19,
65
],
[
67,
70
],
[
72,
81
],
[
83,
106
],
[
108,
111
],
[
113,
118
],
[
121,
122
]
],
[
[
17,
18
],
[
66,
66
],
[
71,
71
],
[
82,
82
],
[
107,
107
],
[
112,
112
],
[
119,
120
]
]
] |
930ccdd208f3cff31360d478d5346a7227acd419 | 3e69b159d352a57a48bc483cb8ca802b49679d65 | /tags/release-2005-12-22/include/gr_basic.h | e5e7dd64ae48e796d74756d047b81b1c35a35517 | [] | 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 | IBM852 | C++ | false | false | 7,279 | h | /**************/
/* gr_basic.h */
/**************/
#ifndef GR_BASIC
#define GR_BASIC
#ifndef eda_global
#define eda_global extern
#endif
#include "colors.h"
/* Constantes utiles */
#define GR_COPY 0
#define GR_OR 0x1000000
#define GR_XOR 0x2000000
#define GR_AND 0x4000000
#define GR_NXOR 0x8000000
#define GR_SURBRILL 0x80000000
#define GR_M_LEFT_DOWN 0x10000000
#define GR_M_RIGHT_DOWN 0x20000000
#define GR_M_MIDDLE_DOWN 0x40000000
#define GR_M_DCLICK 0x80000000
/* variables generales */
eda_global int XorMode // = GR_XOR ou GR_NXOR selon couleur de fond
#ifdef MAIN // pour les tracÚs en mode XOR
= GR_NXOR
#endif
;
eda_global int DrawBgColor // couleur de fond de la frame de dessin
#ifdef MAIN
= WHITE
#endif
;
typedef enum { /* Line styles for Get/SetLineStyle. */
GR_SOLID_LINE = 0,
GR_DOTTED_LINE = 1,
GR_DASHED_LINE = 3
} GRLineStypeType;
typedef enum { /* Line widths for Get/SetLineStyle. */
GR_NORM_WIDTH = 1,
GR_THICK_WIDTH = 3
} GRLineWidthType;
/*******************************************************/
/* Prototypage des fonctions definies dans gr_basic.cc */
/*******************************************************/
int GRMapX(int x);
int GRMapY(int y);
class WinEDA_DrawPanel;
void GRMouseWarp(WinEDA_DrawPanel * panel, const wxPoint& pos); /* positionne la souris au point de coord pos */
/* routines generales */
void GRSetDrawMode(wxDC * DC, int mode);
int GRGetDrawMode(wxDC * DC);
void GRResetPenAndBrush(wxDC * DC);
void GRSetColorPen(wxDC * DC, int Color , int width = 1);
void GRSetBrush(wxDC * DC, int Color , int fill = 0);
void GRForceBlackPen(bool flagforce );
void SetPenMinWidth(int minwidth); /* ajustage de la largeur mini de plume */
void GRLine(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int Color);
void GRMixedLine(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int Color);
void GRSMixedLine(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int Color);
void GRDashedLine(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int Color);
void GRSDashedLine(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int Color);
void GRDashedLineTo(EDA_Rect * ClipBox,wxDC * DC, int x2, int y2, int Color);
void GRSDashedLineTo(EDA_Rect * ClipBox,wxDC * DC, int x2, int y2, int Color);
void GRBusLine(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int Color);
void GRSBusLine(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int Color);
void GRSLine(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int Color);
void GRMoveTo(int x, int y);
void GRSMoveTo(int x, int y);
void GRLineTo(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int Color);
void GRBusLineTo(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int Color);
void GRSLineTo(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int Color);
void GRMoveRel(int x, int y);
void GRSMoveRel(int x, int y);
void GRLineRel(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int Color);
void GRSLineRel(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int Color);
void GRPoly(EDA_Rect * ClipBox, wxDC * DC, int n, int *Points,
int Fill, int Color, int BgColor);
void GRPolyLines(EDA_Rect * ClipBox, wxDC * DC, int n, int *Points,
int Color, int BgColor, int width);
void GRClosedPoly(EDA_Rect * ClipBox, wxDC * DC, int n, int *Points,
int Fill, int Color, int BgColor);
void GRSPoly(EDA_Rect * ClipBox, wxDC * DC, int n, int *Points,
int Fill, int Color, int BgColor);
void GRSPolyLines(EDA_Rect * ClipBox, wxDC * DC, int n, int *Points,
int Color, int BgColor, int width);
void GRSClosedPoly(EDA_Rect * ClipBox, wxDC * DC, int n, int *Points,
int Fill, int Color, int BgColor);
void GRCircle(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int r, int Color);
void GRCircle(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int r, int width, int Color);
void GRFilledCircle(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int r,
int Color, int BgColor);
void GRSCircle(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int r, int Color);
void GRSCircle(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int r, int width, int Color);
void GRSFilledCircle(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int r,
int Color, int BgColor);
void GRArc(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int StAngle, int EndAngle, int r, int Color);
void GRArc(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int StAngle, int EndAngle, int r, int width, int Color);
void GRArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2,
int xc, int yc, int Color);
void GRArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2,
int xc, int yc, int width, int Color);
void GRSArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2,
int xc, int yc, int Color);
void GRSArc1(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2,
int xc, int yc, int width, int Color);
void GRSArc(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int StAngle, int EndAngle, int r, int Color);
void GRSArc(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int StAngle, int EndAngle, int r, int width, int Color);
void GRFilledArc(EDA_Rect * ClipBox, wxDC * DC, int x, int y,
int StAngle, int EndAngle, int r, int Color, int BgColor);
void GRSFilledArc(EDA_Rect * ClipBox, wxDC * DC, int x, int y,
int StAngle, int EndAngle, int r, int Color, int BgColor);
void GRCSegm(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color);
void GRFillCSegm(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color);
void GRSCSegm(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1, int x2, int y2, int width, int Color);
void GRSFillCSegm(EDA_Rect * ClipBox, wxDC * DC,
int x1, int y1, int x2, int y2, int width, int Color);
void GRSetColor(int Color);
void GRSetDefaultPalette(void);
int GRGetColor(void);
void GRPutPixel(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int color);
void GRSPutPixel(EDA_Rect * ClipBox, wxDC * DC, int x, int y, int color);
int GRGetPixel(wxDC * DC, int x, int y);
void GRFilledRect(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1,
int x2, int y2, int Color, int BgColor);
void GRSFilledRect(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1,
int x2, int y2, int Color, int BgColor);
void GRSFilledRect(EDA_Rect * ClipBox,wxDC * DC, int x1, int y1, int x2, int y2,
int Color, int BgColor);
void GRRect(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1,
int x2, int y2, int Color);
void GRSRect(EDA_Rect * ClipBox, wxDC * DC, int x1, int y1,
int x2, int y2, int Color);
/* Routines relatives a l'affichage des textes */
void GRSetFont(wxDC * DC, wxFont * Font);
void GRResetTextFgColor(wxDC * DC);
void GRSetTextFgColor(wxDC * DC, int Color);
void GRSetTextFgColor(wxDC * DC, wxFont * Font, int Color);
int GRGetTextFgColor(wxDC * DC, wxFont * Font);
void GRSetTextBgColor(wxDC * DC, int Color);
void GRSetTextBgColor(wxDC * DC, wxFont * Font, int Color);
int GRGetTextBgColor(wxDC * DC, wxFont * Font);
void GRGetTextExtent(wxDC * DC, const wxChar * Text, long * width, long * height);
#endif /* define GR_BASIC */
| [
"bokeoa@244deca0-f506-0410-ab94-f4f3571dea26"
] | [
[
[
1,
163
]
]
] |
1bf42a8ddb71a19fed289e4500cee7f9be267b25 | 2c9cddc9fb1aeb36a4f213f12850897878f4d2cd | /src/Wanderer.hpp | a88c099886d211dabb4e8f534c1c42b5eaf78f31 | [] | no_license | trezker/Mapgen | 2dcf7f15b888e576302c93f1ff21906ffd517845 | 0a27dc2834374ee8d08306409ed79da69f04b2f4 | refs/heads/master | 2021-01-20T11:05:45.481820 | 2011-08-21T15:40:09 | 2011-08-21T15:40:09 | 2,205,920 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 484 | hpp | #ifndef WANDERERHPP
#define WANDERERHPP
#include "vektor.hpp"
class Wanderer
{
char ux, uy, u0x, u0y;
float dx, dy;
float ditherer;
float smaller;
float bigger;
char sgn(float x);
float abs(float x);
public:
int x, y, steps;
Wanderer(int xin, int yin, float dxin, float dyin);
Wanderer(int x1in, int y1in, int x2in, int y2in);
Wanderer(int xin, int yin, Vektor *v);
void Step(void);
char Done(void);
};
#endif
| [
"[email protected]"
] | [
[
[
1,
25
]
]
] |
a74abf1b9e9c2e131b3a29a25c935c4fb3997152 | 4f89f1c71575c7a5871b2a00de68ebd61f443dac | /src/algorithms/features/fast/SimpleFAST.hpp | be4493c64ea36507ad3a03e9e1dfd92dd10ba461 | [] | no_license | inayatkh/uniclop | 1386494231276c63eb6cdbe83296cdfd0692a47c | 487a5aa50987f9406b3efb6cdc656d76f15957cb | refs/heads/master | 2021-01-10T09:43:09.416338 | 2009-09-03T16:26:15 | 2009-09-03T16:26:15 | 50,645,836 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,286 | hpp |
#if !defined(SIMPLE_FAST_HEADER_INCLUDED)
#define SIMPLE_FAST_HEADER_INCLUDED
// Features detection
// ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=
// Headers
#include "../IFeaturesDetector.hpp"
#include "FASTFeature.hpp"
#include <vector>
#include <boost/cstdint.hpp>
#include <boost/program_options.hpp>
#include <boost/gil/typedefs.hpp>
namespace uniclop
{
using namespace std;
namespace args = boost::program_options;
using boost::uint8_t;
using boost::gil::gray8c_view_t;
// ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=
// Interfaces definition
class SimpleFAST : public IFeaturesDetector<FASTFeature, gray8c_view_t>
{ // simplest implementation of FAST, based on the implementation of Edward Rosten
// FAST features detection and matching by Edward Rosten and Tom Drummond
vector<FASTFeature> detected_features, best_features;
int barrier;
public:
static args::options_description get_options_description();
SimpleFAST(args::variables_map &options);
~SimpleFAST();
const vector<FASTFeature> &detect_features(const gray8c_view_t& view);
};
}
#endif // #if !defined(SIMPLE_FAST_HEADER_INCLUDED)
| [
"rodrigo.benenson@gmailcom"
] | [
[
[
1,
52
]
]
] |
1edc2cc9c941c5808e70aea2d42b4c3cf00ad3b1 | d826e0dcc5b51f57101f2579d65ce8e010f084ec | /pre/FSOLIDCreateProtrusionRevolve.cpp | 2979484f760115b4761144dc7269106cf051bef1 | [] | no_license | crazyhedgehog/macro-parametric | 308d9253b96978537a26ade55c9c235e0442d2c4 | 9c98d25e148f894b45f69094a4031b8ad938bcc9 | refs/heads/master | 2020-05-18T06:01:30.426388 | 2009-06-26T15:00:02 | 2009-06-26T15:00:02 | 38,305,994 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,602 | cpp | #include ".\FSOLIDCreateProtrusionRevolve.h"
#include <iostream>
#include <uf_sket.h>
#include <uf_modl.h>
#include "Part.h"
#include "FSketch.h"
#include "FSKETCHCreate2DCenterline.h"
using namespace std;
int FSOLIDCreateProtrusionRevolve::_nProRevCnt = 0;
FSOLIDCreateProtrusionRevolve::FSOLIDCreateProtrusionRevolve(Part * part, tag_t fTag) :
Feature(part,fTag)
{
_bFlip=0;
_StaType=End_Dimension;
_dStaAng=0;
_EndType=End_Dimension;
_dEndAng=0;
}
FSOLIDCreateProtrusionRevolve::~FSOLIDCreateProtrusionRevolve(void)
{
}
void FSOLIDCreateProtrusionRevolve::GetUGInfo()
{
// Get the feature tag
tag_t fTag = GetFTag();
//---------- Start Condition, End Condition ----------//
int edit=0;
char * taper_angle;
char * limit1;
char * limit2;
UF_CALL( UF_MODL_ask_sweep_parms (fTag, edit, &taper_angle, &limit1, &limit2) );
// UF_free() for taper_angle, limit1, limit2
//---------- Start angle, End angle ----------//
for(unsigned int i=0; i<strlen(limit1) ; i++) { if(limit1[i] == '=') break; }
for(unsigned int j=0; i<strlen(limit2) ; j++) { if(limit2[j] == '=') break; }
SetStaAng( atof((const char*)(limit1+i+1)) );
SetEndAng( atof((const char*)(limit2+j+1)) );
// UF_free()
UF_free(taper_angle);
UF_free(limit1);
UF_free(limit2);
// Get the profile sketch feature
tag_t fSketTag;
UF_CALL(UF_MODL_ask_sketch_of_sweep(fTag, &fSketTag));
_pProFSket = (FSketch *)(GetPart()->GetFeatureByTag(fSketTag));
//DEBUG
cout << " " << "Profile Sketch Feature Tag : " << fSketTag << endl ;
// get revolve origin and axis
double pos[3], dir[3];
UF_MODL_ask_sweep_direction(fTag, pos, dir); // Don't use UF_CALL()
// create 2DCenterline and GetUGInfo()
FSKETCHCreate2DCenterline* pCLine = new FSKETCHCreate2DCenterline(GetPart(),0,_pProFSket);
pCLine->GetUGInfo(pos,dir);
// Set Centerline in the SketObjList of profile sketch
_pProFSket->SetCLine(pCLine);
//---------- Set Result_Object_Name ----------//
char buffer[20];
_itoa( _nProRevCnt++, buffer, 10 );
SetName("proRevolve" + (string)buffer);
}
void FSOLIDCreateProtrusionRevolve::ToTransCAD()
{
bstr_t proSketName( GetProSket()->GetName().c_str() );
TransCAD::IReferencePtr spProSket = GetPart()->_spPart->SelectObjectByName(proSketName);
// Create a protrusion revolve feature with the sketch
GetPart()->_spFeatures->AddNewSolidProtrusionRevolveFeature(GetName().c_str(),spProSket,
_dStaAng, TransCAD::StdRevolveEndType_Blind,
_dEndAng, TransCAD::StdRevolveEndType_Blind, false);
}
| [
"surplusz@2d8c97fe-2f4b-11de-8e0c-53a27eea117e"
] | [
[
[
1,
90
]
]
] |
7278bb17128aca5ff58724d69a782661c1655031 | d752d83f8bd72d9b280a8c70e28e56e502ef096f | /Shared/Utility/Memory/Stack.h | dd4cab283a140790269b6c85f27849766e83af0c | [] | no_license | apoch/epoch-language.old | f87b4512ec6bb5591bc1610e21210e0ed6a82104 | b09701714d556442202fccb92405e6886064f4af | refs/heads/master | 2021-01-10T20:17:56.774468 | 2010-03-07T09:19:02 | 2010-03-07T09:19:02 | 34,307,116 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,143 | h | //
// The Epoch Language Project
// FUGUE Virtual Machine
//
// Definition of the basic push-down, downward-growing stack
// used during execution of code within the virtual machine.
//
#pragma once
//
// Basic implementation of a downward-growing stack
//
class StackSpace
{
// Construction and destruction
public:
StackSpace();
StackSpace(size_t numbytes);
~StackSpace();
// Stack manipulation
public:
void Push(size_t numbytes);
void Pop(size_t numbytes);
// Stack address retrieval
public:
void* GetCurrentTopOfStack() const
{ return CurrentStackPointer; }
// WARNING - this code makes a platform-dependent assumption that char is 1 byte
void* GetOffsetIntoStack(size_t numbytes) const
{ return reinterpret_cast<Byte*>(CurrentStackPointer) + numbytes; }
// Statistics
public:
size_t GetAllocatedStack() const
{ return reinterpret_cast<Byte*>(EndOfStackAllocation) - reinterpret_cast<Byte*>(CurrentStackPointer); }
// END platform-dependent assumptions
// Internal tracking
private:
void* StackAllocation;
void* EndOfStackAllocation;
void* CurrentStackPointer;
};
| [
"[email protected]"
] | [
[
[
1,
50
]
]
] |
f6bb9f9c958e84ff125e67c3719c4c23123f5b0d | 5095bbe94f3af8dc3b14a331519cfee887f4c07e | /apsim/Plant/source/Photosynthesis/SUCROSModel.cpp | 40e18087cfb0c8111884e576519201a9cd19048a | [] | no_license | sativa/apsim_development | efc2b584459b43c89e841abf93830db8d523b07a | a90ffef3b4ed8a7d0cce1c169c65364be6e93797 | refs/heads/master | 2020-12-24T06:53:59.364336 | 2008-09-17T05:31:07 | 2008-09-17T05:31:07 | 64,154,433 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 21,464 | cpp | #include "StdPlant.h"
#include "SUCROSModel.h"
#include "Co2Modifier.h"
#include "Phenology/Phenology.h"
#include "Environment.h"
#include "Leaf/Leaf.h"
using namespace std;
SUCROSModel::SUCROSModel(ScienceAPI& scienceAPI, plantInterface& p)
: PhotosynthesisModel(scienceAPI, p)
{
// RUE.read(scienceAPI,
// "x_stage_rue", "()", 0.0, 1000.0,
// "y_rue", "(g dm/mj)", 0.0, 1000.0);
};
float SUCROSModel::Potential (float radiationInterceptedGreen)
{
// double stress_factor = min(min(min(plant.getTempStressPhoto(), plant.getNfactPhoto())
// , plant.getOxdefPhoto()), plant.getPfactPhoto());
//
// return radiationInterceptedGreen * plant.phenology().doInterpolation(RUE) * stress_factor * plant.getCo2Modifier()->rue();
float GrossPhotosythesis;
GrossPhotosythesis = DailyCanopyGrossPhotosythesis(plant.leaf().getLAI(),
plant.environment().Latitude(),
plant.environment().dayOfYear(),
plant.environment().radn(),
plant.environment().maxt(),
plant.environment().mint(),
plant.environment().co2(),
min(min(plant.getNfactPhoto(),plant.getOxdefPhoto()),plant.getPfactPhoto()))
* 30./44. // Convert CO2 to CH2O
* 0.1 // Convert kg/ha to g/m2
* (1.0/1.45); // Convert CHO to biomass - Growth Respiration
//co2 lost = GrossPhotosythesis * (1-(1.0/1.45));??
return GrossPhotosythesis;
}
void SUCROSModel::Read(void)
{
scienceAPI.read("pgmmax", fPgmmax, 0.0f, 100.0f);
scienceAPI.read("maxlue", fMaxLUE, 0.0f, 100.0f);
scienceAPI.read("co2cmp", fCO2Cmp, 0.0f, 100.0f);
scienceAPI.read("co2r", fCO2R, 0.0f, 100.0f);
scienceAPI.read("kdif", fKDIF, 0.0f, 100.0f);
scienceAPI.read("maxtmp", fMaxTmp, 0.0f, 100.0f);
scienceAPI.read("opttmp", fOptTmp, 0.0f, 100.0f);
scienceAPI.read("mintmp", fMinTmp, 0.0f, 100.0f);
scienceAPI.read("photosynthetic_pathway", pathway);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//float DLL DailyCanopyGrossPhotosythesis(LPSTR pCrop,float fLAI, float fLatitude,int nDay,
// float fRad,float fTmpMax,float fTmpMin,float fCO2,
// PZN pLfN,PZRESPONSE pTmpRsp)
//Author: Enli Wang
//Date: 10.11.1996
//Purpose: This function calculates the daily canopy photosynthesis rate under optimal water condition
//Inputs: 1. pCROP - Pointer to a string containing the crop name,use the following names:
// WHEAT,BARLEY,MAIZE,MILLET,SOGHUM,POTATO,SUGARBEET,SOYBEAN,COTTON,C3,C4,CAM
// 2. fLAI - Effective leaf area index (-)
// 3. fLatitude - Location latitude (Degree)
// 4. nDay - Julain day (-)
// 5. fRad - Daily global radiation (MJ/d)
// 6. fTmpMax - Daily maximum air temperature(C)
// 7. fTmpMin - Daily minimum air temperature(C)
// 8. fCO2 - Current CO2 concentration in the air (vppm)
// 9. pLfN - Pointer to a ORGANNC structure containing leaf nitrogen concentration
/// 10. pTmpRsp - Pointer to a ZRESPONSE structure containing temperature response data for photosynthesis
//Outputs: 1. Return - Calculated daily gross photosynthesis rate of unit leaf area (kgCO2/ha.day)
//Functions Called:
// LeafMaxGrossPhotosynthesis
// LeafLightUseEfficiency
// CanopyGrossPhotosynthesis
//Comments: This function checks at first the data contained under pResp. If these data are valid, they will be
// used to construct the temperature response function for photosynthesis. If not, the cardinal temperatures
// at pCardTemp will be used to construct the temperature response function. If pCardTemp equals NULL,
// a minimum, optimum and maximum temperature of 0, 22 and 35C will be assumed respectively.
// If pLfN equals NULL, no nitrogen stress will be considered.
//Reference:1. Wang,Enli. xxxx.
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
float SUCROSModel::DailyCanopyGrossPhotosythesis(float fLAI, float fLatitude,int nDay,
float fRad,float fTmpMax,float fTmpMin,float fCO2,
float nFact)
{
int i;
double vAveGrossPs,vGrossPs,vDailyGrossPs,PAR,PARDIF,PARDIR,vAveGrossPsMax;
double vLAI,vGlobalRadiation,vSinHeight,vDayl,vAtmTrans,vDifFr;
double vLatitude,vDec,vSin,vCos,vRsc,vSolarConst,vDailySin,vDailySinE,vHour,vRadExt;
float fLUE,fPgMax,fTemp;
int nGauss=5;
double xGauss[]={0.0469101, 0.2307534, 0.5000000, 0.7692465, 0.9530899};
double wGauss[]={0.1184635, 0.2393144, 0.2844444, 0.2393144, 0.1184635};
double PI=3.1415926;
double RAD = PI/180.0;
vLAI = (double)fLAI;
vGlobalRadiation = (double)fRad*1E6; //J/m2.d
vLatitude = (double)fLatitude;
//===========================================================================================
//Dailenght, Solar constant and daily extraterrestrial radiation
//===========================================================================================
//Declination of the sun as function of Daynumber (vDay)
vDec = -asin( sin(23.45*RAD)*cos(2.0*PI*((double)nDay+10.0)/365.0));
//vSin, vCos and vRsc are intermediate variables
vSin = sin(RAD*vLatitude)*sin(vDec);
vCos = cos(RAD*vLatitude)*cos(vDec);
vRsc = vSin/vCos;
//Astronomical daylength (hr)
vDayl=12.0*(1.0+2.0*asin(vSin/vCos)/PI);
//Sine of solar height(vDailySin), inegral of vDailySin(vDailySin) and integrel of vDailySin
//with correction for lower atmospheric transmission at low solar elevations (vDailySinE)
vDailySin = 3600.0*(vDayl*vSin+24.0*vCos*sqrt(1.0-vRsc*vRsc)/PI);
vDailySinE = 3600.0*(vDayl*(vSin+0.4*(vSin*vSin+vCos*vCos*0.5))
+12.0*vCos*(2.0+3.0*0.4*vSin)*sqrt(1.0-vRsc*vRsc)/PI);
//Solar constant(vSolarConst) and daily extraterrestrial (vRadExt)
vSolarConst = 1370.0*(1.0+0.033*cos(2.0*PI*(double)nDay/365.0)); //J/m2.d
vRadExt = vSolarConst*vDailySin*1E-6; //MJ/m2.d
//===========================================================================================
//Daily photosynthesis
//===========================================================================================
//Assimilation set to zero and three different times of the Day (vHour)
vAveGrossPs = 0;
vAveGrossPsMax = 0;
//Daytime temperature
fTemp = (float)0.71*fTmpMax+(float)0.29*fTmpMin;
for (i=0;i<nGauss;i++)
{
//At the specified vHour, radiation is computed and used to compute assimilation
vHour = 12.0+vDayl*0.5*xGauss[i];
//Sine of solar elevation
vSinHeight = max(0.0, vSin + vCos*cos(2.0*PI*(vHour+12.0)/24.0));
//Diffuse light fraction (vDifFr) from atmospheric transmission (vAtmTrans)
PAR = 0.5*vGlobalRadiation*vSinHeight*(1.0+0.4*vSinHeight)/vDailySinE;
vAtmTrans = PAR/(0.5*vSolarConst*vSinHeight);
if (vAtmTrans<=0.22)
vDifFr = 1.0;
else
{
if ((vAtmTrans>0.22)&&(vAtmTrans<=0.35))
vDifFr = 1.0-6.4*(vAtmTrans-0.22)*(vAtmTrans-0.22);
else
vDifFr = 1.47-1.66*vAtmTrans;
}
vDifFr = max (vDifFr, 0.15+0.85*(1.0-exp(-0.1/vSinHeight)));
//Diffuse PAR (PARDIF) and direct PAR (PARDIR)
PARDIF = min(PAR, vSinHeight*vDifFr*vAtmTrans*0.5*vSolarConst);
PARDIR = PAR-PARDIF;
//Light response parameters
fPgMax = LeafMaxGrossPhotosynthesis(fTemp,fCO2,nFact);
fLUE = LeafLightUseEfficiency(fTemp,fCO2);
//Canopy gross photosynthesis
vGrossPs= CanopyGrossPhotosynthesis(fPgMax,fLUE,fLAI,fKDIF,fLatitude,
nDay,(float)vHour,(float)PARDIR,(float)PARDIF);
//Integration of assimilation rate to a daily total (vAveGrossPs)
vAveGrossPs += vGrossPs*wGauss[i];
}
vDailyGrossPs= vAveGrossPs * vDayl;
return (float)vDailyGrossPs;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//float DLL LeafMaxGrossPhotosynthesis(float fPgmmax,float fTemp,float fCO2,float fCO2Cmp,float fCO2R,
// float fMinTmp,float fOptTmp,float fMaxTmp,PZN pLfN,PZRESPONSE pResp)
//Author: Enli Wang
//Date: 10.11.1996
//Purpose: This function calculates the maximum gross photosynthesis of unit leaf area at current temperature
// current CO2 concentration, current leaf N level and light saturation
//Inputs: 1. fPgmmax - Maximum gross leaf photosynthesis rate at optimal temperature, N level, both
// CO2 and light saturation (kgCO2/ha.hr)
// 2. fTemp - Current air temperature (C)
// 3. fCO2 - Current CO2 concentration in the air (vppm)
// 4. fCO2Cmp - Compensation point of CO2 for photosynthesis (vppm)
// 5. fCO2R - Ratio of CO2 concentration in stomatal cavity to that in the air (-)
/// 6. pResp - Pointer to a ZRESPONSE structure containing temperature response data for photosynthesis
// 7. pCardTemp - pointer to a CARDTEMP structure containing the cardinal temperature for photosynthesis
// 8. pLfN - Pointer to a ORGANNC structure containing leaf nitrogen concentration
//Outputs: 1. Return - Calculated maximum gross photosynthesis rate of unit leaf area (kgCO2/ha.hr)
//Functions Called:
// RelativeTemperatureResponse
// ZFGENERATOR
//Comments: This function checks at first the data contained under pResp. If these data are valid, they will be
// used to construct the temperature response function for photosynthesis. If not, the cardinal temperatures
// at pCardTemp will be used to construct the temperature response function. If pCardTemp equals NULL,
// a minimum, optimum and maximum temperature of 0, 22 and 35C will be assumed respectively.
// If pLfN equals NULL, no nitrogen stress will be considered.
//Reference:1. Wang,Enli. xxxx.
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
float SUCROSModel::LeafMaxGrossPhotosynthesis(float fTemp,float fCO2,float nFact)
{
float fTempFunc,fCO2I,fCO2I340,fCO2Func,fPmaxGross;
//------------------------------------------------------------------------
//Efect of CO2 concentration of the air
if (fCO2<(float)0.0) fCO2=(float)350;
fCO2=max(fCO2,fCO2Cmp);
fCO2I = fCO2*fCO2R;
fCO2I340= fCO2R*(float)340.0;
// Original Code
// fCO2Func= min((float)2.3,(fCO2I-fCO2Cmp)/(fCO2I340-fCO2Cmp)); //For C3 crops
fCO2Func = (49.57/34.26)*(1.-exp(-0.208*(fCO2-60.)/49.57));
// fCO2Func= min((float)2.3,pow((fCO2I-fCO2Cmp)/(fCO2I340-fCO2Cmp),0.5)); //For C3 crops
//------------------------------------------------------------------------
//Temperature response and Efect of daytime temperature
fTempFunc = RelativeTemperatureResponse(fTemp,fMinTmp,fOptTmp,fMaxTmp);
//------------------------------------------------------------------------
//Maximum leaf gross photosynthesis
fPmaxGross= max((float)1.0, fPgmmax*(fCO2Func*fTempFunc*nFact));
return fPmaxGross;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//float DLL LeafLightUseEfficiency(float fMaxLUE, float fTemp, float fCO2, LPSTR pType)
//Author: Enli Wang
//Date: 10.11.1996
//Purpose: This function calculates the light use efficiency of the leaf at low light level and
// current CO2 concentration and temperature
//Inputs: 1. fMaxLUE - Maximum leaf light use efficiency at low light, low temperature and low CO2
// ((kgCO2/ha leaf.hr)/(W/m2))
// 2. fTemp - Current air temperature (C)
// 3. fCO2 - Current CO2 concentration in the air (vppm)
// 4. pType - Pointer to a string containing the type of the plant (C3 or C4)
//Outputs: 1. Return - Calculated light use efficiency at low light ((kgCO2/ha leaf.hr)/(W/m2))
//Functions Called:
// None
//Comments: For C3 plants the light use efficiency will decreased if temperature becomes or CO2 concentration
// becomes low due to the increased photorespiration. So that the effect of photorespiration is
// simulated in this function
//Reference:1. Wang,Enli. xxxx.
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
float SUCROSModel::LeafLightUseEfficiency(float fTemp, float fCO2)
{
float fCO2PhotoCmp0,fCO2PhotoCmp,fEffPAR;
//Check wheather a C3 or C4 crop
if (Str_i_Eq(pathway.c_str(), "C3")) //C3 plants
fCO2PhotoCmp0=(float)38.0; //vppm
else
fCO2PhotoCmp0=(float)0.0;
//Efect of Temperature
fCO2PhotoCmp = fCO2PhotoCmp0*(float)pow(2.0,((double)fTemp-20.0)/10.0);
//Efect of CO2 concentration
if (fCO2<(float)0.0) fCO2=(float)350;
fCO2=max(fCO2,fCO2PhotoCmp);
// fEffPAR = fMaxLUE*(fCO2-fCO2PhotoCmp)/(fCO2+2*fCO2PhotoCmp);
// fEffPAR = fMaxLUE*(1.0 - exp(-0.00305*fCO2-0.222))/(1.0 - exp(-0.00305*340.0-0.222));
float Ft = 0.6667 - 0.0067*fTemp;
fEffPAR = Ft*(1.0 - exp(-0.00305*fCO2-0.222))/(1.0 - exp(-0.00305*340.0-0.222));
return fEffPAR;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//float DLL CanopyGrossPhotosynthesis(float fPgMax, float fLUE, float fLAI,
// float fLatitude,int nDay,float fHour, float fPARdir,float fPARdif)
//Author: Enli Wang
//Date: 10.11.1996
//Purpose: This function calculates the canopy gross photosynthesis rate for a given crop with fPgMax,fLUE,fLAI
// at latitude (fLatitude) on day (julian day fDay) at fHour
//Inputs: 1. fPgMax - Maximum leaf gross photosynthesis rate at light saturation (kgCO2/ha.hr)
// 2. fLUE - Light use efficiency of the leaf at current conditions ((kgCO2/ha leaf.hr)/(W/m2))
// 3. fLAI - Effective LAI (-)
// 4. fLatitude- Location latitude (Degree)
// 5. nDay - Julain day (-)
// 6. fHour - Current time (Hour)
// 7. fPARdir - Direct component of incident photosynthetic active radiation (W/m2)
// 7. fPARdif - Diffuse component of incident photosynthetic active radiation (W/m2)
//Outputs: 1. Return - Calculated canopy photosynthesis rate (kgCO2/ha.hr)
//Functions Called:
// None
//Comments: The input variable fPgMax and fLUE should be calculated using the following functions:
// fPgMax = LeafMaxGrossPhotosynthesis(...);
// fLUE = LeafLightUseEfficiency(...)
//Reference:1. Wang,Enli. xxxx.
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
float SUCROSModel::CanopyGrossPhotosynthesis(float fPgMax, float fLUE, float fLAI,float fKDIF,
float fLatitude,int nDay,float fHour, float fPARdir,float fPARdif)
{
int i,j;
double PMAX,EFF,vLAI,PARDIR,PARDIF,SINB,KDIF;
double SQV,REFH,REFS,CLUSTF,KDIRBL,KDIRT,FGROS,LAIC,VISDF,VIST,VISD,VISSHD,FGRSH;
double FGRSUN,VISSUN,VISPP,FGRS,FSLLA,FGL,LAT,DAY,HOUR,DEC,vSin,vCos;
int nGauss=5;
double xGauss[]={0.0469101, 0.2307534, 0.5000000, 0.7692465, 0.9530899};
double wGauss[]={0.1184635, 0.2393144, 0.2844444, 0.2393144, 0.1184635};
double PI =3.1415926;
double RAD = PI/180.0;
double SCV = 0.20; //Scattering coefficient of leaves for visible radiation (PAR)
double k = 0.50; //The average extinction coefficient for visible and near infrared radiation
//if WheatAndBarley KDIF =0.6;
//if Potato KDIF =1.0;
//if SugarBeet KDIF =0.69; WAVE, p5-12
KDIF = (double)fKDIF; //Extinction coefficient for diffuse light
PMAX = (double)fPgMax;
EFF = (double)fLUE;
vLAI = (double)fLAI;
PARDIR = (double)fPARdir;
PARDIF = (double)fPARdif;
LAT = (double)fLatitude;
HOUR = (double)fHour;
DAY = (double)nDay;
//===========================================================================================
//Sine of the solar height
//===========================================================================================
//Declination of the sun as function of Daynumber (vDay)
DEC = -asin( sin(23.45*RAD)*cos(2.0*PI*(DAY+10.0)/365.0));
//vSin, vCos and vRsc are intermediate variables
vSin = sin(RAD*LAT)*sin(DEC);
vCos = cos(RAD*LAT)*cos(DEC);
SINB = max(0.0, vSin + vCos*cos(2.0*PI*(HOUR+12.0)/24.0));
//===========================================================================================
//Reflection of horizontal and spherical leaf angle distribution
SQV = sqrt(1.0-SCV);
REFH = (1.0-SQV)/(1.0+SQV);
REFS = REFH*2.0/(1.0+2.0*SINB);
//Extinction coefficient for direct radiation and total direct flux
CLUSTF = KDIF / (0.8*SQV);
KDIRBL = (0.5/SINB) * CLUSTF;
KDIRT = KDIRBL * SQV;
//===========================================================================================
//Selection of depth of canopy, canopy assimilation is set to zero
FGROS = 0;
for (i=0;i<nGauss;i++)
{
LAIC = vLAI * xGauss[i];
//Absorbed fluxes per unit leaf area: diffuse flux, total direct
//flux, direct component of direct flux.
VISDF = (1.0-REFH)*PARDIF*KDIF *exp (-KDIF *LAIC);
VIST = (1.0-REFS)*PARDIR*KDIRT *exp (-KDIRT *LAIC);
VISD = (1.0-SCV) *PARDIR*KDIRBL*exp (-KDIRBL*LAIC);
//Absorbed flux (J/M2 leaf/s) for shaded leaves and assimilation of shaded leaves
VISSHD = VISDF + VIST - VISD;
if (PMAX>0.0)
FGRSH = PMAX * (1.0-exp(-VISSHD*EFF/PMAX));
else
FGRSH = 0.0;
//Direct flux absorbed by leaves perpendicular on direct beam and
//assimilation of sunlit leaf area
VISPP = (1.0-SCV) * PARDIR / SINB;
FGRSUN = 0.0;
for (j=0;j<nGauss;j++)
{
VISSUN = VISSHD + VISPP * xGauss[j];
if (PMAX>0.0)
FGRS = PMAX * (1.0-exp(-VISSUN*EFF/PMAX));
else
FGRS = 0.0;
FGRSUN = FGRSUN + FGRS * wGauss[j];
}
//Fraction sunlit leaf area (FSLLA) and local assimilation rate (FGL)
FSLLA = CLUSTF * exp(-KDIRBL*LAIC);
FGL = FSLLA * FGRSUN + (1.0-FSLLA) * FGRSH;
//Integration of local assimilation rate to canopy assimilation (FGROS)
FGROS = FGROS + FGL * wGauss[i];
}
FGROS = FGROS * vLAI;
return (float)FGROS;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//Function: float DLL RelativeTemperatureResponse(float fTemp,
// float fTempMin, float fTempOpt, float fTempMax)
//Author: Enli Wang
//Date: 07.11.1996
//Purpose: This function calculates the effect of temperature on the rate of certain plant process with
// a temperature optimum (fOptTemp)
//Inputs: 1. fTemp - Current temperature (C)
// 2. fMinTemp - Minimum temperature for the process (C)
// 2. fOptTemp - Optimum temperature for the process (C)
// 2. fMaxTemp - Maximum temperature for the process (C)
//Outputs: The calculated temperature effect (0-1) 0-fMinTemp,fMaxTemp; 1-fOptTemp
//Functions Called:
// None
//Reference:1. Wang,Enli. xxxx.
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
float SUCROSModel::RelativeTemperatureResponse(float fTemp, float fMinTemp, float fOptTemp, float fMaxTemp)
{
double vTemp,vTmin,vTopt,vTmax,p, vRelEff;
vTemp = (double)fTemp;
vTmin = (double)fMinTemp;
vTopt = (double)fOptTemp;
vTmax = (double)fMaxTemp;
if ((fTemp<=fMinTemp)||(fTemp>=fMaxTemp))
vRelEff=0.0;
else
{
p =log(2)/log((vTmax-vTmin)/(vTopt-vTmin));
vRelEff = (2*pow(vTemp-vTmin,p)*pow(vTopt-vTmin,p)-pow(vTemp-vTmin,2*p))/pow(vTopt-vTmin,2*p);
}
return (float)vRelEff;
}
| [
"hut104@8bb03f63-af10-0410-889a-a89e84ef1bc8",
"hol353@8bb03f63-af10-0410-889a-a89e84ef1bc8",
"devoilp@8bb03f63-af10-0410-889a-a89e84ef1bc8"
] | [
[
[
1,
3
],
[
5,
458
],
[
460,
460
]
],
[
[
4,
4
]
],
[
[
459,
459
]
]
] |
d81b4b8129d278d0f61e939fc48ae1b148eeb686 | 1c84fe02ecde4a78fb03d3c28dce6fef38ebaeff | /State_Attack_Enemy.h | ce0963187d8dac02ee8a717e2b127d498ce0fad0 | [] | no_license | aadarshasubedi/beesiege | c29cb8c3fce910771deec5bb63bcb32e741c1897 | 2128b212c5c5a68e146d3f888bb5a8201c8104f7 | refs/heads/master | 2016-08-12T08:37:10.410041 | 2007-12-16T20:57:33 | 2007-12-16T20:57:33 | 36,995,410 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 458 | h | #ifndef STATEATTACKENEMY_H
#define STATEATTACKENEMY_H
#include "FSMState.h"
#include "FSMBeeAIControl.h"
using namespace std;
class StateAttackEnemy: public FSMState
{
public:
StateAttackEnemy(FSMAIControl* control, int type=FSM_ATTACK_ENEMY) :
FSMState(control, type)
{
}
void Enter();
void Exit();
void Update(int i);
void Init();
FSMState* CheckTransitions(int t);
};
NiSmartPointer(StateAttackEnemy);
#endif
| [
"ruhisinha27@8db35e17-053d-0410-88b8-2990f35e824c",
"[email protected]"
] | [
[
[
1,
11
],
[
15,
27
]
],
[
[
12,
14
]
]
] |
16a1b29dc20b21c02fee5b9079ddcd591267e776 | 0b55a33f4df7593378f58b60faff6bac01ec27f3 | /Konstruct/Client/Dimensions/Paralyze.h | 1676920f80e35b1c0733eb3d12d4a52c5fbddc74 | [] | no_license | RonOHara-GG/dimgame | 8d149ffac1b1176432a3cae4643ba2d07011dd8e | bbde89435683244133dca9743d652dabb9edf1a4 | refs/heads/master | 2021-01-10T21:05:40.480392 | 2010-09-01T20:46:40 | 2010-09-01T20:46:40 | 32,113,739 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 395 | h | #pragma once
#include "basicshot.h"
class Paralyze :
public BasicShot
{
public:
Paralyze(void);
~Paralyze(void);
bool Update(PlayerCharacter* pSkillOwner, float fDeltaTime);
protected:
int GetRange() { return m_iMinRange + m_iSkillRank / m_iRangeMod; }
float m_fMinRadius;
int m_iRadiusMod;
int m_iRangeMod;
int m_iMinResist;
int m_iResistMod;
};
| [
"bflassing@0c57dbdb-4d19-7b8c-568b-3fe73d88484e"
] | [
[
[
1,
22
]
]
] |
03e38fe2b0152985d4fa19b9e15334c3b7f91809 | 252e638cde99ab2aa84922a2e230511f8f0c84be | /reflib/src/TripOwnerSimpleProcessForm.h | 9043d047fb3898a9e31c8a2deb5724c539f564a1 | [] | no_license | openlab-vn-ua/tour | abbd8be4f3f2fe4d787e9054385dea2f926f2287 | d467a300bb31a0e82c54004e26e47f7139bd728d | refs/heads/master | 2022-10-02T20:03:43.778821 | 2011-11-10T12:58:15 | 2011-11-10T12:58:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,496 | h | //---------------------------------------------------------------------------
#ifndef TripOwnerSimpleProcessFormH
#define TripOwnerSimpleProcessFormH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include "SimpleProcessForm.h"
#include "VStringStorage.h"
#include <ExtCtrls.hpp>
enum TourTripOwnerSimpleProcessStringsTypes
{
TourTripOwnerSimpleProcessTripOwnerFieldEmptyErrorMessageStr = TourSimpleProcessStringsCount,
TourTripOwnerSimpleProcessTripOwnerFieldEmptyExceptionMessageStr,
TourTripOwnerSimpleProcessTripOwnerStringsCount
};
//---------------------------------------------------------------------------
class TTourTripOwnerSimpleProcessForm : public TTourSimpleProcessForm
{
__published: // IDE-managed Components
TLabel *TripOwnerLabel;
TLabel *TripOwnerNameLabel;
TEdit *TripOwnerEdit;
TEdit *TripOwnerNameEdit;
void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose);
private: // User declarations
public: // User declarations
__fastcall TTourTripOwnerSimpleProcessForm(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TTourTripOwnerSimpleProcessForm *TourTripOwnerSimpleProcessForm;
//---------------------------------------------------------------------------
#endif
| [
"[email protected]"
] | [
[
[
1,
37
]
]
] |
14d2ddd7e6493f9cc61f013f90115e911db4c872 | dd296e4ce663222db78a3aa7230cabe4b6620747 | /Programs/CryectsTools/FileInfo.cpp | 4841958aca9d37c005b97ace8f51f9386d7701bf | [] | no_license | vienis/mcbuddiapfel | 42213684b253d7a0dae8b785c58a13853d6c9efd | e4d5c6b91d2f9f3b2d0de011cca3298a4e266d89 | refs/heads/master | 2021-01-10T02:13:50.149299 | 2011-01-22T13:56:56 | 2011-01-22T13:56:56 | 36,045,662 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,128 | cpp | #include <stdio.h>
#include <string.h>
FILE *Input;
struct MCIN{
unsigned int Offset;
unsigned int Size;
unsigned int Temp1;
unsigned int Temp2;
};
/*
MCNK
0x14 MCVT Offset
0x18 MCNR Offset
0x1C MCLY Offset
0x20 MCRF Offset
0x24 MCAL Offset
0x2C MCSH Offset
0x52 MCSE Offset
0x60 MCLQ Offset
0x68 Z' Base Coordinate
0x6C X' Base Coordinate
0x70 Y Base Coordinate
*/
struct MCNK{
float Z;
float X;
float Y;
};
struct Pos
{
float x;
float y;
float z;
};
struct MCLQ
{
int Enabled;
float First;
float Vertex[81];
int Flags[81];
float Last;
};
MCIN Positions[256];
MCNK ADTOffsets[256];
MCLQ WaterLevels[256];
unsigned int MCNK_Positions[256];
unsigned int MTEX_Offset;
unsigned int MMDX_Offset;
unsigned int MMID_Offset;
unsigned int MWMO_Offset;
unsigned int MWID_Offset;
unsigned int MDDF_Offset;
unsigned int MODF_Offset;
int NumDoodads;
Pos *Doodads;
unsigned char *File;
unsigned int FileSize;
struct DDF
{
unsigned int ID;
unsigned int UniqueID;
float Pos[3];
float Rot[3];
unsigned int Scale;
};
struct WMO
{
unsigned int ID;
unsigned int UniqueID;
float Pos[3];
float Rot[3];
float Pos2[3];
float Pos3[3];
short Unknown1;
short DoodadIndex;
unsigned int Unknown2;
};
int NumWMOs;
WMO *WMOs;
char *Textures;
char *MDXFiles;
int diffMDXs;
int *MDXOffsets;
char *WMOFiles;
int diffWMOs;
int *WMOOffsets;
int NumDDFs;
DDF *DDFs;
void FindMDDFandMODF()
{
fseek(Input,0x1c,SEEK_SET);
fread(&MTEX_Offset,sizeof(unsigned int),1,Input);
fread(&MMDX_Offset,sizeof(unsigned int),1,Input);
fread(&MMID_Offset,sizeof(unsigned int),1,Input);
fread(&MWMO_Offset,sizeof(unsigned int),1,Input);
fread(&MWID_Offset,sizeof(unsigned int),1,Input);
fread(&MDDF_Offset,sizeof(unsigned int),1,Input);
fread(&MODF_Offset,sizeof(unsigned int),1,Input);
}
short Map[256];
void LoadMTEX()
{
unsigned int TexSize;
fseek(Input,0x14+0x04+MTEX_Offset,SEEK_SET);
fread(&TexSize,sizeof(int),1,Input);
Textures=new char[TexSize];
fread(Textures,sizeof(char),TexSize,Input);
for(int i=0;i<TexSize-1;i++)
if (Textures[i]==0)
Textures[i]='\n';
}
void LoadMDXs()
{
unsigned int temp;
fseek(Input,0x14+0x04+MMDX_Offset,SEEK_SET);
fread(&temp,sizeof(int),1,Input);
MDXFiles=new char[temp];
fread(MDXFiles,sizeof(char),temp,Input);
fseek(Input,0x14+0x04+MMID_Offset,SEEK_SET);
fread(&temp,sizeof(int),1,Input);
diffMDXs=temp/4;
MDXOffsets=new int[diffMDXs];
fread(MDXOffsets,sizeof(int),diffMDXs,Input);
fseek(Input,0x14+0x04+MDDF_Offset,SEEK_SET);
fread(&NumDDFs,sizeof(unsigned int),1,Input);
NumDDFs=NumDDFs/sizeof(DDF);
DDFs=new DDF[NumDDFs];
fread(DDFs,sizeof(DDF),NumDDFs,Input);
}
void LoadWMOs()
{
unsigned int temp;
fseek(Input,0x14+0x04+MWMO_Offset,SEEK_SET);
fread(&temp,sizeof(int),1,Input);
WMOFiles=new char[temp];
fread(WMOFiles,sizeof(char),temp,Input);
fseek(Input,0x14+0x04+MWID_Offset,SEEK_SET);
fread(&temp,sizeof(int),1,Input);
diffWMOs=temp/4;
WMOOffsets=new int[diffWMOs];
fread(WMOOffsets,sizeof(int),diffWMOs,Input);
fseek(Input,0x14+0x04+MODF_Offset,SEEK_SET);
fread(&NumWMOs,sizeof(unsigned int),1,Input);
NumWMOs=NumWMOs/64;
WMOs=new WMO[NumWMOs];
fread(WMOs,sizeof(WMO),NumWMOs,Input);
}
int main(int argc, char **argv)
{
int i;
char *replace;
if(argc<2)
{
printf("fileinfo <adt file>\n");
return 0;
}
printf("Extracting Info From File %s\n",argv[1]);
Input=fopen(argv[1],"rb");
if(Input==0)
{
printf("ERROR: Could not open %s\n",argv[1]);
return 0;
}
printf("Finding MDDF's & MODF's\n");
FindMDDFandMODF();
printf("Loading MTEX\n");
LoadMTEX();
printf("Loading MDDX\n");
LoadMDXs();
printf("Loading WMOs\n");
LoadWMOs();
fclose(Input);
printf("Closing File\n");
replace=strstr(argv[1],"adt");
replace[0]='t';
replace[1]='x';
replace[2]='t';
FILE *Output;
Output=fopen(argv[1],"wt");
if(Output==0)
{
printf("ERROR: Couldn't open %s for saving\n",argv[1]);
return 0;
}
printf("Writing Info To File %s\n",argv[1]);
fprintf(Output,"MMDX\t%d\n",diffMDXs);
for(i=0;i<diffMDXs;i++)
fprintf(Output,"%d\t%s\n",i,MDXFiles+MDXOffsets[i]);
fprintf(Output,"\nMWMO\t%d\n",diffWMOs);
for(i=0;i<diffWMOs;i++)
fprintf(Output,"%d\t%s\n",i,WMOFiles+WMOOffsets[i]);
fprintf(Output,"\nMDDF\t%d\n",NumDDFs);
for(i=0;i<NumDDFs;i++)
fprintf(Output,"%d\t%d\t%f\t%f\t%f\t%f\t%f\t%f\t%d\n",DDFs[i].ID,DDFs[i].UniqueID,DDFs[i].Pos[0],DDFs[i].Pos[1],DDFs[i].Pos[2],DDFs[i].Rot[0],DDFs[i].Rot[1],DDFs[i].Rot[2],DDFs[i].Scale);
fprintf(Output,"\nMODF\t%d\n",NumWMOs);
for(i=0;i<NumWMOs;i++)
fprintf(Output,"%d\t%d\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%d\n",WMOs[i].ID,WMOs[i].UniqueID,WMOs[i].Pos[0],WMOs[i].Pos[1],WMOs[i].Pos[2],WMOs[i].Rot[0],WMOs[i].Rot[1],WMOs[i].Rot[2],WMOs[i].Pos2[0],WMOs[i].Pos2[1],WMOs[i].Pos2[2],WMOs[i].Pos3[0],WMOs[i].Pos3[1],WMOs[i].Pos3[2],WMOs[i].DoodadIndex);
fclose(Output);
}
| [
"[email protected]@af0300bf-f729-58c1-2b4a-178d59e24212"
] | [
[
[
1,
240
]
]
] |
12a5eb6e00a7a2fed89c66200cd464e4e71fb5eb | fcf03ead74f6dc103ec3b07ffe3bce81c820660d | /HelloWorld/HelloWorld_AppUi.cpp | b6768e59ae790af17b7aa5ac71748279c3120d03 | [] | no_license | huellif/symbian-example | 72097c9aec6d45d555a79a30d576dddc04a65a16 | 56f6c5e67a3d37961408fc51188d46d49bddcfdc | refs/heads/master | 2016-09-06T12:49:32.021854 | 2010-10-14T06:31:20 | 2010-10-14T06:31:20 | 38,062,421 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,221 | cpp | // HelloWorld_CExampleAppUi.cpp
// ----------------------------
//
// Copyright (c) 2000 Symbian Ltd. All rights reserved.
//
////////////////////////////////////////////////////////////////////////
//
// Source file for the implementation of the
// application UI class - CExampleAppUi
//
////////////////////////////////////////////////////////////////////////
#include "HelloWorld.h"
// The second phase constructor of the application UI class.
// The application UI creates and owns the one and only view.
//
void CExampleAppUi::ConstructL()
{
// BaseConstructL() completes the UI framework's
// construction of the App UI.
BaseConstructL();
// Create the single application view in which to
// draw the text "Hello World!", passing into it
// the rectangle available to it.
iAppView = CExampleAppView::NewL(ClientRect());
}
// The app Ui owns the two views and is.
// therefore, responsible for destroying them
//
CExampleAppUi::~CExampleAppUi()
{
delete iAppView;
}
// Called by the UI framework when a command has been issued.
// In this example, a command can originate through a
// hot-key press or by selection of a menu item.
// The command Ids are defined in the .hrh file
// and are 'connected' to the hot-key and menu item in the
// resource file.
// Note that the EEikCmdExit is defined by the UI
// framework and is pulled in by including eikon.hrh
//
void CExampleAppUi::HandleCommandL(TInt aCommand)
{
switch (aCommand)
{
// Just issue simple info messages to show that
// the menu items have been selected
case EExampleItem0:
iEikonEnv->InfoMsg(R_EXAMPLE_TEXT_ITEM0);
break;
case EExampleItem1:
iEikonEnv->InfoMsg(R_EXAMPLE_TEXT_ITEM1);
break;
case EExampleItem2:
iEikonEnv->InfoMsg(R_EXAMPLE_TEXT_ITEM2);
break;
// Exit the application. The call is
// implemented by the UI framework.
case EEikCmdExit:
Exit();
break;
}
}
| [
"liuxk99@bdc341c6-17c0-11de-ac9f-1d9250355bca"
] | [
[
[
1,
75
]
]
] |
6b596cbd2080e0a2bbf763da2c37ea057123f0da | 9a48be80edc7692df4918c0222a1640545384dbb | /Libraries/Boost1.40/libs/asio/example/timeouts/connect_timeout.cpp | 8cc61b7d3a287bf8e5f9eff32382aad6af448feb | [
"BSL-1.0"
] | permissive | fcrick/RepSnapper | 05e4fb1157f634acad575fffa2029f7f655b7940 | a5809843f37b7162f19765e852b968648b33b694 | refs/heads/master | 2021-01-17T21:42:29.537504 | 2010-06-07T05:38:05 | 2010-06-07T05:38:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,966 | cpp | //
// connect_timeout.cpp
// ~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// 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)
//
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <iostream>
using namespace boost::asio;
using boost::asio::ip::tcp;
class connect_handler
{
public:
connect_handler(io_service& ios)
: io_service_(ios),
timer_(ios),
socket_(ios)
{
socket_.async_connect(
tcp::endpoint(boost::asio::ip::address_v4::loopback(), 32123),
boost::bind(&connect_handler::handle_connect, this,
boost::asio::placeholders::error));
timer_.expires_from_now(boost::posix_time::seconds(5));
timer_.async_wait(boost::bind(&connect_handler::close, this));
}
void handle_connect(const boost::system::error_code& err)
{
if (err)
{
std::cout << "Connect error: " << err.message() << "\n";
}
else
{
std::cout << "Successful connection\n";
}
}
void close()
{
socket_.close();
}
private:
io_service& io_service_;
deadline_timer timer_;
tcp::socket socket_;
};
int main()
{
try
{
io_service ios;
tcp::acceptor a(ios, tcp::endpoint(tcp::v4(), 32123), 1);
// Make lots of connections so that at least some of them will block.
connect_handler ch1(ios);
connect_handler ch2(ios);
connect_handler ch3(ios);
connect_handler ch4(ios);
connect_handler ch5(ios);
connect_handler ch6(ios);
connect_handler ch7(ios);
connect_handler ch8(ios);
connect_handler ch9(ios);
ios.run();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}
| [
"metrix@Blended.(none)"
] | [
[
[
1,
85
]
]
] |
b5a5cc1e22b1d9014f5bcbe11849a01bb1e3a143 | 8fcf3f01e46f8933b356f763c61938ab11061a38 | /Interface/sources/Rendering/FunctionItem.h | a8fa75443c22fcdfcf557da861b74aa175aec629 | [] | 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 | ISO-8859-1 | C++ | false | false | 1,187 | h | #ifndef FUNCTION_ITEM_H
#define FUNCTION_ITEM_H
/*!
* \file FunctionItem.h
* \author Pascal Berberat
* \date 12.04.2010
* \version 1.1
*/
#include <QGraphicsScene>
#include "Rendering/FunctionGraphics.h"
#include "Expression/IExpression.h"
#include "Data/ItemData.h"
/*!
* \class FunctionItem
*
* \brief La classe FunctionItem représente un élément graphique associé à une
* fonction.
*
* Cette classe abstraite factorise les élément graphiques d'une fonction en
* leurs associant des données.
*/
class FunctionItem : public FunctionGraphics
{
private:
/*! Données de l'élément graphique */
ItemData data;
public:
/*!
* Constructeur
*
* \param function Fonction
* \param data Données de l'élément graphique
* \param scene Scène graphique
*/
FunctionItem(IExpression* function, const ItemData& data, QGraphicsScene* scene = NULL);
/*!
* Retourne les données de l'élément graphique.
*
* \return Données de l'élément graphique
*/
const ItemData& getData() const;
};
#endif // FUNCTION_ITEM_H
| [
"jonesbusy@fa255007-c97c-c9ae-ff28-e9f0558300b6"
] | [
[
[
1,
55
]
]
] |
233b0a46f5a9cd768d5c2ab55af5c25513beda35 | 4b0f51aeecddecf3f57a29ffa7a184ae48f1dc61 | /CleanProject/OgreMaxLoader/Include/ApplicationLuaTypes.hpp | 8ecc3295255938b7bff4ad9c3d2ec42e50a5d90e | [] | no_license | bahao247/apeengine2 | 56560dbf6d262364fbc0f9f96ba4231e5e4ed301 | f2617b2a42bdf2907c6d56e334c0d027fb62062d | refs/heads/master | 2021-01-10T14:04:02.319337 | 2009-08-26T08:23:33 | 2009-08-26T08:23:33 | 45,979,392 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,213 | hpp | /*
* OgreMaxViewer - An Ogre 3D-based viewer for .scene and .mesh files
* Copyright 2008 Derek Nedelman
*
* This code is available under the OgreMax Free License:
* -You may use this code for any purpose, commercial or non-commercial.
* -If distributing derived works (that use this source code) in binary or source code form,
* you must give the following credit in your work's end-user documentation:
* "Portions of this work provided by OgreMax (www.ogremax.com)"
*
* Derek Nedelman assumes no responsibility for any harm caused by using this code.
*
* OgreMaxViewer was written by Derek Nedelman and released at www.ogremax.com
*/
#ifndef OgreMax_ApplicationLuaTypes_INCLUDED
#define OgreMax_ApplicationLuaTypes_INCLUDED
#ifndef OGREMAX_VIEWER_NO_LUA
//Includes---------------------------------------------------------------------
#include "LuaScript.hpp"
//Classes----------------------------------------------------------------------
namespace OgreMax
{
class LuaScript;
class ApplicationLuaTypes
{
public:
static void Register(LuaScript& script, const Ogre::String& moduleName);
};
}
#endif
#endif | [
"pablosn@06488772-1f9a-11de-8b5c-13accb87f508"
] | [
[
[
1,
41
]
]
] |
ea6c7ca5aa1bc2c019c4f15c8b46c487edffdd44 | d9a78f212155bb978f5ac27d30eb0489bca87c3f | /PB/src/PbLib/PBRequest.h | c786f705c3dd1d05475a3a445ffab3f38c534453 | [] | no_license | marchon/pokerbridge | 1ed4a6a521f8644dcd0b6ec66a1ac46879b8473c | 97d42ef318bf08f3bc0c0cb1d95bd31eb2a3a8a9 | refs/heads/master | 2021-01-10T07:15:26.496252 | 2010-05-17T20:01:29 | 2010-05-17T20:01:29 | 36,398,892 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 301 | h | #pragma once
class PBRequestState
{
public:
PBRequestState();
bool sent(){ return _sent; }
void setSent();
bool answered(){ return _answered; }
void setAnswered();
void reset();
bool timedOut();
private:
QTime _sendTime;
bool _sent;
bool _answered;
int _timeout;
}; | [
"mikhail.mitkevich@a5377438-2eb2-11df-b28a-19025b8c0740"
] | [
[
[
1,
21
]
]
] |
7acaf0738d4d2d9cda34bea4be4088bd460b202f | c3531ade6396e9ea9c7c9a85f7da538149df2d09 | /Param/src/Numerical/linear_solver.h | cd464604e28e7cf0b36d09c07c40c93b186b17be | [] | 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 | 2,333 | h | //
// This class is the implementation of a row-dominant sparse matrix.
// Primarily, the class is designed for sparse mesh structure.
//
//////////////////////////////////////////////////////////////////////
#ifndef LINEAR_SOLVER_2_H
#define LINEAR_SOLVER_2_H
#include "MeshSparseMatrix.h"
#include "solver.h"
#ifdef WIN32
#include <hj_3rd/hjlib/sparse_old/sparse.h>
#else
#include <hj_3rd/hjlib/sparse/sparse.h>
#endif
class LinearSolver: public Solver
{
public:
LinearSolver(int nb_variables);
virtual ~LinearSolver();
public:
// __________________ Construction _____________________
void begin_equation() ;
void begin_row() ;
void set_right_hand_side(double b_) ;
void add_coefficient(int index_, double a_) ;
void end_row() ;
void end_equation() ;
//
void solve();
void solve_from_file();
//
void factorize();
void renew_right_b(std::vector<double>& right_b_vec);
void set_equation_div_flag();
void equations_value(std::vector<double>& var_val_vec);
size_t get_equation_size(){return m_equation_vec.size();}
void is_printf_info(bool is_){m_is_printf_info=is_;}
void print_to_file(std::vector<double>& var_val_vec, std::string filename);
void write_to_file(std::string ata_filename, std::string atb_filename);
private:
void set_solve_matrix();
void set_solve_b();
void update_variables();
bool is_free(int id) { return (id < nb_free_variables_) ; }
bool is_locked(int id) { return (id >= nb_free_variables_) ; }
void print_f(std::vector<double>& xc_);
void print_equation_value(std::vector<double>& function_vec);
private:
// User representation
int nb_free_variables_ ;
int nb_locked_variables_ ;
std::vector<std::vector<std::pair<int, double> > > m_equation_vec;
std::vector<std::pair<int, double> > m_current_equ;
std::vector<double> m_right_b_vec;
std::vector<double> m_xc_;
private:
//std::auto_ptr<hj::sparse::solver> m_solver_;
CMeshSparseMatrix m_solve_matrix_AT_;
std::vector<double> m_solve_b_vec;
private:
bool factorize_state;
private:
std::vector<size_t> m_equ_div_flag_vec;
bool m_is_printf_info;
std::vector<std::pair<int, double> > m_tmp_current_equ;
std::vector<std::vector<std::pair<int, double> > > m_tmp_equation_vec;
};
#endif
| [
"[email protected]"
] | [
[
[
1,
88
]
]
] |
64eef1291add444e8c75b17b766f6107b57307b7 | bef7d0477a5cac485b4b3921a718394d5c2cf700 | /dingus/dingus/utils/CpuTimer.h | e4a2d04ca8ace49a618e3dc0f9a65fa8faf5253d | [
"MIT"
] | permissive | TomLeeLive/aras-p-dingus | ed91127790a604e0813cd4704acba742d3485400 | 22ef90c2bf01afd53c0b5b045f4dd0b59fe83009 | refs/heads/master | 2023-04-19T20:45:14.410448 | 2011-10-04T10:51:13 | 2011-10-04T10:51:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 866 | h | #ifndef __CPU_TIMER_H
#define __CPU_TIMER_H
#pragma once
namespace dingus {
/**
* Fast and accurate timer based on CPU ticks.
*
* However, the actual CPU speed varies on speed-step CPUs,
* so don't use it in production code (but it's great for timing
* when developing, and you're sure the CPU isn't speed-stepped).
*/
namespace cputimer
{
typedef __int64 ticks_type;
/// Returns the time in CPU ticks.
ticks_type ticks();
/// Returns the time in seconds.
double seconds();
/// Returns CPU speed in MHz.
int mhz();
/// Returns seconds per CPU tick.
double secsPerTick();
class debug_interval : public boost::noncopyable {
public:
debug_interval( const char* name );
~debug_interval();
private:
ticks_type mStartTicks;
const char* mName;
};
};
}; // namespace dingus
#endif
| [
"[email protected]"
] | [
[
[
1,
45
]
]
] |
6f9969cf148da43aaa0d9b2d609fd9a763c71c97 | c0bd82eb640d8594f2d2b76262566288676b8395 | /src/shared/Database/impl/PostgreDatabase.cpp | 8093923d2288c186bba19345de27d0591b59a1ed | [
"FSFUL"
] | permissive | vata/solution | 4c6551b9253d8f23ad5e72f4a96fc80e55e583c9 | 774fca057d12a906128f9231831ae2e10a947da6 | refs/heads/master | 2021-01-10T02:08:50.032837 | 2007-11-13T22:01:17 | 2007-11-13T22:01:17 | 45,352,930 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 8,042 | cpp | #include "../DatabaseEnv.h"
#ifdef DATABASE_SUPPORT_PGSQL
PostgreDatabase::PostgreDatabase() : Database(DATABASE_TYPE_PGSQL)
{
Connections = NULL;
InUseMarkers = NULL;
QueryBuffer = NULL;
mConnectionCount = -1; // Not connected.
mNextPing = getMSTime();
mQueryThread = NULL;
}
PostgreDatabase::~PostgreDatabase()
{
// Close connections..
for(int32 i = 0; i < mConnectionCount; ++i)
{
if(Connections)
if(Connections[i])
Disconnect(i);
delete [] QueryBuffer[i];
}
delete [] Connections;
delete [] InUseMarkers;
delete [] QueryBuffer;
delete [] DelayedQueryBuffer;
}
bool PostgreDatabase::Initialize(const char* Hostname, unsigned int port, const char* Username, const char* Password, const char* DatabaseName, uint32 ConnectionCount, uint32 BufferSize)
{
mConnectionCount = ConnectionCount;
// Build the connection string
stringstream ss;
ss << "host = " << Hostname << " port = " << port << " ";
ss << "user = '" << Username << "' ";
if(strlen(Password) > 0)
ss << "password = '" << Password << "' ";
ss << "dbname = '" << DatabaseName << "'";
mConnectionString = ss.str();
Connections = new PGconn*[mConnectionCount];
InUseMarkers = new bool[mConnectionCount];
QueryBuffer = new char*[mConnectionCount];
DelayedQueryBuffer = new char[BufferSize];
for(int i = 0; i < mConnectionCount; ++i)
{
Connections[i] = NULL;
InUseMarkers[i] = false;
QueryBuffer[i] = new char[BufferSize];
}
bool result = Connect();
if(!result) return false;
if(result && mConnectionCount > 1)
{
// Spawn MySQLDatabase thread
//ZThread::Thread t(new PostgreDatabaseThread(this));
//sLog.outString("sql: Spawned delayed MySQLDatabase query thread...");
}
return result;
}
bool PostgreDatabase::Connect()
{
sLog.outString("Connecting to PostgreSQL Database with [%s]", mConnectionString.c_str());
for(uint32 i = 0; i < mConnectionCount; ++i)
{
if(!Connect(i))
return false;
}
//sLog.outString("sql: %u MySQL connections established.", mConnectionCount);
return true;
}
bool PostgreDatabase::Connect(uint32 ConnectionIndex)
{
Connections[ConnectionIndex] = PQconnectdb(mConnectionString.c_str());
if(Connections[ConnectionIndex] == 0) return false;
if(PQstatus(Connections[ConnectionIndex]) != CONNECTION_OK)
{
// failed for some reason
sLog.outError("PostgreSQL connection failed: %s", PQerrorMessage(Connections[ConnectionIndex]));
// free the memory
Disconnect(ConnectionIndex);
return false;
}
return true;
}
bool PostgreDatabase::Disconnect(uint32 ConnectionIndex)
{
if(Connections[ConnectionIndex] == 0) return false;
PQfinish(Connections[ConnectionIndex]);
Connections[ConnectionIndex] = 0;
return true;
}
uint32 PostgreDatabase::GetConnection()
{
int32 index = -1;
while(index == -1)
{
for(uint32 i = 0; i < mConnectionCount; ++i)
{
if(Connections[i] && InUseMarkers[i] == false)
{
index = i;
break;
}
}
ZThread::Thread::sleep(5);
}
return index;
}
void PostgreDatabase::Shutdown()
{
sLog.outString("sql: Closing all PostgreSQL connections...");
for(uint32 i = 0; i < mConnectionCount; ++i)
Disconnect(i);
sLog.outString("sql: %u connections closed.", mConnectionCount);
}
PGresult * PostgreDatabase::SendQuery(uint32 ConnectionIndex, const char* Sql, bool Self)
{
PGresult * res = PQexec(Connections[ConnectionIndex], Sql);
return res;
}
QueryResult * PostgreDatabase::Query(const char* QueryString, ...)
{
if(QueryString == NULL) return NULL;
va_list vlist;
va_start(vlist, QueryString);
mSearchMutex.acquire();
// Find a free connection
uint32 i = GetConnection();
// Mark the connection as busy
InUseMarkers[i] = true;
mSearchMutex.release();
// Apply parameters
vsprintf(QueryBuffer[i], QueryString, vlist);
va_end(vlist);
// Send the query
PGresult * res = SendQuery(i, QueryBuffer[i], false);
InUseMarkers[i] = false;
// Get the error code
ExecStatusType result = PQresultStatus(res);
if(result != PGRES_TUPLES_OK)
{
sLog.outError("Query failed: %s", PQresultErrorMessage(res));
// command failed.
PQclear(res);
return 0;
}
// Better check the row count.. we don't want to return an empty query..
if(PQntuples(res) == 0)
{
// oh noes!
PQclear(res);
return 0;
}
// get number of columns
uint32 FieldCount = PQnfields(res);
// get number of rows
uint32 RowCount = PQntuples(res);
// Create the QueryResult
PostgreQueryResult * qResult = new PostgreQueryResult(res, FieldCount, RowCount);
return qResult;
}
bool PostgreDatabase::Execute(const char* QueryString, ...)
{
if(QueryString == NULL) return false;
va_list vlist;
va_start(vlist, QueryString);
if(mQueryThread == 0)
{
DelayedQueryBufferMutex.acquire();
vsprintf(DelayedQueryBuffer, QueryString, vlist);
bool res = WaitExecute(DelayedQueryBuffer);
DelayedQueryBufferMutex.release();
return res;
}
/*DelayedQueryBufferMutex.acquire();
vsprintf(DelayedQueryBuffer, QueryString, vlist);
mQueryThread->AddQuery(DelayedQueryBuffer);
DelayedQueryBufferMutex.release();*/
return false;
}
bool PostgreDatabase::WaitExecute(const char* QueryString, ...)
{
if(QueryString == NULL) return false;
va_list vlist;
va_start(vlist, QueryString);
mSearchMutex.acquire();
uint32 Connection = GetConnection();
InUseMarkers[Connection] = true;
mSearchMutex.release();
vsprintf(QueryBuffer[Connection], QueryString, vlist);
PGresult * res = SendQuery(Connection, QueryBuffer[Connection], false);
if(res == 0) return false;
InUseMarkers[Connection] = false;
ExecStatusType result = PQresultStatus(res);
bool passed = false;
if(result == PGRES_TUPLES_OK || result == PGRES_COMMAND_OK)
passed = true;
else
sLog.outError("Execute failed because of [%s]", PQresultErrorMessage(res));
// free up the memory
PQclear(res);
return passed;
}
PostgreQueryResult::PostgreQueryResult(PGresult * res, uint32 FieldCount, uint32 RowCount) : QueryResult(FieldCount, RowCount, DATABASE_TYPE_PGSQL)
{
// set result for later deletion and use
mResult = res;
// starting at row 0
mRow = 0;
// retreieve the data
NextRow();
}
PostgreQueryResult::~PostgreQueryResult()
{
}
void PostgreQueryResult::Destroy()
{
PQclear(mResult);
mResult = 0;
}
bool PostgreQueryResult::NextRow()
{
// check if we reached the end
if(mRow == mRowCount) return false;
// get each field and set it in result
char * value;
for(uint32 i = 0; i < mFieldCount; ++i)
{
value = PQgetvalue(mResult, mRow, i);
if(value == 0) return false;
mCurrentRow[i].SetValue(value);
}
mRow++;
return true;
}
void PostgreDatabase::CheckConnections()
{
// Check every 30 seconds (TODO: MAKE CUSTOMIZABLE)
if(getMSTime() < mNextPing)
return;
mNextPing = getMSTime() + 60000;
for(uint32 i = 0; i < mConnectionCount; ++i)
{
if(Connections[i] != 0 && PQstatus(Connections[i]) != CONNECTION_OK)
{
// disconnect and reconnect
Disconnect(i);
Connect(i);
}
}
}
#endif | [
"[email protected]"
] | [
[
[
1,
313
]
]
] |
67a7a2819aadcd489f62048ad3dadb66b4e84c26 | 3970f1a70df104f46443480d1ba86e246d8f3b22 | /imebra/src/imebra/include/dataCollection.h | 58b436b0429e00a6e011a2191a044e9dc6fb3b98 | [] | no_license | zhan2016/vimrid | 9f8ea8a6eb98153300e6f8c1264b2c042c23ee22 | 28ae31d57b77df883be3b869f6b64695df441edb | refs/heads/master | 2021-01-20T16:24:36.247136 | 2009-07-28T18:32:31 | 2009-07-28T18:32:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,448 | h | /*
0.0.46
Imebra: a C++ dicom library.
Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 by Paolo Brandoli
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE Version 3
as published by the Free Software Foundation.
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 AFFERO GENERAL PUBLIC LICENSE Version 3 for more details.
You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE Version 3
along with this program; If not, see http://www.gnu.org/licenses/
-------------------
If you want to use Imebra commercially then you have to buy the commercial
license available at http://puntoexe.com
After you buy the commercial license then you can use Imebra according
to the terms described in the Imebra Commercial License Version 1.
A copy of the Imebra Commercial License Version 1 is available in the
documentation pages.
Imebra is available at http://puntoexe.com
The author can be contacted by email at [email protected] or by mail at
the following address:
Paolo Brandoli
Preglov trg 6
1000 Ljubljana
Slovenia
*/
/*! \file dataCollection.h
\brief Declaration of the base class used by the dataSet and the dataGroup
classes.
*/
#if !defined(imebraDataCollection_22668C4B_A480_4f6e_B5DC_ADAD585444DA__INCLUDED_)
#define imebraDataCollection_22668C4B_A480_4f6e_B5DC_ADAD585444DA__INCLUDED_
#include "../../base/include/exception.h"
#include "data.h"
#include "charsetsList.h"
#include <map>
#include <string>
///////////////////////////////////////////////////////////
//
// Everything is in the namespace puntoexe::imebra
//
///////////////////////////////////////////////////////////
namespace puntoexe
{
namespace imebra
{
// The following classes are used in the declaration
class data;
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/// \brief This class accesses to all the %data stored
/// in a dataCollection derived class (dataGroup or
/// dataSet).
///
/// When retrieved from a dataSet this class accesses all
/// the groups (class dataGroup) in the dataSet, while
/// when retrieved from a dataGroup it accesses all the
/// tags (class data) in the dataGroup.
///
/// When retrieved the iterator references the first
/// data or dataGroup in the collection.
///
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
template <class collectionType>
class dataCollectionIterator: public baseObject
{
public:
dataCollectionIterator()
{
PUNTOEXE_FUNCTION_START(L"dataCollectionIterator::dataCollectionIterator");
m_iterator=m_collection.begin();
PUNTOEXE_FUNCTION_END();
}
/// \brief Increase the iterator so it references the next
/// data or dataGroup in the collection.
///
/// @return true if after the increment the iterator
/// references a valid data or dataGroup, or false
/// if after the increment the iterator references
/// the end of the collection (invalid data or
/// dataGroup)
///
///////////////////////////////////////////////////////////
bool incIterator()
{
PUNTOEXE_FUNCTION_START(L"dataCollectionIterator::incIterator");
if(isValid())
{
++m_iterator;
}
return isValid();
PUNTOEXE_FUNCTION_END();
}
/// \brief Reset the iterator so it referencesthe first
/// data or dataGroup in the collection.
///
/// @return true if after the reset the iterator references
/// to a valid data or dataGroup, or false if
/// after the reset the iterator references
/// the end of the collection (it means that the
/// collection is empty)
///
///////////////////////////////////////////////////////////
bool reset()
{
PUNTOEXE_FUNCTION_START(L"dataCollectionIterator::reset");
m_iterator=m_collection.begin();
return isValid();
PUNTOEXE_FUNCTION_END();
}
/// \brief Returns true if the iterator references a valid
/// data or dataGroup in the collection.
///
/// @return true if the iterator references a valid data or
/// dataGroup, or false if the iterator references
/// the end of the collection
///
///////////////////////////////////////////////////////////
bool isValid()
{
PUNTOEXE_FUNCTION_START(L"dataCollectionIterator::isValid");
return m_iterator!=m_collection.end();
PUNTOEXE_FUNCTION_END();
}
/// \brief Retrieve the data or dataGroup referenced by the
/// iterator.
///
/// This function returns 0 if the iterator references an
/// invalid data or dataGroup (isValid() returns false).
///
/// @return the data or dataGroup referenced by the
/// iterator
///
///////////////////////////////////////////////////////////
ptr<collectionType> getData()
{
PUNTOEXE_FUNCTION_START(L"dataCollectionIterator::getData");
ptr<collectionType> collection;
if(isValid())
{
collection = m_iterator->second;
}
return collection;
PUNTOEXE_FUNCTION_END();
}
/// \brief Return the id of the data or dataGroup
/// referenced by the iterator.
///
/// If the iterator references an invalid data or dataGroup
/// (isValid() returns false) then the function returns 0.
///
/// @return the id of the referenced data or dataGroup
///
///////////////////////////////////////////////////////////
imbxUint16 getId()
{
PUNTOEXE_FUNCTION_START(L"dataCollectionIterator::getId");
if(m_iterator==m_collection.end())
{
return 0;
}
return (imbxUint16)((m_iterator->first)>>16);
PUNTOEXE_FUNCTION_END();
}
/// \brief Retrieve the order of the referenced data or
/// dataGroup.
///
/// This function is used only while retrieving dataGroups
/// because there can be several groups with the same id;
/// in this case the function retrieve the order of
/// the dataGroup, that could be bigger than 0 when
/// several %data groups with the same id are stored in
/// the collection.
///
/// When used while retrieving the tags (class data) this
/// function always returns 0.
///
/// The function returns 0 also when used while the
/// iterator references an invalid dataGroup (isValid()
/// returns 0).
///
/// @return the dataGroup's order
///
///////////////////////////////////////////////////////////
imbxUint16 getOrder()
{
PUNTOEXE_FUNCTION_START(L"dataCollectionIterator::getOrder");
if(m_iterator==m_collection.end())
{
return 0;
}
return (imbxUint16)((m_iterator->first) & 0x0000ffff);
PUNTOEXE_FUNCTION_END();
}
public:
std::map<imbxUint32, ptr<collectionType> > m_collection;
typename std::map<imbxUint32, ptr<collectionType> >::iterator m_iterator;
};
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/// \brief This class stores a collection of Dicom tags or
/// groups (classes \ref puntoexe::imebra::data or
/// \ref puntoexe::imebra::dataGroup).
/// It is used as base class by dataGroup and
/// dataSet.
///
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
template <class collectionType>
class dataCollection : public baseObject
{
public:
dataCollection(ptr<baseObject> externalLock): baseObject(externalLock) {}
/// \internal
/// \brief Set the charsets used in the collection
///
/// The charsets contained in the list are copied in a
/// local list.
///
/// @param pCharsetsList a pointer to the list of charsets
/// used in the collection.
/// The list's content is copied in
/// a local list
///
///////////////////////////////////////////////////////////
virtual void setCharsetsList(charsetsList::tCharsetsList* pCharsetsList)
{
m_charsetsList.clear();
charsetsList::updateCharsets(pCharsetsList, &m_charsetsList);
for(
typename std::map<imbxUint32, ptr<collectionType> >::iterator dataIterator=m_collection.begin();
dataIterator!=m_collection.end();
++dataIterator)
{
dataIterator->second->setCharsetsList(pCharsetsList);
}
}
/// \internal
/// \brief Fill a list with the charsets used in the
/// collection.
///
/// Queries all the children objects (dataGroup or data)
/// for their charsets, update the local charsets list
/// and the list specified as a parameter.
///
/// @param pCharsetsList a pointer to the list that will
/// be filled with the used charsets
///
///////////////////////////////////////////////////////////
virtual void getCharsetsList(charsetsList::tCharsetsList* pCharsetsList)
{
m_charsetsList.clear();
for(
typename std::map<imbxUint32, ptr<collectionType> >::iterator dataIterator=m_collection.begin();
dataIterator!=m_collection.end();
++dataIterator)
{
charsetsList::tCharsetsList charsets;
dataIterator->second->getCharsetsList(&charsets);
charsetsList::updateCharsets(&charsets, &m_charsetsList);
}
charsetsList::copyCharsets(&m_charsetsList, pCharsetsList);
}
protected:
//
// In a dataGroup class returns the tag (ptr<data>with
// the specified ID, while in a dataSet class returns
// the group (ptr<dataGroup>) with the specified ID.
//
///////////////////////////////////////////////////////////
ptr<collectionType> getData(imbxUint16 dataId, imbxUint16 order)
{
PUNTOEXE_FUNCTION_START(L"dataCollection::getData");
lockObject lockAccess(this);
imbxUint32 dataUid = (((imbxUint32)dataId)<<16) | (imbxUint32)order;
ptr<collectionType> returnCollection;
typename std::map<imbxUint32, ptr<collectionType> >::iterator findCollection = m_collection.find(dataUid);
if(findCollection != m_collection.end())
{
returnCollection = findCollection->second;
}
return returnCollection;
PUNTOEXE_FUNCTION_END();
}
// Set the data (tag or group)
///////////////////////////////////////////////////////////
void setData(imbxUint16 dataId, imbxUint16 order, ptr<collectionType> pData)
{
PUNTOEXE_FUNCTION_START(L"dataCollection::setData");
lockObject lockAccess(this);
imbxUint32 dataUid = (((imbxUint32)dataId)<<16) | (imbxUint32)order;
m_collection[dataUid]=pData;
pData->setCharsetsList(&m_charsetsList);
PUNTOEXE_FUNCTION_END();
}
public:
/// \brief Return an iterator pointing to the first tag or
/// group (data or dataGroup) in the collection.
///
/// You can use this function to scan all the tags (data)
/// in a dataGroup or all the groups (dataGroup) in a
/// dataSet.
///
/// See dataCollectionIterator for more information.
///
/// @return an iterator that accesses all the %data in
/// the collection
///
///////////////////////////////////////////////////////////
ptr<dataCollectionIterator<collectionType> > getDataIterator()
{
PUNTOEXE_FUNCTION_START(L"dataCollection::getDataIterator");
lockObject lockAccess(this);
ptr<dataCollectionIterator<collectionType> > pIterator(new dataCollectionIterator<collectionType>);
for(
typename std::map<imbxUint32, ptr<collectionType> >::iterator dataIterator=m_collection.begin();
dataIterator!=m_collection.end();
++dataIterator)
{
pIterator->m_collection[dataIterator->first]=dataIterator->second;
}
pIterator->reset();
return pIterator;
PUNTOEXE_FUNCTION_END();
}
protected:
// Stored data (tags or groups)
///////////////////////////////////////////////////////////
std::map<imbxUint32, ptr<collectionType> > m_collection;
charsetsList::tCharsetsList m_charsetsList;
};
} // namespace imebra
} // namespace puntoexe
#endif // !defined(imebraDataCollection_22668C4B_A480_4f6e_B5DC_ADAD585444DA__INCLUDED_)
| [
"[email protected]"
] | [
[
[
1,
418
]
]
] |
6dc8ef109b137842263b428c5d8516f1d272a556 | f90b1358325d5a4cfbc25fa6cccea56cbc40410c | /include/proteomeInfo.h | ae47b39d23f61be1a6781ec40c02bdff04702ad4 | [] | no_license | ipodyaco/prorata | bd52105499c3fad25781d91952def89a9079b864 | 1f17015d304f204bd5f72b92d711a02490527fe6 | refs/heads/master | 2021-01-10T09:48:25.454887 | 2010-05-11T19:19:40 | 2010-05-11T19:19:40 | 48,766,766 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,153 | h |
#ifndef PROTEOMEINFO_H
#define PROTEOMEINFO_H
//#define DEBUG
#include <vector>
#include <iostream>
#include <string>
#include <iterator>
#include <iomanip>
#include <fstream>
#include "peptideInfo.h"
#include "proteinInfo.h"
#include "peptideRatio.h"
#include "proteinRatio.h"
#include "directoryStructure.h"
#include "proRataConfig.h"
#include "tinyxml.h"
using namespace std;
class ProteomeInfo
{
public:
ProteomeInfo();
~ProteomeInfo();
bool processPeptidesXIC();
bool processProteins();
bool readFileQPR( string sFilename );
bool writeFileQPR();
bool writeFileTAB();
bool getProteinRatio( ProteinInfo * queryProteinInfo, ProteinRatio * queryProteinRatio );
bool getPeptideRatio( PeptideInfo * queryPeptideInfo, PeptideRatio * queryPeptideRatio );
// retrieve ProteinInfo by searching Keyword in both Locus and Description
vector< ProteinInfo * > getProteinInfo( string sKeyword );
// retrieve ProteinInfo by searching Locus, require exact match
vector< ProteinInfo * > getProteinInfo4Locus( string sLocus );
// retrieve Locus list
void getLocusList( vector< string > & vsLocusListRef );
void getLocusDescriptionList( vector< string > & vsLocusListRef, vector< string > & vsDescriptionRef);
// these two sorting methods sort in the ascending order
void sortProteinInfo( vector< ProteinInfo * > & vpProteinInfoInput, string sKey );
void sortPeptideInfo( vector< PeptideInfo * > & vpPeptideInfoInput, string sKey );
// these two sorting method sort in the descending order
void sortProteinInfoDescending( vector< ProteinInfo * > & vpProteinInfoInput, string sKey );
void sortPeptideInfoDescending( vector< PeptideInfo * > & vpPeptideInfoInput, string sKey );
private:
void addPeptideInfo( PeptideInfo * pCurrentPeptideInfo );
vector< ProteinInfo * > vpProteinInfo;
vector< PeptideInfo * > vpPeptideInfo;
string getValue( TiXmlElement * pElement, const vector<string> &vsTagList );
vector< TiXmlElement * > getElement( TiXmlElement * pElement, const vector<string> &vsTagList );
};
#endif //PROTEOMEINFO_H
| [
"chongle.pan@c58cc1ec-c975-bb1e-ac29-6983d7497d3a"
] | [
[
[
1,
66
]
]
] |
1a00319d21fb9d2bb5b1729330a57114dad1bbe7 | c2abb873c8b352d0ec47757031e4a18b9190556e | /src/MyGUIEngine/src/MyGUI_List.cpp | 4ca3a21c83efa99548d54a56d05e6b55451f8208 | [] | no_license | twktheainur/vortex-ee | 70b89ec097cd1c74cde2b75f556448965d0d345d | 8b8aef42396cbb4c9ce063dd1ab2f44d95e994c6 | refs/heads/master | 2021-01-10T02:26:21.913972 | 2009-01-30T12:53:21 | 2009-01-30T12:53:21 | 44,046,528 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 23,754 | cpp | /*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
#include "MyGUI_Prerequest.h"
#include "MyGUI_Common.h"
#include "MyGUI_CastWidget.h"
#include "MyGUI_List.h"
#include "MyGUI_Button.h"
#include "MyGUI_VScroll.h"
#include "MyGUI_WidgetOIS.h"
#include "MyGUI_WidgetSkinInfo.h"
namespace MyGUI
{
Ogre::String List::WidgetTypeName = "List";
List::List(const IntCoord& _coord, Align _align, const WidgetSkinInfoPtr _info, CroppedRectanglePtr _parent, WidgetCreator * _creator, const Ogre::String & _name) :
Widget(_coord, _align, _info, _parent, _creator, _name),
mWidgetScroll(null),
//mWidgetClient(null),
mTopIndex(0),
mOffsetTop(0),
mRangeIndex(-1),
mLastRedrawLine(0),
mIndexSelect(ITEM_NONE),
mLineActive(ITEM_NONE),
mIsFocus(false),
mNeedVisibleScroll(true)
{
// нам нужен фокус клавы
mNeedKeyFocus = true;
for (VectorWidgetPtr::iterator iter=mWidgetChild.begin(); iter!=mWidgetChild.end(); ++iter) {
if ((*iter)->_getInternalString() == "VScroll") {
mWidgetScroll = castWidget<VScroll>(*iter);
mWidgetScroll->eventScrollChangePosition = newDelegate(this, &List::notifyScrollChangePosition);
mWidgetScroll->eventMouseButtonPressed = newDelegate(this, &List::notifyMousePressed);
}
else if ((*iter)->_getInternalString() == "Client") {
mWidgetClient = (*iter);
mWidgetClient->eventMouseButtonPressed = newDelegate(this, &List::notifyMousePressed);
}
}
MYGUI_ASSERT(null != mWidgetScroll, "Child VScroll not found in skin (List must have VScroll)");
MYGUI_ASSERT(null != mWidgetClient, "Child Widget Client not found in skin (List must have Client)");
// парсим свойства
const MapString & param = _info->getParams();
MapString::const_iterator iterS = param.find("SkinLine");
if (iterS != param.end()) mSkinLine = iterS->second;
MYGUI_ASSERT(false == mSkinLine.empty(), "SkinLine property or skin not found (List must have SkinLine property)");
iterS = param.find("HeightLine");
if (iterS != param.end()) mHeightLine = utility::parseInt(iterS->second);
if (mHeightLine < 1) mHeightLine = 1;
mWidgetScroll->setScrollPage((size_t)mHeightLine);
mWidgetScroll->setScrollViewPage((size_t)mHeightLine);
updateScroll();
updateLine();
}
void List::_onMouseWheel(int _rel)
{
notifyMouseWheel(null, _rel);
// !!! ОБЯЗАТЕЛЬНО вызывать в конце метода
Widget::_onMouseWheel(_rel);
}
void List::_onKeySetFocus(WidgetPtr _old)
{
mIsFocus = true;
_updateState();
// !!! ОБЯЗАТЕЛЬНО вызывать в конце метода
Widget::_onKeySetFocus(_old);
}
void List::_onKeyLostFocus(WidgetPtr _new)
{
mIsFocus = false;
_updateState();
// !!! ОБЯЗАТЕЛЬНО вызывать в конце метода
Widget::_onKeyLostFocus(_new);
}
void List::_onKeyButtonPressed(KeyCode _key, Char _char)
{
// очень секретный метод, запатентованный механизм движения курсора
if (getItemCount() == 0) {
// !!! ОБЯЗАТЕЛЬНО вызывать в конце метода
Widget::_onKeyButtonPressed(_key, _char);
return;
}
size_t sel = mIndexSelect;
if (_key == KC_UP) {
if (sel != 0) {
if (sel == ITEM_NONE) sel = 0;
else sel --;
}
} else if (_key == KC_DOWN) {
if (sel == ITEM_NONE) sel = 0;
else sel ++;
if (sel >= getItemCount()) {
// старое значение
sel = mIndexSelect;
}
} else if (_key == KC_HOME) {
if (sel != 0) sel = 0;
} else if (_key == KC_END) {
if (sel != (getItemCount() - 1)) {
sel = getItemCount() - 1;
}
} else if (_key == KC_PGUP) {
if (sel != 0) {
if (sel == ITEM_NONE) sel = 0;
else {
size_t page = mWidgetClient->getHeight() / mHeightLine;
if (sel <= page) sel = 0;
else sel -= page;
}
}
} else if (_key == KC_PGDOWN) {
if (sel != (getItemCount() - 1)) {
if (sel == ITEM_NONE) sel = 0;
else {
sel += mWidgetClient->getHeight() / mHeightLine;
if (sel >= getItemCount()) sel = getItemCount() - 1;
}
}
} else if ((_key == KC_RETURN) || (_key == KC_NUMPADENTER)) {
if (sel != ITEM_NONE) {
eventListSelectAccept(this, sel);
Widget::_onKeyButtonPressed(_key, _char);
// выходим, так как изменили колличество строк
return;
}
}
if (sel != mIndexSelect) {
if ( false == isItemVisible(sel)) {
beginToIndex(sel);
_sendEventChangeScroll(mWidgetScroll->getScrollPosition());
}
setItemSelect(sel);
// изменилась позиция
eventListChangePosition(this, mIndexSelect);
}
// !!! ОБЯЗАТЕЛЬНО вызывать в конце метода
Widget::_onKeyButtonPressed(_key, _char);
}
void List::notifyMouseWheel(WidgetPtr _sender, int _rel)
{
if (mRangeIndex <= 0) return;
int offset = (int)mWidgetScroll->getScrollPosition();
if (_rel < 0) offset += mHeightLine;
else offset -= mHeightLine;
if (offset >= mRangeIndex) offset = mRangeIndex;
else if (offset < 0) offset = 0;
if ((int)mWidgetScroll->getScrollPosition() == offset) return;
mWidgetScroll->setScrollPosition(offset);
_setScrollView(offset);
_sendEventChangeScroll(offset);
}
void List::notifyScrollChangePosition(WidgetPtr _sender, size_t _position)
{
_setScrollView(_position);
_sendEventChangeScroll(_position);
}
void List::notifyMousePressed(WidgetPtr _sender, int _left, int _top, MouseButton _id)
{
if (MB_Left != _id) return;
if (_sender == mWidgetScroll) return;
// если выделен клиент, то сбрасываем
if (_sender == mWidgetClient) {
if (mIndexSelect != ITEM_NONE) {
_selectIndex(mIndexSelect, false);
mIndexSelect = ITEM_NONE;
eventListChangePosition(this, mIndexSelect);
}
eventListMouseItemActivate(this, mIndexSelect);
// если не клиент, то просчитывам
} else {
size_t index = (size_t)_sender->_getInternalData() + mTopIndex;
if (mIndexSelect != index) {
_selectIndex(mIndexSelect, false);
_selectIndex(index, true);
mIndexSelect = index;
eventListChangePosition(this, mIndexSelect);
}
eventListMouseItemActivate(this, mIndexSelect);
}
}
void List::notifyMouseDoubleClick(WidgetPtr _sender)
{
if (mIndexSelect != ITEM_NONE)
eventListSelectAccept(this, mIndexSelect);
}
void List::setSize(const IntSize& _size)
{
Widget::setSize(_size);
updateScroll();
updateLine();
}
void List::setPosition(const IntCoord& _coord)
{
Widget::setPosition(_coord);
updateScroll();
updateLine();
}
void List::updateScroll()
{
mRangeIndex = (mHeightLine * (int)mStringArray.size()) - mWidgetClient->getHeight();
if ( (false == mNeedVisibleScroll) || (mRangeIndex < 1) || (mWidgetScroll->getLeft() <= mWidgetClient->getLeft()) )
{
if (mWidgetScroll->isShow()) {
mWidgetScroll->hide();
// увеличиваем клиентскую зону на ширину скрола
mWidgetClient->setSize(mWidgetClient->getWidth() + mWidgetScroll->getWidth(), mWidgetClient->getHeight());
}
}
else if (false == mWidgetScroll->isShow())
{
mWidgetClient->setSize(mWidgetClient->getWidth() - mWidgetScroll->getWidth(), mWidgetClient->getHeight());
mWidgetScroll->show();
}
mWidgetScroll->setScrollRange(mRangeIndex + 1);
if ((int)mStringArray.size()) mWidgetScroll->setTrackSize( mWidgetScroll->getLineSize() * mWidgetClient->getHeight() / mHeightLine / (int)mStringArray.size() );
}
void List::updateLine(bool _reset)
{
// сбрасываем
if (_reset) {
mOldSize.clear();
mLastRedrawLine = 0;
}
// позиция скролла
int position = mTopIndex * mHeightLine + mOffsetTop;
// если высота увеличивалась то добавляем виджеты
if (mOldSize.height < mCoord.height) {
int height = (int)mWidgetLines.size() * mHeightLine - mOffsetTop;
// до тех пор, пока не достигнем максимального колличества, и всегда на одну больше
while ( (height <= (mWidgetClient->getHeight() + mHeightLine)) && (mWidgetLines.size() < mStringArray.size()) ) {
// создаем линию
WidgetPtr line = mWidgetClient->createWidgetT("Button", mSkinLine, 0, height, mWidgetClient->getWidth(), mHeightLine, ALIGN_TOP | ALIGN_HSTRETCH);
// подписываемся на всякие там события
line->eventMouseButtonPressed = newDelegate(this, &List::notifyMousePressed);
line->eventMouseButtonDoubleClick = newDelegate(this, &List::notifyMouseDoubleClick);
line->eventMouseWheel = newDelegate(this, &List::notifyMouseWheel);
line->eventMouseSetFocus = newDelegate(this, &List::notifyMouseSetFocus);
line->eventMouseLostFocus = newDelegate(this, &List::notifyMouseLostFocus);
// присваиваем порядковый номер, длу простоты просчета
line->_setInternalData((int)mWidgetLines.size());
// и сохраняем
mWidgetLines.push_back(line);
height += mHeightLine;
};
// проверяем на возможность не менять положение списка
if (position >= mRangeIndex) {
// размер всех помещается в клиент
if (mRangeIndex <= 0) {
// обнуляем, если надо
if (position || mOffsetTop || mTopIndex) {
position = 0;
mTopIndex = 0;
mOffsetTop = 0;
mLastRedrawLine = 0; // чтобы все перерисовалось
// выравниваем
int offset = 0;
for (size_t pos=0; pos<mWidgetLines.size(); pos++) {
mWidgetLines[pos]->setPosition(0, offset);
offset += mHeightLine;
}
}
} else {
// прижимаем список к нижней границе
int count = mWidgetClient->getHeight() / mHeightLine;
mOffsetTop = mHeightLine - (mWidgetClient->getHeight() % mHeightLine);
if (mOffsetTop == mHeightLine) {
mOffsetTop = 0;
count --;
}
int top = (int)mStringArray.size() - count - 1;
// выравниваем
int offset = 0 - mOffsetTop;
for (size_t pos=0; pos<mWidgetLines.size(); pos++) {
mWidgetLines[pos]->setPosition(0, offset);
offset += mHeightLine;
}
// высчитываем положение, должно быть максимальным
position = top * mHeightLine + mOffsetTop;
// если индех изменился, то перерисовываем линии
if (top != mTopIndex) {
mTopIndex = top;
_redrawItemRange();
}
}
}
// увеличился размер, но прокрутки вниз небыло, обновляем линии снизу
_redrawItemRange(mLastRedrawLine);
} // if (old_cy < mCoord.height)
// просчитываем положение скролла
mWidgetScroll->setScrollPosition(position);
mOldSize.width = mCoord.width;
mOldSize.height = mCoord.height;
}
void List::_redrawItemRange(size_t _start)
{
// перерисовываем линии, только те, что видны
size_t pos = _start;
for (; pos<mWidgetLines.size(); pos++) {
// индекс в нашем массиве
size_t index = pos + (size_t)mTopIndex;
// не будем заходить слишком далеко
if (index >= mStringArray.size()) {
// запоминаем последнюю перерисованную линию
mLastRedrawLine = pos;
break;
}
if (mWidgetLines[pos]->getTop() > mWidgetClient->getHeight()) {
// запоминаем последнюю перерисованную линию
mLastRedrawLine = pos;
break;
}
// если был скрыт, то покажем
if (false == mWidgetLines[pos]->isShow()) mWidgetLines[pos]->show();
// обновляем текст
mWidgetLines[pos]->setCaption(mStringArray[index]);
// если нужно выделить ,то выделим
if (index == mIndexSelect) {
if (!static_cast<ButtonPtr>(mWidgetLines[pos])->getButtonPressed())
static_cast<ButtonPtr>(mWidgetLines[pos])->setButtonPressed(true);
} else {
if (static_cast<ButtonPtr>(mWidgetLines[pos])->getButtonPressed())
static_cast<ButtonPtr>(mWidgetLines[pos])->setButtonPressed(false);
}
}
// если цикл весь прошли, то ставим максимальную линию
if (pos >= mWidgetLines.size()) mLastRedrawLine = pos;
}
// перерисовывает индекс
void List::_redrawItem(size_t _index)
{
// невидно
if (_index < (size_t)mTopIndex) return;
_index -= (size_t)mTopIndex;
// тоже невидно
if (_index >= mLastRedrawLine) return;
MYGUI_DEBUG_ASSERT(_index < mWidgetLines.size(), "index out range");
// перерисовываем
mWidgetLines[_index]->setCaption(mStringArray[_index + mTopIndex]);
}
void List::insertItem(size_t _index, const Ogre::UTFString & _item)
{
if (_index > mStringArray.size()) _index = mStringArray.size();
// вставляем физически
_insertString(_index, _item);
// если надо, то меняем выделенный элемент
if ( (mIndexSelect != ITEM_NONE) && (_index <= mIndexSelect) ) mIndexSelect++;
// строка, до первого видимого элемента
if ( (_index <= (size_t)mTopIndex) && (mRangeIndex > 0) ) {
mTopIndex ++;
// просчитываем положение скролла
mWidgetScroll->setScrollRange(mWidgetScroll->getScrollRange() + mHeightLine);
if ((int)mStringArray.size()) mWidgetScroll->setTrackSize( mWidgetScroll->getLineSize() * mWidgetClient->getHeight() / mHeightLine / (int)mStringArray.size() );
mWidgetScroll->setScrollPosition(mTopIndex * mHeightLine + mOffsetTop);
mRangeIndex += mHeightLine;
} else {
// высчитывам положение строки
int offset = ((int)_index - mTopIndex) * mHeightLine - mOffsetTop;
// строка, после последнего видимого элемента, плюс одна строка (потому что для прокрутки нужно на одну строчку больше)
if (mWidgetClient->getHeight() < (offset - mHeightLine)) {
// просчитываем положение скролла
mWidgetScroll->setScrollRange(mWidgetScroll->getScrollRange() + mHeightLine);
if ((int)mStringArray.size()) mWidgetScroll->setTrackSize( mWidgetScroll->getLineSize() * mWidgetClient->getHeight() / mHeightLine / (int)mStringArray.size() );
mWidgetScroll->setScrollPosition(mTopIndex * mHeightLine + mOffsetTop);
mRangeIndex += mHeightLine;
// строка в видимой области
} else {
// обновляем все
updateScroll();
updateLine(true);
// позже сюда еще оптимизацию по колличеству перерисовок
}
}
}
void List::deleteItem(size_t _index)
{
// доверяй, но проверяй
MYGUI_ASSERT(_index < mStringArray.size(), "deleteItemString: index '" << _index << "' out of range");
// удяляем физически строку
_deleteString(_index);
// если надо, то меняем выделенный элемент
if (mStringArray.empty()) mIndexSelect = ITEM_NONE;
else if (mIndexSelect != ITEM_NONE) {
if (_index < mIndexSelect) mIndexSelect--;
else if ( (_index == mIndexSelect) && (mIndexSelect == (mStringArray.size())) ) mIndexSelect--;
}
// если виджетов стало больше , то скрываем крайний
if (mWidgetLines.size() > mStringArray.size()) {
mWidgetLines[mStringArray.size()]->hide();
}
// строка, до первого видимого элемента
if (_index < (size_t)mTopIndex) {
mTopIndex --;
// просчитываем положение скролла
mWidgetScroll->setScrollRange(mWidgetScroll->getScrollRange() - mHeightLine);
if ((int)mStringArray.size()) mWidgetScroll->setTrackSize( mWidgetScroll->getLineSize() * mWidgetClient->getHeight() / mHeightLine / (int)mStringArray.size() );
mWidgetScroll->setScrollPosition(mTopIndex * mHeightLine + mOffsetTop);
mRangeIndex -= mHeightLine;
} else {
// высчитывам положение удаляемой строки
int offset = ((int)_index - mTopIndex) * mHeightLine - mOffsetTop;
// строка, после последнего видимого элемента
if (mWidgetClient->getHeight() < offset) {
// просчитываем положение скролла
mWidgetScroll->setScrollRange(mWidgetScroll->getScrollRange() - mHeightLine);
if ((int)mStringArray.size()) mWidgetScroll->setTrackSize( mWidgetScroll->getLineSize() * mWidgetClient->getHeight() / mHeightLine / (int)mStringArray.size() );
mWidgetScroll->setScrollPosition(mTopIndex * mHeightLine + mOffsetTop);
mRangeIndex -= mHeightLine;
// строка в видимой области
} else {
// обновляем все
updateScroll();
updateLine(true);
// позже сюда еще оптимизацию по колличеству перерисовок
}
}
}
void List::_deleteString(size_t _index)
{
for (size_t pos=_index+1; pos<mStringArray.size(); pos++) {
mStringArray[pos-1] = mStringArray[pos];
}
mStringArray.pop_back();
}
void List::_insertString(size_t _index, const Ogre::UTFString & _item)
{
mStringArray.push_back("");
for (size_t pos=mStringArray.size()-1; pos > _index; pos--) {
mStringArray[pos] = mStringArray[pos-1];
}
mStringArray[_index] = _item;
}
void List::setItemSelect(size_t _index)
{
if (mIndexSelect == _index) return;
_selectIndex(mIndexSelect, false);
_selectIndex(_index, true);
mIndexSelect = _index;
}
void List::_selectIndex(size_t _index, bool _select)
{
if (_index >= mStringArray.size()) return;
// не видно строки
if (_index < (size_t)mTopIndex) return;
// высчитывам положение строки
int offset = ((int)_index - mTopIndex) * mHeightLine - mOffsetTop;
// строка, после последнего видимого элемента
if (mWidgetClient->getHeight() < offset) return;
static_cast<ButtonPtr>(mWidgetLines[_index-mTopIndex])->setButtonPressed(_select);
}
void List::beginToIndex(size_t _index)
{
if (_index >= mStringArray.size()) return;
if (mRangeIndex <= 0) return;
int offset = (int)_index * mHeightLine;
if (offset >= mRangeIndex) offset = mRangeIndex;
if ((int)mWidgetScroll->getScrollPosition() == offset) return;
mWidgetScroll->setScrollPosition(offset);
notifyScrollChangePosition(null, offset);
}
// видим ли мы элемент, полностью или нет
bool List::isItemVisible(size_t _index, bool _fill)
{
// если элемента нет, то мы его не видим (в том числе когда их вообще нет)
if (_index >= mStringArray.size()) return false;
// если скрола нет, то мы палюбак видим
if (mRangeIndex <= 0) return true;
// строка, до первого видимого элемента
if (_index < (size_t)mTopIndex) return false;
// строка это верхний выделенный
if (_index == (size_t)mTopIndex) {
if ( (mOffsetTop != 0) && (_fill) ) return false; // нам нужна полностью видимость
return true;
}
// высчитывам положение строки
int offset = ((int)_index - mTopIndex) * mHeightLine - mOffsetTop;
// строка, после последнего видимого элемента
if (mWidgetClient->getHeight() < offset) return false;
// если мы внизу и нам нужен целый
if ((mWidgetClient->getHeight() < (offset + mHeightLine)) && (_fill) ) return false;
return true;
}
void List::deleteAllItems()
{
mTopIndex = 0;
mIndexSelect = ITEM_NONE;
mOffsetTop = 0;
mStringArray.clear();
for (size_t pos=0; pos<mWidgetLines.size(); pos++)
mWidgetLines[pos]->hide();
// обновляем все
updateScroll();
updateLine(true);
}
void List::setItem(size_t _index, const Ogre::UTFString & _item)
{
MYGUI_ASSERT(_index < mStringArray.size(), "setItemString: index " << _index <<" out of range");
mStringArray[_index]=_item;
_redrawItem(_index);
}
const Ogre::UTFString & List::getItem(size_t _index)
{
MYGUI_ASSERT(_index < mStringArray.size(), "getItemString: index " << _index <<" out of range");
return mStringArray[_index];
}
size_t List::findItem(const Ogre::UTFString & _item)
{
//std::find(mStringArray.begin(), mStringArray.end(), _item);
for (size_t pos=0; pos<mStringArray.size(); pos++) {
if (_item == mStringArray[pos]) return pos;
}
return ITEM_NONE;
}
void List::notifyMouseSetFocus(WidgetPtr _sender, WidgetPtr _old)
{
mLineActive = _sender->_getInternalData();
eventListMouseItemFocus(this, mLineActive + (size_t)mTopIndex);
}
void List::notifyMouseLostFocus(WidgetPtr _sender, WidgetPtr _new)
{
if ((null == _new) || (_new->getParent() != mWidgetClient)) {
mLineActive = ITEM_NONE;
eventListMouseItemFocus(this, ITEM_NONE);
}
}
void List::_setItemFocus(size_t _position, bool _focus)
{
size_t index = (_position - mTopIndex);
if (index < mWidgetLines.size())
static_cast<ButtonPtr>(mWidgetLines[index])->_setMouseFocus(_focus);
}
void List::setScrollVisible(bool _visible)
{
if (mNeedVisibleScroll == _visible) return;
mNeedVisibleScroll = _visible;
updateScroll();
}
void List::setScrollPosition(size_t _position)
{
if (mWidgetScroll->getScrollRange() > _position) {
mWidgetScroll->setScrollPosition(_position);
_setScrollView(_position);
}
}
void List::_setScrollView(size_t _position)
{
mOffsetTop = ((int)_position % mHeightLine);
// смещение с отрицательной стороны
int offset = 0 - mOffsetTop;
for (size_t pos=0; pos<mWidgetLines.size(); pos++) {
mWidgetLines[pos]->setPosition(IntPoint(0, offset));
offset += mHeightLine;
}
// если индех изменился, то перерисовываем линии
int top = ((int)_position / mHeightLine);
if (top != mTopIndex) {
mTopIndex = top;
_redrawItemRange();
}
// прорисовываем все нижние строки, если они появились
_redrawItemRange(mLastRedrawLine);
}
void List::_sendEventChangeScroll(size_t _position)
{
eventListChangeScroll(this, _position);
if (ITEM_NONE != mLineActive) eventListMouseItemFocus(this, mLineActive + (size_t)mTopIndex);
}
} // namespace MyGUI
| [
"twk.theainur@37e2baaa-b253-11dd-9381-bf584fb1fa83"
] | [
[
[
1,
711
]
]
] |
a547f90322635e2e88893411a29cc6354aa8ceb8 | 5236606f2e6fb870fa7c41492327f3f8b0fa38dc | /srpc/test/stdafx.cpp | 358cf7384a0e86115962f5a08e51e318a6fa936a | [] | no_license | jcloudpld/srpc | aa8ecf4ffc5391b7183b19d217f49fb2b1a67c88 | f2483c8177d03834552053e8ecbe788e15b92ac0 | refs/heads/master | 2021-01-10T08:54:57.140800 | 2010-02-08T07:03:00 | 2010-02-08T07:03:00 | 44,454,693 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 204 | cpp | // stdafx.cpp : source file that includes just the standard includes
// srpcTest.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
| [
"kcando@6d7ccee0-1a3b-0410-bfa1-83648d9ec9a4"
] | [
[
[
1,
5
]
]
] |
4cd1225899c1cb07cd67e880a0565bcbd8b4cc2b | 444a151706abb7bbc8abeb1f2194a768ed03f171 | /trunk/ENIGMAsystem/SHELL/Graphics_Systems/OpenGLES/GSenable.cpp | 6b3819f5e3893ce332ee31fe1fdf318bfb315898 | [] | no_license | amorri40/Enigma-Game-Maker | 9d01f70ab8de42f7c80af9a0f8c7a66e412d19d6 | c6b701201b6037f2eb57c6938c184a5d4ba917cf | refs/heads/master | 2021-01-15T11:48:39.834788 | 2011-11-22T04:09:28 | 2011-11-22T04:09:28 | 1,855,342 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,516 | cpp | /********************************************************************************\
** **
** Copyright (C) 2008 Josh Ventura **
** Copyright (C) 2011 Alasdair Morrison **
** **
** This file is a part of the ENIGMA Development Environment. **
** **
** **
** ENIGMA 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, version 3 of the license or any later version. **
** **
** This application and its source code is distributed AS-IS, 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 recieved a copy of the GNU General Public License along **
** with this code. If not, see <http://www.gnu.org/licenses/> **
** **
** ENIGMA is an environment designed to create games and other programs with a **
** high-level, fully compilable language. Developers of ENIGMA or anything **
** associated with ENIGMA are in no way responsible for its users or **
** applications created by its users, or damages caused by the environment **
** or programs made in the environment. **
** **
\********************************************************************************/
#include "OpenGLHeaders.h"
int gs_enable_alpha(bool enable){
(enable?glEnable:glDisable)(GL_ALPHA_TEST);
return 0;
}//If enabled, do alpha testing. See glAlphaFunc.
int gs_enable_blending(bool enable){
(enable?glEnable:glDisable)(GL_BLEND);
return 0;
}//If enabled, blend the incoming RGBA color values with the values in the color buffers. See glBlendFunc.
int gs_enable_depthbuffer(bool enable){
(enable?glEnable:glDisable)(GL_DEPTH_TEST);
return 0;
}//If enabled, do depth comparisons and update the depth buffer. See glDepthFunc and glDepthRange.
int gs_enable_dither(bool enable){
(enable?glEnable:glDisable)(GL_DITHER);
return 0;
}//If enabled, dither color components or indexes before they are written to the color buffer.
int gs_enable_smooth_lines(bool enable){
(enable?glEnable:glDisable)(GL_LINE_SMOOTH);
return 0;
}//If enabled, draw lines with correct filtering. If disabled, draw aliased lines. See glLineWidth.
int gs_enable_stipple(bool enable){
// Opengles does not have line stipple
// Could texture the line with alpha to produce a similar effect
return 0;
}//If enabled, use the current polygon stipple pattern when rendering polygons. See glPolygonStipple.
int gs_enable_logical_op(bool enable){
(enable?glEnable:glDisable)(GL_COLOR_LOGIC_OP); //changed for OPENGLES
return 0;
}//If enabled, apply the currently selected logical operation to the incoming and color-buffer indexes. See glLogicOp.
int gs_enable_smooth_points(bool enable){
(enable?glEnable:glDisable)(GL_POINT_SMOOTH);
return 0;
}//If enabled, draw points with proper filtering. If disabled, draw aliased points. See glPointSize.
int gs_enable_smooth_polygons(bool enable){
//(enable?glEnable:glDisable)(GL_POLYGON_SMOOTH); removed for OPENGLES
return 0;
}//If enabled, draw polygons with proper filtering. If disabled, draw aliased polygons. See glPolygonMode.
int gs_enable_stencil(bool enable){
(enable?glEnable:glDisable)(GL_STENCIL_TEST);
return 0;
}//If enabled, do stencil testing and update the stencil buffer. See glStencilFunc and glStencilOp.
int gs_enable_texture(bool enable){
(enable?glEnable:glDisable)(GL_TEXTURE_2D);
return 0;
}//If enabled, textures
| [
"[email protected]"
] | [
[
[
1,
85
]
]
] |
2732537126d6c006c02298755cffd0389e5d2219 | ef23e388061a637f82b815d32f7af8cb60c5bb1f | /src/emu/video/msm6255.h | 545e54beba6c7e9c973a14ed1378a5dd5a194475 | [] | 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 | 3,731 | h | /**********************************************************************
OKI MSM6255 Dot Matrix LCD Controller implementation
Copyright MESS Team.
Visit http://mamedev.org for licensing and usage restrictions.
**********************************************************************/
#pragma once
#ifndef __MSM6255__
#define __MSM6255__
#include "emu.h"
///*************************************************************************
// INTERFACE CONFIGURATION MACROS
///*************************************************************************
#define MCFG_MSM6255_ADD(_tag, _clock, _config) \
MCFG_DEVICE_ADD(_tag, MSM6255, _clock) \
MCFG_DEVICE_CONFIG(_config)
#define MSM6255_INTERFACE(name) \
const msm6255_interface (name) =
#define MSM6255_CHAR_RAM_READ(_name) \
UINT8 _name(device_t *device, UINT16 ma, UINT8 ra)
///*************************************************************************
// TYPE DEFINITIONS
///*************************************************************************
// ======================> msm6255_char_ram_read_func
typedef UINT8 (*msm6255_char_ram_read_func)(device_t *device, UINT16 ma, UINT8 ra);
// ======================> msm6255_interface
struct msm6255_interface
{
const char *m_screen_tag;
int m_character_clock;
// ROM/RAM data read function
msm6255_char_ram_read_func m_char_ram_r;
};
// ======================> msm6255_device_config
class msm6255_device_config : public device_config,
public msm6255_interface
{
friend class msm6255_device;
// construction/destruction
msm6255_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
public:
// allocators
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
protected:
// device_config overrides
virtual void device_config_complete();
msm6255_char_ram_read_func m_char_ram_r;
};
// ======================> msm6255_device
class msm6255_device : public device_t
{
friend class msm6255_device_config;
// construction/destruction
msm6255_device(running_machine &_machine, const msm6255_device_config &_config);
public:
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );
void update_screen(bitmap_t *bitmap, const rectangle *cliprect);
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
private:
inline UINT8 read_video_data(UINT16 ma, UINT8 ra);
void update_cursor();
void draw_scanline(bitmap_t *bitmap, const rectangle *cliprect, int y, UINT16 ma, UINT8 ra);
void update_graphics(bitmap_t *bitmap, const rectangle *cliprect);
void update_text(bitmap_t *bitmap, const rectangle *cliprect);
screen_device *m_screen;
UINT8 m_ir; // instruction register
UINT8 m_mor; // mode control register
UINT8 m_pr; // character pitch register
UINT8 m_hnr; // horizontal character number register
UINT8 m_dvr; // duty number register
UINT8 m_cpr; // cursor form register
UINT8 m_slr; // start address (lower) register
UINT8 m_sur; // start address (upper) register
UINT8 m_clr; // cursor address (lower) register
UINT8 m_cur; // cursor address (upper) register
int m_cursor; // is cursor displayed
int m_frame; // frame counter
const msm6255_device_config &m_config;
};
// device type definition
extern const device_type MSM6255;
#endif
| [
"Mike@localhost"
] | [
[
[
1,
134
]
]
] |
a880b7e49b88e94d60c68651ae4d7376277d7819 | a01b67b20207e2d31404262146763d3839ee833d | /trunk/Projet/tags/Monofin_20090606_release/EdgeDetection/edgesextractionview.cpp | ed87019eb86bb25ebc333b39a3a37ba498713eaf | [] | 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 | 1,633 | cpp | #include "edgesextractionview.h"
#include <QPainter>
#include <QRect>
EdgesExtractionView::EdgesExtractionView(EdgesExtractionScene* scene, QWidget* parent):
QGraphicsView(scene, parent), _scene(scene)
{
_initWidth = this->width() - 10;
_initHeight = this->height() - 10;
qreal sceneWidth = this->scene()->width();
qreal sceneHeight = this->scene()->height();
qreal scaleX = _initWidth / sceneWidth;
qreal scaleY = _initHeight / sceneHeight;
if(scaleX <= scaleY){
this->scale(scaleX, scaleX);
_scale = scaleX;
}
else{
this->scale(scaleY, scaleY);
_scale = scaleY;
}
}
void EdgesExtractionView::reScale(){
qreal sceneWidth = this->scene()->width();
qreal sceneHeight = this->scene()->height();
qreal scaleX = _initWidth / sceneWidth;
qreal scaleY = _initHeight / sceneHeight;
if(scaleX <= scaleY){
this->scale(scaleX / _scale, scaleX / _scale);
_scale = scaleX;
}
else{
this->scale(scaleY /_scale, scaleY / _scale);
_scale = scaleY;
}
}
void EdgesExtractionView::resizeEvent(QResizeEvent *event)
{
_initWidth = this->width() - 10;
_initHeight = this->height() - 10;
this->reScale();
}
void EdgesExtractionView::drawForeground(QPainter *painter, const QRectF &rect){
painter->setBrush(QBrush("black"));
painter->setOpacity(0.75);
QPainterPath path1;
path1.addRect(rect);
QPainterPath path2;
path2.addRect(this->sceneRect());
path1 -= path2;
painter->drawPath(path1);
}
| [
"kryptos@314bda93-af5c-0410-b653-d297496769b1"
] | [
[
[
1,
66
]
]
] |
f6255fab1b84fc7af46b0ae7376d409cb935bd46 | b7d5640a8078e579f61d54f81858cc1dff3fa7ae | /GameServer/include/network/network.h | 256a0f92ad74f019b5172186a38bcf433706f519 | [] | 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 | 991 | 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"
namespace Typhon
{
struct Message
{
char prefix;
std::string msg;
in_addr address;
};
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,
55
]
]
] |
62a0d51159b8a575a738d6fbae19e51ba4462353 | 7ba7440b6a7b6068c900d561ad03c3ff86439c09 | /GalDemo/GalDemo/ResourceManager.cpp | 43be8c09651b07f07a9ea64342f5572259ed3233 | [] | no_license | weimingtom/gal-demo | 96dc06f8f02b4c767412aac7fcf050e241b40c04 | f2b028591a195516af3ce33d084b7b29cbea84aa | refs/heads/master | 2021-01-20T11:47:07.598476 | 2011-08-10T23:48:43 | 2011-08-10T23:48:43 | 42,379,726 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,878 | cpp | #include "stdafx.h"
#include "ResourceManager.h"
#include <fstream>
#include <string>
using namespace std;
CResourceManager::CResourceManager(void)
{
}
CResourceManager::~CResourceManager(void)
{
}
CResourceManager* CResourceManager::GetInstance()
{
static CResourceManager instance;
return &instance;
}
bool CResourceManager::Initialize(LPCTSTR name)
{
string sname = name;
sname.append(".gres");
string iname = name;
iname.append(".gids");
m_resMgr.ChangeScript(sname.c_str());
return m_resIds.LoadIdentities(iname.c_str());
}
bool CResourceManager::SetScript( LPCSTR name)
{
string sname = name;
sname.append(".gres");
string iname = name;
iname.append(".gids");
m_resMgr.ChangeScript(sname.c_str());
m_resIds.Destory();
return m_resIds.LoadIdentities(iname.c_str());
}
bool CResourceManager::Finalize()
{
m_resMgr.Purge(0);
m_resIds.Destory();
return true;
}
bool CResourceManager::LoadResGroup(int group)
{
m_resMgr.Precache(group);
return false;
}
HTEXTURE CResourceManager::GetTexture( LONG ID, int group /*= 0*/ )
{
return m_resMgr.GetTexture(m_resIds.LookUp(ID), group);
}
bool CResourceIdentity::LoadIdentities( LPCSTR fname)
{
Destory();
ifstream infile;
infile.open(fname);
if (!infile.is_open())
{
return false;
}
char buff[MAX_RESNAME_LEN];
int id = 0;
while(infile.getline(buff, MAX_RESNAME_LEN))
{
char *resName = new char[MAX_RESNAME_LEN];
memcpy(resName, buff, MAX_RESNAME_LEN);
m_resIdMap[id++] = resName;
}
return true;
}
LPCTSTR CResourceIdentity::LookUp( int id )
{
return m_resIdMap[id];
}
void CResourceIdentity::Destory()
{
std::map<LONG, LPTSTR>::iterator iter = m_resIdMap.begin();
while (iter != m_resIdMap.end())
{
delete[] iter->second;
iter->second = 0;
iter++;
}
m_resIdMap.clear();
} | [
"[email protected]"
] | [
[
[
1,
97
]
]
] |
5bdf2dee06e57571a7bf8c2debf6bb7bd8af6b50 | b6a6fa4324540b94fb84ee68de3021a66f5efe43 | /SCS/Instruments/MString.h | c7789ab341f9b5bbf3e6221c22d46ffa6931eb52 | [] | no_license | southor/duplo-scs | dbb54061704f8a2ec0514ad7d204178bfb5a290e | 403cc209039484b469d602b6752f66b9e7c811de | refs/heads/master | 2021-01-20T10:41:22.702098 | 2010-02-25T16:44:39 | 2010-02-25T16:44:39 | 34,623,992 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,340 | h | #ifndef _MSTRING_
#define _MSTRING_
#include "Standards.h"
#include "Curves.h"
class MString : public STInstrument
{
public:
double Pos;
EnvelopeT *Env1;
EnvelopeT *Env2;
EchoModule *Echo;
// modulations
double Decay;
double EchoAmount;
MString() : STInstrument()
{
Env1 = new EnvelopeT(0.005, 0.1, 0.15, 0.9, 0.17);
Env2 = new EnvelopeT(0.005, 0.1, 0.1, 0.4, 0.17);
Pos = 0;
Decay = 2.0;
EchoAmount = 0.2;
Echo = new EchoModule(0.01, 2);
}
void NoteOn()
{
Env1->NoteOn();
Env2->NoteOn();
Echo->NoteOn();
STInstrument::NoteOn();
Pos = 0;
}
bool Run()
{
STInstrument::Run();
Amp = 0;
if (Env1->Playing == true)
{
if(Env1->Run() == false)
{
Echo->NoteOff();
}
Env2->Run();
Pos = Pos + TimeStep*Fre;
Amp = MultiCurve(Pos, 0.1, 0.5, 0.4, -0.5, 0.9, -1.0);
Amp = Amp * Fall2(TimePos*Decay)*Env1->Amp*0.5;
}
//if (Echo->Out)
// Echo
Echo->In = Amp;
Playing = Echo->Run();
//if (TimePos < 0.5) cout << Echo->Out << endl;
Amp = Amp + Echo->Out * EchoAmount;
return Playing;
}
void NoteOff()
{
Env1->NoteOff();
Env2->NoteOff();
STInstrument::NoteOff();
}
void End()
{
Echo->End();
}
};
#endif | [
"t.soderberg8@2b3d9118-3c8b-11de-9b50-8bb2048eb44c"
] | [
[
[
1,
99
]
]
] |
9cd03f8d718bf5d145ca180c865e70d784c7c8eb | fe122f81ca7d6dff899945987f69305ada995cd7 | /developlib/vc60include/String2DataType.h | 4d9b0955fbb26dbe1e46d4174c87b9266d66f64c | [] | no_license | myeverytime/chtdependstoreroom | ddb9f4f98a6a403521aaf403d0b5f2dc5213f346 | 64a4d1e2d32abffaab0376f6377e10448b3c5bc3 | refs/heads/master | 2021-01-10T06:53:35.455736 | 2010-06-23T10:21:44 | 2010-06-23T10:21:44 | 50,168,936 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,640 | h | // String2DataType.h: interface for the CString2DataType class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_STRING2DATATYPE_H__8BC63FA1_F2F2_446F_BA98_1F311D1722C2__INCLUDED_)
#define AFX_STRING2DATATYPE_H__8BC63FA1_F2F2_446F_BA98_1F311D1722C2__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <list>
#include <map>
using namespace std;
// Exported functions.
class AFX_EXT_CLASS CString2DataType
{
public:
unsigned char Str2HEX(CString strData);
unsigned char GetBitValue(unsigned char ucCh,unsigned char ucBitNo);
CString Char2Binary(unsigned char ucCh);
BOOL Str2Bool(CString str);
CString Int2CString(int nInt);
int String2Int(CString str);
int reduceBCD2Int(unsigned char nchar);
double String2Double(CString str);
CString2DataType();
virtual ~CString2DataType();
CString str1,str2,str3;
void TokenizeString(const CString& strInput, const CString& strDelim, std::list<CString>& tokenList);
bool StringToBool(const CString& s, bool& flag);
bool StringToInteger(const CString& s, int& val);
bool StringToItems(const CString& s, std::list<CString>& itemList);
bool StringToSize(const CString& s, const CString& t, CSize& size);
bool StringToLocation(const CString& s, const CString& t, CPoint& location);
bool Splittoint(const CString& s, int& val1,int& val2,int& val3);
bool SplittoCString(const CString& s, LPCTSTR& val1,LPCTSTR& val2,LPCTSTR& val3);
private:
char HexChar(char c);
};
#endif // !defined(AFX_STRING2DATATYPE_H__8BC63FA1_F2F2_446F_BA98_1F311D1722C2__INCLUDED_)
| [
"robustwell@bd7e636a-136b-06c9-ecb0-b59307166256"
] | [
[
[
1,
47
]
]
] |
94d2550a881e5cc78e059299dd295accec3e4f51 | 87ff03fd1b5a4642773a5a001165b595cfacd60d | /WinampRemoteMedia/winampplugin/in_redcaza/InputPluginManagement.h | 154273d90f363e94ab145e4f0fdc1a7f72b75f99 | [] | no_license | jubbynox/googlegadets | f7f16b2eb417871601a33d2f1f5615b3a007780a | 79e94a0af754b0f3dfed59f73aeaa3bff39dafa5 | refs/heads/master | 2021-01-10T21:46:45.901272 | 2010-02-06T13:38:25 | 2010-02-06T13:38:25 | 32,803,954 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 910 | h | #ifndef INPUT_PLUGIN_MANAGEMENT
#define INPUT_PLUGIN_MANAGEMENT
#include <windows.h>
#include <list>
#include <algorithm>
#include <shlwapi.h>
#include "../../Winamp/in2.h"
#define RED_CAZA_MODULE L"in_redcaza.dll" // The name of this module.
typedef struct // Structure to hold input plugin handle and module.
{
In_Module *mod;
HMODULE hdll;
} InMod;
typedef In_Module* (*PluginGetter)(void);
class InputPluginManagement
{
private:
std::list<InMod> inModList; // input plugin list
bool caseInsensitiveStringFind(const std::wstring& subStr, const std::wstring& fullStr); // Case insensitive string comparison.
public:
InputPluginManagement();
~InputPluginManagement();
void InputPluginManagement::loadPlugins(const wchar_t *file); // Loads plugins.
In_Module* findInputPlugin(const wchar_t *file); // Finds an input plugin to use with the file.
};
#endif | [
"jubbynox@9a519766-8835-0410-a643-67b8b61f6624"
] | [
[
[
1,
33
]
]
] |
b318aae6ef8b902c1bdd24298f01e1cf6da20246 | f177993b13e97f9fecfc0e751602153824dfef7e | /ImPro/ImProFilters/AR2WarpController/pointTrans.h | 4093fafd5d79cd8dc1fcb7c2c724066fe338a68a | [] | 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 | 1,708 | h | #include "cv.h"
#include "highgui.h"
#include <cvaux.h>
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
using namespace std;
#define CAMWIDTH 640
#define CAMHEIGHT 480
class ProjectorTrans2World{
public :
ProjectorTrans2World(int tableW, int tableH ,char* fileDir);
~ProjectorTrans2World() ;
void findCam2WorldExtrinsic(CvMat* cameraPoint, CvMat* objectPoint);
void findPro2WorldExtrinsic();
void loadCalibParam(char* fileDir);
// combine rotation matrix and translation matrix into a 4*4 extrinsic matrix
void buildExtrinsicMat(CvMat* rotation, CvMat* translate, CvMat* dstExtrinsicMat);
CvPoint3D32f findPro3D(CvMat* pointMat);
void setTableSize(int width , int height);
int* getTableSize();
void getProjHomo();
void initProjRes(int width, int height);
CvPoint2D32f findPro3DcvPoint(CvPoint point);
public:
CvMat* pro2CamExtrinsic;
CvMat* proIntrinsic;
CvMat* camIntrinsic;
CvMat* proDisto;
CvMat* camDisto;
CvMat* invProIntrinsic;
CvMat* pro2WorldRotation;
CvMat* cam2WorldExtrinsic;
CvMat* pro2WorldExtrinsic;
CvMat* world2CamExtrinsic;
CvMat* proPositionInWorld;
CvMat* cameraPoint;
CvMat* objectPoint;
CvMat* oriProPos;
CvMat* rotateW2C;
CvMat* transW2C ;
CvMat* rotateRodrigues ;
// for findPro3D
CvMat* proVector ;
CvMat* proVectorInWorld;
CvMat* pro3DPointsMat;
CvMat* proHomoMat;
CvMat projCornerMat;
float proj3DPoints[4][2];
float projBox[4];
float projCorner[8];
float projHomo[3][3];
int ProjResWidth ; // resolution width
int ProjResHeight;
int tableWidth;
int tableHeight;
float pre_proj3DPoints[4][2];
bool firstProjPoints ;
}; | [
"ndhumuscle@fa729b96-8d43-11de-b54f-137c5e29c83a"
] | [
[
[
1,
73
]
]
] |
e6fde985e6ac0faafe7188efa37576dfdd5c682d | 3187b0dd0d7a7b83b33c62357efa0092b3943110 | /src/dlib/sockets/sockets_kernel_abstract.h | bd0aa0b94bfcc4e618bac25cbe09a6a766b028cd | [
"BSL-1.0"
] | permissive | exi/gravisim | 8a4dad954f68960d42f1d7da14ff1ca7a20e92f2 | 361e70e40f58c9f5e2c2f574c9e7446751629807 | refs/heads/master | 2021-01-19T17:45:04.106839 | 2010-10-22T09:11:24 | 2010-10-22T09:11:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,307 | h | // Copyright (C) 2003 Davis E. King ([email protected])
// License: Boost Software License See LICENSE.txt for the full license.
#undef DLIB_SOCKETS_KERNEl_ABSTRACT_
#ifdef DLIB_SOCKETS_KERNEl_ABSTRACT_
#include <string>
#include "../threads.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
/*!
GENERAL COMMENTS:
Nothing in here will throw exceptions
Timeouts:
All timeout values are measured in milliseconds but you are not
guaranteed to have that level of resolution. The actual resolution
is implementation defined.
GENERAL WARNING
Don't call any of these functions or make any of these objects
before main() has been entered.
!*/
// ----------------------------------------------------------------------------------------
// LOOKUP FUNCTIONS
// all lookup functions are thread-safe
int get_local_hostname (
std::string& hostname
);
/*!
ensures
- if (#get_local_hostname() == 0) then
- #hostname == a string containing the hostname of the local computer
- returns 0 upon success
- returns OTHER_ERROR upon failure and in this case #hostname's value
is undefined
!*/
// -----------------
int hostname_to_ip (
const std::string& hostname,
std::string& ip,
int n = 0
);
/*!
requires
- n >= 0
ensures
- if (#hostname_to_ip() == 0) then
- #ip == string containing the nth ip address associated with the hostname
- returns 0 upon success
- returns OTHER_ERROR upon failure
!*/
// -----------------
int ip_to_hostname (
const std::string& ip,
std::string& hostname
);
/*!
ensures
- if (#ip_to_hostname() == 0) then
- #hostname == string containing the hostname associated with ip
- returns 0 upon success
- returns OTHER_ERROR upon failure
!*/
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
//
// socket creation functions
//
// The following functions are guaranteed to be thread-safe
//
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
int create_listener (
listener*& new_listener,
unsigned short port,
const std::string& ip = ""
);
/*!
requires
- 0 <= port <= 65535
ensures
- if (#create_listener() == 0) then
- #new_listener == a pointer to a listener object that is listening on
the specified port and ip for an incoming connection
- if (ip == "") then
- the new listener will be listening on all interfaces
- if (port == 0) then
- the kernel will assign a free port to listen on
- returns 0 if create_listener was successful
- returns PORTINUSE if the specified local port was already in use
- returns OTHER_ERROR if some other error occurred
!*/
int create_connection (
connection*& new_connection,
unsigned short foreign_port,
const std::string& foreign_ip,
unsigned short local_port = 0,
const std::string& local_ip = ""
);
/*!
requires
- 0 < foreign_port <= 65535
- 0 <= local_port <= 65535
ensures
- if (#create_connection() == 0) then
- #new_connection == a pointer to a connection object that is connected
to foreign_ip on port foreign_port and is using the local interface
local_ip and local port local_port
- #new_connection->user_data == 0
- if (local_ip == "") then
- the operating system will chose this for you
- if (local_port == 0) then
- the operating system will chose this for you
- returns 0 if create_connection was successful
- returns PORTINUSE if the specified local port was already in use
- returns OTHER_ERROR if some other error occurred
!*/
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// connection object
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
class connection
{
/*!
WHAT THIS OBJECT REPRESENTS
This object represents a TCP connection.
Instances of this class can only be created by using the
create_connection function or listener class defined below.
NOTE:
A connection object must ALWAYS be closed (delete the pointer to the
connection) or it will cause a resource leak.
Note also that all errors indicated by a return code of OTHER_ERROR
are fatal so if one occurs the connection should just be closed.
CLOSING A CONNECTION
Note that if ~connection() or shutdown() is called before the remote client
has received all sent data it is possible that the data will be lost. To
avoid this you should call the close_gracefully() function to close your
connections (unless you actually do want to immediately dispose of a
connection and don't care about the data).
(example: close_gracefully(con); // close con gracefully but force it closed
// if it takes more than 500 milliseconds.)
THREAD SAFETY
- It is always safe to call shutdown() or shutdown_outgoing().
- you may NOT call any function more than once at a time (except the
shutdown functions).
- do not call read() more than once at a time
- do not call write() more than once at a time
- You can safely call shutdown or shutdown_outgoing in conjunction with
the read/write functions.
This is helpful if you want to unblock another thread that is
blocking on a read/write operation. Shutting down the connection
will cause the read/write functions to return a value of SHUTDOWN.
OUT-OF-BAND DATA:
All out-of-band data will be put inline into the normal data stream.
This means that you can read any out-of-band data via calls to read().
(i.e. the SO_OOBINLINE socket option will be set)
!*/
public:
~connection (
);
/*!
requires
- no other threads are using this connection object
ensures
- closes the connection (this is an abrupt non-graceful close)
- frees the resources used by this object
!*/
void* user_data;
/*!
This pointer is provided so that the client programmer may easily assocaite
some data with a connection object. You can really do whatever you want
with it. Initially user_data is 0.
!*/
long write (
const char* buf,
long num
);
/*!
requires
- num > 0
- buf points to an array of at least num bytes
ensures
- will block until ONE of the following occurrs:
- num bytes from buf have been written to the connection
- an error has occurred
- the outgoing channel of the connection has been shutdown locally
- returns num if write succeeded
- returns OTHER_ERROR if there was an error (this could be due to a
connection close)
- returns SHUTDOWN if the outgoing channel of the connection has been
shutdown locally
!*/
long read (
char* buf,
long num
);
/*!
requires
- num > 0
- buf points to an array of at least num bytes
ensures
- read() will not read more than num bytes of data into #buf
- read blocks until ONE of the following happens:
- there is some data available and it has been written into #buf
- the remote end of the connection is closed
- an error has occurred
- the connection has been shutdown locally
- returns the number of bytes read into #buf if there was any data.
- returns 0 if the connection has ended/terminated and there is no more data.
- returns OTHER_ERROR if there was an error.
- returns SHUTDOWN if the connection has been shutdown locally
!*/
unsigned short get_local_port (
) const;
/*!
ensures
- returns the local port number for this connection
!*/
unsigned short get_foreign_port (
) const;
/*!
ensures
- returns the foreign port number for this connection
!*/
const std::string& get_local_ip (
) const;
/*!
ensures
- returns the IP of the local interface this connection is using
!*/
const std::string& get_foreign_ip (
) const;
/*!
ensures
- returns the IP of the foreign host for this connection
!*/
int shutdown (
);
/*!
ensures
- if (#shutdown() == 0 && connection was still open) then
- terminates the connection but does not free the resources for the
connection object
- any read() or write() calls on this connection will return immediately
with the code SHUTDOWN.
- returns 0 upon success
- returns OTHER_ERROR if there was an error
!*/
int shutdown_outgoing (
);
/*!
ensures
- if (#shutdown_outgoing() == 0 && outgoing channel was still open) then
- sends a FIN to indicate that no more data will be sent on this
connection but leaves the receive half of the connection open to
receive more data from the other host
- any calls to write() will return immediately with the code SHUTDOWN.
- returns 0 upon success
- returns OTHER_ERROR if there was an error
!*/
private:
// restricted functions
connection();
connection(connection&); // copy constructor
connection& operator=(connection&); // assignment operator
};
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// listener object
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
class listener
{
/*!
WHAT THIS OBJECT REPRESENTS
This object represents a TCP socket waiting for incoming connections.
Calling accept returns a pointer to any new incoming connections on its
port.
Instances of this class can only be created by using the
create_listener function defined below.
NOTE:
A listener object must ALWAYS be closed (delete the pointer to it) or
it will cause a resource leak.
Note also that all errors indicated by a return code of OTHER_ERROR
are fatal so if one occurs the listener should be closed.
THREAD SAFETY
None of the functions in this object are guaranteed to be thread-safe.
This means that you must serialize all access to this object.
!*/
public:
~listener (
);
/*!
requires
- no other threads are using this listener object
ensures
- closes the listener
- frees the resources used by this object
!*/
int accept (
connection*& new_connection,
unsigned long timeout = 0
);
/*!
requires
- timeout < 2000000
ensures
- blocks until a new connection is ready or timeout milliseconds have
elapsed.
- #new_connection == a pointer to the new connection object
- #new_connection->user_data == 0
- if (timeout == 0) then
- the timeout argument is ignored
- returns 0 if accept() was successful
- returns TIMEOUT if timeout milliseconds have elapsed
- returns OTHER_ERROR if an error has occured
!*/
unsigned short get_listening_port (
) const;
/*!
ensures
- returns the port number that this object is listening on
!*/
const std::string& get_listening_ip (
) const;
/*!
ensures
- returns a string containing the IP (e.g. "127.0.0.1") of the
interface this object is listening on
- returns "" if it is accepting connections on all interfaces
!*/
private:
// restricted functions
listener();
listener(listener&); // copy constructor
listener& operator=(listener&); // assignment operator
};
}
#endif // DLIB_SOCKETS_KERNEl_ABSTRACT_
| [
"[email protected]"
] | [
[
[
1,
403
]
]
] |
49ae565b83619e8ed72dc060db75080ad07e8aa6 | 5ac13fa1746046451f1989b5b8734f40d6445322 | /minimangalore/Nebula2/code/mangalore/msg/gfxremskin.cc | 8e6af8d2eecc9c9c80e8ee7e1dbcd271408841ed | [] | 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 | 414 | cc | //------------------------------------------------------------------------------
// msg/gfxremskin.cc
// (C) 2006 Radon Labs GmbH
//------------------------------------------------------------------------------
#include "msg/gfxremskin.h"
namespace Message
{
ImplementRtti(Message::GfxRemSkin, Message::Msg);
ImplementFactory(Message::GfxRemSkin);
ImplementMsgId(GfxRemSkin);
} // namespace Message
| [
"BawooiT@d1c0eb94-fc07-11dd-a7be-4b3ef3b0700c"
] | [
[
[
1,
12
]
]
] |
8ac1c3dff100c13edcef69eb04b8b93eb07e4238 | c5ecda551cefa7aaa54b787850b55a2d8fd12387 | /src/UILayer/DownloadTabCtrl.h | 8569ceb13c88be813bc77ea5df091e5698c5def4 | [] | no_license | firespeed79/easymule | b2520bfc44977c4e0643064bbc7211c0ce30cf66 | 3f890fa7ed2526c782cfcfabb5aac08c1e70e033 | refs/heads/master | 2021-05-28T20:52:15.983758 | 2007-12-05T09:41:56 | 2007-12-05T09:41:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 424 | h | #pragma once
#include "tabwnd.h"
#include "CoolBarCtrl.h"
#include "TbcDownload.h"
class CDownloadTabWnd : public CTabWnd
{
DECLARE_MESSAGE_MAP()
public:
CDownloadTabWnd(void);
virtual ~CDownloadTabWnd(void);
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
public:
CTbcDownload m_Toolbar;
protected:
void InitToolBar(void);
public:
afx_msg void OnSize(UINT nType, int cx, int cy);
};
| [
"LanceFong@4a627187-453b-0410-a94d-992500ef832d"
] | [
[
[
1,
22
]
]
] |
20ceba082d74b6752e633f0c9703e327975711a9 | b83c990328347a0a2130716fd99788c49c29621e | /include/boost/random/xor_combine.hpp | b633278dd98cbf38549a7ef90c0ae4fa44b77366 | [] | no_license | SpliFF/mingwlibs | c6249fbb13abd74ee9c16e0a049c88b27bd357cf | 12d1369c9c1c2cc342f66c51d045b95c811ff90c | refs/heads/master | 2021-01-18T03:51:51.198506 | 2010-06-13T15:13:20 | 2010-06-13T15:13:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,646 | hpp | /* boost random/xor_combine.hpp header file
*
* Copyright Jens Maurer 2002
* 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 for most recent version including documentation.
*
* $Id: xor_combine.hpp 52492 2009-04-19 14:55:57Z steven_watanabe $
*
*/
#ifndef BOOST_RANDOM_XOR_COMBINE_HPP
#define BOOST_RANDOM_XOR_COMBINE_HPP
#include <iostream>
#include <cassert>
#include <algorithm> // for std::min and std::max
#include <boost/config.hpp>
#include <boost/limits.hpp>
#include <boost/static_assert.hpp>
#include <boost/cstdint.hpp> // uint32_t
#include <boost/random/detail/config.hpp>
namespace boost {
namespace random {
#ifndef BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
#define BOOST_RANDOM_VAL_TYPE typename URNG1::result_type
#else
#define BOOST_RANDOM_VAL_TYPE uint32_t
#endif
template<class URNG1, int s1, class URNG2, int s2, BOOST_RANDOM_VAL_TYPE val = 0>
class xor_combine
{
public:
typedef URNG1 base1_type;
typedef URNG2 base2_type;
typedef typename base1_type::result_type result_type;
BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
BOOST_STATIC_CONSTANT(int, shift1 = s1);
BOOST_STATIC_CONSTANT(int, shift2 = s2);
xor_combine() : _rng1(), _rng2()
{ }
xor_combine(const base1_type & rng1, const base2_type & rng2)
: _rng1(rng1), _rng2(rng2) { }
template<class It> xor_combine(It& first, It last)
: _rng1(first, last), _rng2( /* advanced by other call */ first, last) { }
void seed() { _rng1.seed(); _rng2.seed(); }
template<class It> void seed(It& first, It last)
{
_rng1.seed(first, last);
_rng2.seed(first, last);
}
const base1_type& base1() { return _rng1; }
const base2_type& base2() { return _rng2; }
result_type operator()()
{
// MSVC fails BOOST_STATIC_ASSERT with std::numeric_limits at class scope
#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) && !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300)
BOOST_STATIC_ASSERT(std::numeric_limits<typename base1_type::result_type>::is_integer);
BOOST_STATIC_ASSERT(std::numeric_limits<typename base2_type::result_type>::is_integer);
BOOST_STATIC_ASSERT(std::numeric_limits<typename base1_type::result_type>::digits >= std::numeric_limits<typename base2_type::result_type>::digits);
#endif
return (_rng1() << s1) ^ (_rng2() << s2);
}
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return std::min BOOST_PREVENT_MACRO_SUBSTITUTION((_rng1.min)(), (_rng2.min)()); }
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return std::max BOOST_PREVENT_MACRO_SUBSTITUTION((_rng1.min)(), (_rng2.max)()); }
static bool validation(result_type x) { return val == x; }
#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
template<class CharT, class Traits>
friend std::basic_ostream<CharT,Traits>&
operator<<(std::basic_ostream<CharT,Traits>& os, const xor_combine& s)
{
os << s._rng1 << " " << s._rng2 << " ";
return os;
}
template<class CharT, class Traits>
friend std::basic_istream<CharT,Traits>&
operator>>(std::basic_istream<CharT,Traits>& is, xor_combine& s)
{
is >> s._rng1 >> std::ws >> s._rng2 >> std::ws;
return is;
}
#endif
friend bool operator==(const xor_combine& x, const xor_combine& y)
{ return x._rng1 == y._rng1 && x._rng2 == y._rng2; }
friend bool operator!=(const xor_combine& x, const xor_combine& y)
{ return !(x == y); }
#else
// Use a member function; Streamable concept not supported.
bool operator==(const xor_combine& rhs) const
{ return _rng1 == rhs._rng1 && _rng2 == rhs._rng2; }
bool operator!=(const xor_combine& rhs) const
{ return !(*this == rhs); }
#endif
private:
base1_type _rng1;
base2_type _rng2;
};
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
// A definition is required even for integral static constants
template<class URNG1, int s1, class URNG2, int s2, BOOST_RANDOM_VAL_TYPE val>
const bool xor_combine<URNG1, s1, URNG2, s2, val>::has_fixed_range;
template<class URNG1, int s1, class URNG2, int s2, BOOST_RANDOM_VAL_TYPE val>
const int xor_combine<URNG1, s1, URNG2, s2, val>::shift1;
template<class URNG1, int s1, class URNG2, int s2, BOOST_RANDOM_VAL_TYPE val>
const int xor_combine<URNG1, s1, URNG2, s2, val>::shift2;
#endif
#undef BOOST_RANDOM_VAL_TYPE
} // namespace random
} // namespace boost
#endif // BOOST_RANDOM_XOR_COMBINE_HPP
| [
"[email protected]"
] | [
[
[
1,
131
]
]
] |
93ae6289c1b072bd65f3e02fece6597dbc439d57 | 74c8da5b29163992a08a376c7819785998afb588 | /NetAnimal/Game/wheel/WheelController/src/WheelMediator.cpp | cd7ec1f8ed5c2c9e5ab977179f2a99f7e1e276d6 | [] | 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 | 43 | cpp | #include "WheelControllerStableHeaders.h"
| [
"[email protected]"
] | [
[
[
1,
1
]
]
] |
97bf83b585be1aff8ee71a3b6a3cc58df5231cb7 | 960d6f5c4195a18f795f741c5d2d484f26482c0c | /src/server/scripts/Kalimdor/HallsOfOrigination/boss_tempelguardian_anhuur.cpp | b7996dd75a51ecd376e5b07da88eeb2976129571 | [] | no_license | Bootz/TrilliumEMU-1 | ec4100d345cc28171e52d60f092ebd39298c40b0 | 961bfa5d9b0e028d6d89cc238ed8db78a46c69f4 | refs/heads/master | 2020-12-25T04:30:12.412196 | 2011-11-25T10:11:04 | 2011-11-25T10:11:04 | 2,769,808 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,305 | cpp | /*
* Copyright (C) 2005 - 2011 MaNGOS <http://www.getmangos.org/>
*
* Copyright (C) 2008 - 2011 TrinityCore <http://www.trinitycore.org/>
*
* Copyright (C) 2011 TrilliumEMU <http://www.arkania.net/>
*
* 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 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, see <http://www.gnu.org/licenses/>.
*/
/*
Made By: Jenova
Project: Atlantiss Core
SDName: boss_templeguardian_anhuur
SD%Complete: 80%
SDComment: Add object handling.
SDCategory: Halls Of Origination
Known Bugs:
TODO:
1. Needs Testing
2. Missing ScriptTexts
3. Check Timers
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ScriptPCH.h"
#include "halls_of_origination.h"
enum ScriptTexts
{
SAY_AGGRO = 0,
SAY_BEACON = 1,
SAY_KILL_1 = 2,
SAY_KILL_2 = 3,
SAY_DEATH = 4,
SAY_ANNOUNCE = 5
};
enum Spells
{
SPELL_DIVINE_RECKONING = 75592,
SPELL_REVERBERATING_HYMN = 75322,
SPELL_SHIELD_OF_LIGHT = 74938,
SPELL_SEARING_FLAME_SUMM = 75114,
// Lever beams.
SPELL_BEAM_LEFT = 83697, // Object 203133
SPELL_BEAM_RIGHT = 83698, // Object 203136
};
const Position SpawnPosition[] =
{
{-654.277f, 361.118f, 52.9508f, 5.86241f},
{-670.102f, 350.896f, 54.1803f, 2.53073f},
{-668.896f, 326.048f, 53.2267f, 3.36574f},
{-618.875f, 344.237f, 52.95f, 0.194356f},
{-661.667f, 338.78f, 53.0333f, 2.53073f},
{-607.836f, 348.586f, 53.4939f, 1.0558f},
{-656.452f, 376.388f, 53.9709f, 1.4525f},
{-652.762f, 370.634f, 52.9503f, 2.5221f},
{-682.656f, 343.953f, 53.7329f, 2.53073f},
{-658.877f, 309.077f, 53.6711f, 0.595064f},
{-619.399f, 309.049f, 53.4247f, 4.63496f},
{-612.648f, 318.365f, 53.777f, 3.53434f},
{-616.398f, 345.109f, 53.0165f, 2.53073f},
{-681.394f, 342.813f, 53.8955f, 6.24987f},
{-668.843f, 351.407f, 54.1813f, 5.5293f},
{-672.797f, 317.175f, 52.9636f, 5.51166f},
{-631.834f, 375.502f, 55.7079f, 0.738231f},
{-617.027f, 360.071f, 52.9816f, 2.00725f},
{-623.891f, 361.178f, 52.9334f, 5.61183f},
{-614.988f, 331.613f, 52.9533f, 2.91186f},
{-662.902f, 341.463f, 52.9502f, 2.84307f}
};
enum BossPhases
{
PHASE_NORMAL = 1,
PHASE_SHIELD = 2,
};
class boss_temple_guardian_anhuur : public CreatureScript
{
public:
boss_temple_guardian_anhuur() : CreatureScript("boss_temple_guardian_anhuur") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_temple_guardian_anhuurAI(pCreature);
}
struct boss_temple_guardian_anhuurAI : public ScriptedAI
{
boss_temple_guardian_anhuurAI(Creature* pCreature) : ScriptedAI(pCreature)
{
pInstance = pCreature->GetInstanceScript();
}
std::list<uint64> SummonList;
InstanceScript *pInstance;
uint8 Phase;
uint8 PhaseCount;
uint8 FlameCount;
uint32 DivineReckoningTimer;
uint32 SearingFlameTimer;
void Reset()
{
if (pInstance)
pInstance->SetData(DATA_TEMPLE_GUARDIAN_ANHUUR_EVENT, NOT_STARTED);
Phase = PHASE_NORMAL;
PhaseCount = 0;
FlameCount = 2;
DivineReckoningTimer = 8000;
SearingFlameTimer = 5000;
RemoveSummons();
me->RemoveAurasDueToSpell(SPELL_SHIELD_OF_LIGHT);
me->RemoveAurasDueToSpell(SPELL_REVERBERATING_HYMN);
}
void RemoveSummons()
{
if (SummonList.empty())
return;
for (std::list<uint64>::const_iterator itr = SummonList.begin(); itr != SummonList.end(); ++itr)
{
if (Creature* pTemp = Unit::GetCreature(*me, *itr))
if (pTemp)
pTemp->DisappearAndDie();
}
SummonList.clear();
}
void JustSummoned(Creature* pSummon)
{
SummonList.push_back(pSummon->GetGUID());
}
void ChangePhase()
{
DoTeleportTo(-640.527f, 334.855f, 78.345f, 1.54f);
me->SetOrientation(1.54f);
for(uint32 x = 0; x<21; ++x)
me->SummonCreature(NPC_PIT_SNAKE,SpawnPosition[x],TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3000);
DoCast(me, SPELL_SHIELD_OF_LIGHT);
DoCast(me, SPELL_REVERBERATING_HYMN);
//Talk(SAY_BEACON);
//Talk(SAY_ANNOUNCE);
PhaseCount++;
Phase = PHASE_SHIELD;
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_INTERRUPT, true);
if (Creature *light1 = me->SummonCreature(40183, -603.465f, 334.38f, 65.4f, 3.12f,TEMPSUMMON_CORPSE_DESPAWN, 1000))
light1->CastSpell(me, SPELL_BEAM_LEFT, false);
if (Creature *light2 = me->SummonCreature(40183, -678.132f, 334.212f, 64.9f, 0.24f,TEMPSUMMON_CORPSE_DESPAWN, 1000))
light2->CastSpell(me, SPELL_BEAM_RIGHT, false);
}
void KilledUnit(Unit* /*Killed*/)
{
//Talk(RAND(SAY_KILL_1, SAY_KILL_2));
}
void JustDied(Unit* /*Kill*/)
{
RemoveSummons();
//Talk(SAY_DEATH);
if (pInstance)
pInstance->SetData(DATA_TEMPLE_GUARDIAN_ANHUUR_EVENT, DONE);
GameObject* Bridge = me->FindNearestGameObject(GO_ANHUUR_BRIDGE, 200);
if (Bridge)
Bridge->SetGoState(GO_STATE_ACTIVE);
}
void SummonedCreatureDespawn(Creature* summon)
{
switch(summon->GetEntry())
{
case 40183:
FlameCount--;
break;
}
}
void EnterCombat(Unit* /*Ent*/)
{
//Talk(SAY_AGGRO);
if (pInstance)
pInstance->SetData(DATA_TEMPLE_GUARDIAN_ANHUUR_EVENT, IN_PROGRESS);
DoZoneInCombat();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() && !me->HasAura(SPELL_SHIELD_OF_LIGHT))
return;
if ((me->HealthBelowPct(34) && Phase == PHASE_NORMAL && PhaseCount == 1) ||
(me->HealthBelowPct(67) && Phase == PHASE_NORMAL && PhaseCount == 0))
{
ChangePhase();
}
if (Phase == PHASE_SHIELD && FlameCount == 0)
{
me->RemoveAurasDueToSpell(SPELL_SHIELD_OF_LIGHT);
FlameCount = 2;
}
if (!me->HasUnitState(UNIT_STAT_CASTING) && Phase == PHASE_SHIELD)
{
Phase = PHASE_NORMAL;
RemoveSummons();
}
if (DivineReckoningTimer <= diff && Phase == PHASE_NORMAL)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_DIVINE_RECKONING);
DivineReckoningTimer = urand(15000,18000);
} else DivineReckoningTimer -= diff;
if (SearingFlameTimer <= diff && Phase == PHASE_NORMAL)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
target->CastSpell(target, SPELL_SEARING_FLAME_SUMM, true);
SearingFlameTimer = 8000;
} else SearingFlameTimer -= diff;
DoMeleeAttackIfReady();
}
};
};
class go_beacon_of_light : public GameObjectScript
{
public:
go_beacon_of_light() : GameObjectScript("go_beacon_of_light") { }
bool OnGossipHello(Player* pPlayer, GameObject* pGO)
{
pPlayer->CastSpell(pGO, 68398, false);
if (Creature* beam = pGO->FindNearestCreature(40183, 14.0f, true))
beam->Kill(beam);
return true;
}
};
void AddSC_boss_temple_guardian_anhuur()
{
new boss_temple_guardian_anhuur();
new go_beacon_of_light();
} | [
"[email protected]",
"[email protected]"
] | [
[
[
1,
5
],
[
7,
20
],
[
22,
22
],
[
25,
34
],
[
36,
38
],
[
40,
278
]
],
[
[
6,
6
],
[
21,
21
],
[
23,
24
],
[
35,
35
],
[
39,
39
]
]
] |
3bfd438cb1e0c4e77f420234445e067295d5497f | 2f72d621e6ec03b9ea243a96e8dd947a952da087 | /src/vector2d.cpp | 120044dcab123f08c3c41586c97ad2f5cfb5dbf0 | [] | 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 | ISO-8859-1 | C++ | false | false | 1,189 | cpp | //#include "vector2d.h"
//template <typename T>
//void vector2d<T>::clear()
//{
// std::vector< std::vector<T> >::iterator itr;
// for(itr= mVector.begin();itr != mVector.end();itr++)
// {
// std::vector<T2D> cur = *itr;
// cur.clear();
// }
// mVector.clear();
// maxX = 0;
// maxY = 0;
//}
//template <typename T>
//T vector2d<T>::getAt(unsigned int x, unsigned int y)
//{
// unsigned int maxX = mVector.size()-1;
// if(x<=maxX)
// {
// unsigned int maxY = mVector[x].size()-1;
// if(y <= maxY)
// {
// return mVector[x][y];
// }
// else
// return valEmpty;
// }
// else
// {
// return valEmpty;
// }
//}
//template <typename T>
//void vector2d<T>::setAt(unsigned int x, unsigned int y, T val)
//{
//
// unsigned int sizeX = mVector.size();
// if(sizeX <= y)
// {
// for(unsigned int i = sizeX;i<=x;i++)
// {
// std::vector<T> temp;
//
// mVector.push_back(temp);
// }
//
//
// }
// unsigned int sizeY = mVector[x].size();
// if(sizeY <= y)
// {
// //dh hier Y nachfüllen
// for(unsigned int i=sizeY;i<=y;i++)
// {
// mVector[x].push_back(valEmpty);
// }
// }
//
// mVector[x][y] = val;
//
//} | [
"praecipitator@bd7a9385-7eed-4fd6-88b1-0096df50a1ac"
] | [
[
[
1,
62
]
]
] |
682e3f7b3096af1a1a5b95918d8a4e46cf9deb63 | 368c34f3901c02da13d4a03730d4a859e3f3dc91 | /key-net/win_socket_errors.h | abb37f5995665f3b854aaac835caaedc29d370ea | [
"LicenseRef-scancode-warranty-disclaimer",
"MIT"
] | permissive | Nercury/epics | 2c0f1f521894b5478fb993c96aad80f89502e593 | 37c3e4b47510085245bc4dc7795e777b5541a2df | refs/heads/master | 2020-12-24T16:58:32.814871 | 2011-12-19T21:24:46 | 2011-12-19T21:24:46 | 2,839,261 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 543 | h | #pragma once
#include <key-net/lib_key_net.h>
#include <key-common/sockets.hpp>
#include <string>
namespace key {
namespace internal {
enum class SocketErrorScope {
Any,
Bind,
Listen,
Accept,
};
/** returns last error for socket opperation */
LIB_KEY_NET int socket_last_error();
LIB_KEY_NET std::string socket_error_message(int error_num, SocketErrorScope scope);
inline std::string socket_last_error_message() { return socket_error_message(socket_last_error(), SocketErrorScope::Any); }
}
} | [
"[email protected]"
] | [
[
[
1,
22
]
]
] |
1250ff3886dc3a1250eb778ed0f7507d9112aec0 | 478570cde911b8e8e39046de62d3b5966b850384 | /apicompatanamdw/bcdrivers/os/devicesrv/SysLibs/ecom/src/T_ImplementationInformationData.cpp | d4fa571b8adf063533c083e5ff46ba6e86ae97c1 | [] | 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 | 10,391 | cpp | /*
* Copyright (c) 2006-2007 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:
*
*/
#include "T_ImplementationInformationData.h"
/*@{*/
/// Parameters
_LIT( KUid, "uid" );
_LIT( KExpectedString, "expected_string" );
_LIT( KExpectedResult, "expected" );
_LIT( KExpectedBool, "expected_bool" );
_LIT( KDisabled, "disabled" );
_LIT( KElement, "element" );
/// CImplementationInformation
_LIT( KCmdDisplayName, "DisplayName" );
_LIT( KCmdDataType, "DataType" );
_LIT( KCmdOpaqueData, "OpaqueData" );
_LIT( KCmdImplementationUid, "ImplementationUid" );
_LIT( KCmdVersion, "Version" );
_LIT( KCmdDisabled, "Disabled" );
_LIT( KCmdSetDisabled, "SetDisabled" );
_LIT( KCmdDrive, "Drive" );
_LIT( KCmdRomOnly, "RomOnly" );
_LIT( KCmdRomBased, "RomBased" );
_LIT( KCmdDestroy, "~" );
_LIT( KEmptyString, "");
/*@}*/
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CT_ImplementationInformationData* CT_ImplementationInformationData::NewL( )
{
CT_ImplementationInformationData* ret = new ( ELeave ) CT_ImplementationInformationData( );
CleanupStack::PushL( ret );
ret->ConstructL();
CleanupStack::Pop( ret );
return ret;
}
CT_ImplementationInformationData::CT_ImplementationInformationData( )
: iImplementationInformation(NULL)
{
}
void CT_ImplementationInformationData::ConstructL()
{
}
CT_ImplementationInformationData::~CT_ImplementationInformationData()
{
DestroyData();
}
void CT_ImplementationInformationData::DestroyData()
{
// this does not own iImplementationInformation
iImplementationInformation=NULL;
}
//////////////////////////////////////////////////////////////////////
// Read data from INI file
//////////////////////////////////////////////////////////////////////
TBool CT_ImplementationInformationData::GetUid( const TDesC& aSection, TUid& aUid )
{
TInt uidValue=0;
TBool ret=GetHexFromConfig( aSection, KUid(), uidValue ) ;
aUid = TUid::Uid( uidValue );
return ret;
}
TBool CT_ImplementationInformationData::GetExpectedString( const TDesC& aSection, TPtrC& aExpectedString)
{
aExpectedString.Set(KEmptyString);
return GetStringFromConfig( aSection, KExpectedString(), aExpectedString);
}
TBool CT_ImplementationInformationData::GetExpectedResult( const TDesC& aSection, TInt& aExpectedResult )
{
aExpectedResult = 0;
return GetIntFromConfig( aSection, KExpectedResult(), aExpectedResult );
}
TBool CT_ImplementationInformationData::GetExpectedHexResult( const TDesC& aSection, TInt& aExpectedResult)
{
aExpectedResult = 0;
return GetHexFromConfig( aSection, KExpectedResult(), aExpectedResult );
}
TBool CT_ImplementationInformationData::GetArrayElement(const TDesC& aSection, TInt& aArrayElement)
{
aArrayElement = 0;
return GetIntFromConfig( aSection, KElement(), aArrayElement);
}
TBool CT_ImplementationInformationData::GetExpectedBool( const TDesC& aSection, TBool& aBool )
{
aBool = EFalse;
return GetBoolFromConfig( aSection, KExpectedBool(), aBool );
}
TBool CT_ImplementationInformationData::GetDisabled( const TDesC& aSection, TBool& aDisabled )
{
aDisabled = EFalse;
return GetBoolFromConfig( aSection, KDisabled(), aDisabled );
}
/**
Test script command entry point
@internalComponent
@return Explanation of the object returned
@param aCommand descriptor containing the command value
@param aSection descriptor containing the command parameter
@pre N/A
@post N/A
*/
TBool CT_ImplementationInformationData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/)
{
TBool retVal = ETrue;
if ( aCommand == KCmdDestroy )
{
DoCmdDestroy();
}
else if ( aCommand == KCmdDisplayName )
{
DoCmdDisplayName( aSection );
}
else if ( aCommand == KCmdDataType )
{
DoCmdDataType( aSection );
}
else if ( aCommand == KCmdOpaqueData )
{
DoCmdOpaqueData( aSection );
}
else if ( aCommand == KCmdImplementationUid )
{
DoCmdImplementationUid( aSection );
}
else if ( aCommand == KCmdVersion )
{
DoCmdVersion( aSection );
}
else if ( aCommand == KCmdDisabled )
{
DoCmdDisabled( aSection );
}
else if ( aCommand == KCmdSetDisabled )
{
DoCmdSetDisabled( aSection );
}
else if ( aCommand == KCmdDrive )
{
DoCmdDrive( aSection );
}
else if ( aCommand == KCmdRomOnly )
{
DoCmdRomOnly( aSection );
}
else if ( aCommand == KCmdRomBased )
{
DoCmdRomBased( aSection );
}
else
{
retVal = EFalse;
}
return retVal;
}
void CT_ImplementationInformationData::DoCmdDisplayName(const TDesC& aSection)
{
TBuf<KMaxTestExecuteCommandLength> actualValue;
actualValue.Copy(iImplementationInformation->DisplayName());
TInt pos=actualValue.Find(_L("|"));
if (pos>0)
{
actualValue.Copy(actualValue.Left(pos));
};
INFO_PRINTF2(_L("DisplayName %S"), &actualValue);
TPtrC expectedValue;
if (GetExpectedString(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value \"%S\" does not match expected value \"%S\""), &actualValue, &expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdDataType(const TDesC& aSection)
{
TBuf<KMaxTestExecuteCommandLength> actualValue;
actualValue.Copy(iImplementationInformation->DataType());
TInt pos=actualValue.Find(_L("|"));
if (pos>0)
{
actualValue.Copy(actualValue.Left(pos));
};
INFO_PRINTF2(_L("DataType %S"), &actualValue);
TPtrC expectedValue;
if (GetExpectedString(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value \"%S\" does not match expected value \"%S\""), &actualValue, &expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdOpaqueData(const TDesC& aSection)
{
TBuf<KMaxTestExecuteCommandLength> actualValue;
actualValue.Copy(iImplementationInformation->OpaqueData());
TInt pos=actualValue.Find(_L("|"));
if (pos>0)
{
actualValue.Copy(actualValue.Left(pos));
};
INFO_PRINTF2(_L("OpaqueData %S"), &actualValue);
TPtrC expectedValue;
if (GetExpectedString(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value \"%S\" does not match expected value \"%S\""), &actualValue, &expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdImplementationUid(const TDesC& aSection)
{
TInt actualValue=iImplementationInformation->ImplementationUid().iUid;
INFO_PRINTF2(_L("ImplementationUid %d"), actualValue);
TInt expectedValue;
if (GetExpectedHexResult(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value %d does not match expected value %d"), actualValue, expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdVersion(const TDesC& aSection)
{
TInt actualValue=iImplementationInformation->Version();
INFO_PRINTF2(_L("Version %d"), actualValue);
TInt expectedValue;
if (GetExpectedResult(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value %d does not match expected value %d"), actualValue, expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdDisabled(const TDesC& aSection)
{
TBool actualValue=iImplementationInformation->Disabled();
INFO_PRINTF2(_L("Disabled %d"), actualValue);
TBool expectedValue;
if (GetExpectedBool(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value %d does not match expected value %d"), actualValue, expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdSetDisabled(const TDesC& aSection)
{
INFO_PRINTF1(_L("SetDisabled"));
TBool disabled;
if (!GetDisabled(aSection, disabled))
{
ERR_PRINTF1(_L("Not enought arguments"));
SetBlockResult( EFail );
}
else
{
iImplementationInformation->SetDisabled(disabled);
}
}
void CT_ImplementationInformationData::DoCmdDrive(const TDesC& aSection)
{
TDriveName actualValue(iImplementationInformation->Drive().Name());
INFO_PRINTF2(_L("Drive Name %s"), &actualValue);
TPtrC expectedValue;
if (GetExpectedString(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value \"%S\" does not match expected value \"%S\""), &actualValue, &expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdRomOnly(const TDesC& aSection)
{
TBool actualValue=iImplementationInformation->RomOnly();
INFO_PRINTF2(_L("RomOnly %d"), actualValue);
TBool expectedValue;
if (GetExpectedBool(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value %d does not match expected value %d"), actualValue, expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdRomBased(const TDesC& aSection)
{
TBool actualValue=iImplementationInformation->RomBased();
INFO_PRINTF2(_L("RomBased %d"), actualValue);
TBool expectedValue;
if (GetExpectedBool(aSection, expectedValue))
{
if (actualValue!=expectedValue)
{
ERR_PRINTF3(_L("Actual value %d does not match expected value %d"), actualValue, expectedValue);
SetBlockResult(EFail);
}
}
}
void CT_ImplementationInformationData::DoCmdDestroy()
{
INFO_PRINTF1( _L( "Destroyed" ) );
DestroyData();
}
| [
"none@none"
] | [
[
[
1,
375
]
]
] |
35e4ac138dd801c484b8d2b8bf00d7040eeb8411 | 4d838ba98a21fc4593652e66eb7df0fac6282ef6 | /CaveProj/Plane.cpp | 5bed2be945c6b829dc398d86e0728cf36ea42264 | [] | no_license | davidhart/ProceduralCaveEditor | 39ed0cf4ab4acb420fa2ad4af10f9546c138a83a | 31264591f2dcd250299049c826aeca18fc52880e | refs/heads/master | 2021-01-17T15:10:09.100572 | 2011-05-03T19:24:06 | 2011-05-03T19:24:06 | 69,302,913 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 145 | cpp | #include "Plane.h"
#include "Ray.h"
Plane::Plane(const Vector3f& origin, const Vector3f& normal) :
_origin(origin),
_normal(normal)
{
} | [
"[email protected]"
] | [
[
[
1,
8
]
]
] |
b59f27b6452bc1f8da3daae89eedaa0143b4ccdc | 38664d844d9fad34e88160f6ebf86c043db9f1c5 | /branches/initialize/cwf/httpserver2/request_parser.hpp | 5facd72ebfe7753ce18f49b057b4036e4466e6b5 | [] | 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 | 2,504 | hpp | //
// request_parser.hpp
// ~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// 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)
//
#ifndef HTTP_SERVER2_REQUEST_PARSER_HPP
#define HTTP_SERVER2_REQUEST_PARSER_HPP
#include <boost/logic/tribool.hpp>
#include <boost/tuple/tuple.hpp>
namespace http {
namespace server2 {
struct request;
/// Parser for incoming requests.
class request_parser
{
public:
/// Construct ready to parse the request method.
request_parser();
/// Reset to initial parser state.
void reset();
/// Parse some data. The tribool return value is true when a complete request
/// has been parsed, false if the data is invalid, indeterminate when more
/// data is required. The InputIterator return value indicates how much of the
/// input has been consumed.
template <typename InputIterator>
boost::tuple<boost::tribool, InputIterator> parse(request& req,
InputIterator begin, InputIterator end)
{
while (begin != end)
{
boost::tribool result = consume(req, *begin++);
if (result || !result)
return boost::make_tuple(result, begin);
}
boost::tribool result = boost::indeterminate;
return boost::make_tuple(result, begin);
}
private:
/// Handle the next character of input.
boost::tribool consume(request& req, char input);
/// Check if a byte is an HTTP character.
static bool is_char(int c);
/// Check if a byte is an HTTP control character.
static bool is_ctl(int c);
/// Check if a byte is defined as an HTTP tspecial character.
static bool is_tspecial(int c);
/// Check if a byte is a digit.
static bool is_digit(int c);
/// The current state of the parser.
enum state
{
method_start,
method,
uri_start,
uri,
http_version_h,
http_version_t_1,
http_version_t_2,
http_version_p,
http_version_slash,
http_version_major_start,
http_version_major,
http_version_minor_start,
http_version_minor,
expecting_newline_1,
header_line_start,
header_lws,
header_name,
space_before_header_value,
header_value,
expecting_newline_2,
expecting_newline_3
} state_;
};
} // namespace server2
} // namespace http
#endif // HTTP_SERVER2_REQUEST_PARSER_HPP
| [
"ken.shao@ba8f1dc9-3c1c-0410-9eed-0f8a660c14bd"
] | [
[
[
1,
96
]
]
] |
3230518c642e73e78aa5c2969c9f8f287d8233e8 | 619941b532c6d2987c0f4e92b73549c6c945c7e5 | /Include/RarPlugin/Storage/RarStream.h | 66fdc8c35bb98ccc3151300e5dc72ae214780e5d | [] | no_license | dzw/stellarengine | 2b70ddefc2827be4f44ec6082201c955788a8a16 | 2a0a7db2e43c7c3519e79afa56db247f9708bc26 | refs/heads/master | 2016-09-01T21:12:36.888921 | 2008-12-12T12:40:37 | 2008-12-12T12:40:37 | 36,939,169 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,162 | h | // //
// # # ### # # -= Nuclex Library =- //
// ## # # # ## ## RarStream.h - Rar compressed file implementation //
// ### # # ### //
// # ### # ### Accesses a compressed file and allows to read data //
// # ## # # ## ## from it through nuclex' stream interface //
// # # ### # # R1 (C)2002-2004 Markus Ewald -> License.txt //
// //
#ifndef NUCLEX_STORAGE_RARSTREAM_H
#define NUCLEX_STORAGE_RARSTREAM_H
#include "RarPlugin/RarPlugin.h"
#include "Nuclex/Support/String.h"
#include "Nuclex/Support/Exception.h"
#include "Nuclex/Storage/Stream.h"
#include <vector>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "UnRar/UnRar.h"
namespace Nuclex {
namespace Storage { class RarArchive; }
}
namespace Nuclex { namespace Storage {
// //
// Nuclex::Storage::RarStream //
// //
/// Rar data stream class
/** Performs
*/
class RarStream :
public Stream {
public:
/// Constructor
NUCLEXRAR_API RarStream(const RarArchive &RarArchive, const string &sArchiveName,
unsigned long nIndex, const string &sFilename, size_t nSize,
AccessMode eMode);
/// Destructor
NUCLEXRAR_API virtual ~RarStream();
//
// Stream implementation
//
public:
/// Get stream name
NUCLEXRAR_API string getName() const;
/// Get stream size
NUCLEXRAR_API size_t getSize() const;
/// Seek to position
NUCLEXRAR_API void seekTo(size_t nPos);
/// Current location
NUCLEXRAR_API size_t getLocation() const;
/// Read data
NUCLEXRAR_API size_t readData(void *pDest, size_t nBytes);
/// Write data
NUCLEXRAR_API size_t writeData(const void *pDest, size_t nBytes);
/// Retrieve access mode
NUCLEXRAR_API AccessMode getAccessMode() const;
/// Flush stream cache
NUCLEXRAR_API void flush();
private:
static int PASCAL RARCallbackProc(UINT nMessage, LONG nUserData,
LONG nParam1, LONG nParam2);
std::vector<unsigned char> m_Memory; ///< The uncompressed file
size_t m_nLoc; ///< Current read location
std::exception m_Exception; ///< Last exception occured
AccessMode m_eAccessMode; ///< Stream access mode
};
}} // namespace Nuclex::Storage
#endif // NUCLEX_STORAGE_RARSTREAM_H
| [
"ctuoMail@5f320639-c338-0410-82ad-c55551ec1e38"
] | [
[
[
1,
81
]
]
] |
0e3dfff4abc928c28e8bd2dfd04823c2040e7721 | 8cf9b251e0f4a23a6ef979c33ee96ff4bdb829ab | /src-ginga-editing/wac-editing-cpp/include/ILinkAction.h | 7369167cc6b15ca2839df581d8af2326fb2f6fa6 | [] | no_license | BrunoSSts/ginga-wac | 7436a9815427a74032c9d58028394ccaac45cbf9 | ea4c5ab349b971bd7f4f2b0940f2f595e6475d6c | refs/heads/master | 2020-05-20T22:21:33.645904 | 2011-10-17T12:34:32 | 2011-10-17T12:34:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,408 | h | /******************************************************************************
Este arquivo eh parte da implementacao do ambiente declarativo do middleware
Ginga (Ginga-NCL).
Copyright (C) 2009 UFSCar/Lince, Todos os Direitos Reservados.
Este programa eh software livre; voce pode redistribui-lo e/ou modificah-lo sob
os termos da Licenca Publica Geral GNU versao 2 conforme publicada pela Free
Software Foundation.
Este programa eh distribuido na expectativa de que seja util, porem, SEM
NENHUMA GARANTIA; nem mesmo a garantia implicita de COMERCIABILIDADE OU
ADEQUACAO A UMA FINALIDADE ESPECIFICA. Consulte a Licenca Publica Geral do
GNU versao 2 para mais detalhes.
Voce deve ter recebido uma copia da Licenca Publica Geral do GNU versao 2 junto
com este programa; se nao, escreva para a Free Software Foundation, Inc., no
endereco 59 Temple Street, Suite 330, Boston, MA 02111-1307 USA.
Para maiores informacoes:
[email protected]
http://www.ncl.org.br
http://www.ginga.org.br
http://lince.dc.ufscar.br
******************************************************************************
This file is part of the declarative environment of middleware Ginga (Ginga-NCL)
Copyright (C) 2009 UFSCar/Lince, Todos os Direitos Reservados.
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License version 2 as published by
the Free Software Foundation.
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 version 2 for more
details.
You should have received a copy of the GNU General Public License version 2
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
For further information contact:
[email protected]
http://www.ncl.org.br
http://www.ginga.org.br
http://lince.dc.ufscar.br
*******************************************************************************/
/**
* @file ILinkAction.h
* @author Caio Viel
* @date 29-01-10
*/
#ifndef ILINKACTION_H
#define ILINKACTION_H
#include "IObjectMode.h"
namespace br {
namespace ufscar {
namespace lince {
namespace ginga {
namespace wac {
namespace editing {
class IObjetcMode;
/**
* Interface pela qual é possivel obter informações sobre os links do módulo Formatter.
* Esta interface é necessária para se obter informações sobre os links a fim de determinar
* Se eles devem ou não ser disparados dependendo do modo de exibição atual.
*/
class ILinkAction {
public:
/**
* Destrói a instância de ILinkAction.
*/
virtual ~ILinkAction() {};
/**
* Retorna o tipo de elo.
* @return Tipo de Elo.
*/
virtual int getLinkType()=0;
/**
* Seta o tipo de elo.
* @param type Tipo de elo.
*/
virtual void setLinkType(int type)=0;
/**
* Seta o identificador do elo.
* @param linkId Identificador do elo.
*/
virtual void setLinkId(string linkId)=0;
/**
* Retorna o identificador do elo.
* @return Identificador do elo.
*/
virtual string getLinkId()=0;
/**
* Retorna o ExecutionObjet relacionado ao elo.
* @return ExectionObject Relacionado ao elo.
*/
virtual IObjetcMode* getOjetcMode()=0;
};
}
}
}
}
}
}
#endif //ILINKACTION_H
| [
"[email protected]"
] | [
[
[
1,
123
]
]
] |
1288a840fa810cdbb7806f0f09b7b17d9902c464 | 184455acbcc5ee6b2ee0c77c66b436375e1171e9 | /src/Resources.h | a359024828d07d37b3f94d2c3db62ec8d618e11c | [] | no_license | Karkasos/Core512 | d996d40e57be899e6c4c9aec106e371356152b36 | b83151ab284b7cf2e058fdd218dcc676946f43aa | refs/heads/master | 2020-04-07T14:19:51.907224 | 2011-11-01T06:46:20 | 2011-11-01T06:46:20 | 2,753,621 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 367 | h | #pragma once
#include <map>
#include "Texture.h"
class Resources
{
typedef std::map<const char*,void*> ResMap;
typedef std::pair<const char*,void*> ResMapPair;
typedef ResMap::iterator ResMapIterator;
ResMap vMap;
public:
~Resources();
Texture* GetTexture(const char* ResPath);
private:
bool Get(const char* ResPath, void*& Value);
};
| [
"[email protected]"
] | [
[
[
1,
19
]
]
] |
1a24410cf08acabd1c25e28de88a0e418a06b16d | b5ad65ebe6a1148716115e1faab31b5f0de1b493 | /src/AranPhy/SixDofJoint.cpp | aaa7759e3862562efff327b8c2661d88c30ec59e | [] | no_license | gasbank/aran | 4360e3536185dcc0b364d8de84b34ae3a5f0855c | 01908cd36612379ade220cc09783bc7366c80961 | refs/heads/master | 2021-05-01T01:16:19.815088 | 2011-03-01T05:21:38 | 2011-03-01T05:21:38 | 1,051,010 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 195 | cpp | #include "AranPhyPCH.h"
#include "SixDofJoint.h"
SixDofJoint::SixDofJoint(const OdeSpaceContext* osc)
: AngularJoint(osc)
, LinearJoint(osc)
{
}
SixDofJoint::~SixDofJoint(void)
{
}
| [
"[email protected]"
] | [
[
[
1,
12
]
]
] |
3284f70689c9ad6219cf0e7bc98f0a145e34dfe8 | 7d5dbe3ceb85833b9a2c2a2d1bfd71f2c772a01f | /include/IndependantItem.h | 4dd00f0832539928893b63572651507f0093c8d8 | [] | no_license | forivall-old-repos/opengl3-rg | a8e530f70c33e70088672d856faee387ebd728d3 | e4f9b7d356167e35b3a21f63ce227e266b306e99 | refs/heads/master | 2022-11-20T23:17:48.584560 | 2011-10-20T05:27:18 | 2011-10-20T05:27:18 | 281,288,584 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,146 | h | /*
* Item.h
*
* Created on: 2011-10-08
* Author: Jordan
*/
#include "Angel.h"
#ifndef ITEM_H_
#define ITEM_H_
#include "Guard.h"
#include "ShaderManager.h"
#include "ShaderRepr.h"
#include "GeometryReprImplGlrgShader.h"
#include <string>
#include <map>
namespace glrg {
class IndependantItem : public glrg::Guard
{
void construct(ShaderManager *);
protected:
GLenum drawMode;
ShaderRepr *shader;
GeometryRepr *geometry;
public:
IndependantItem();
IndependantItem(ShaderManager *);
virtual ~IndependantItem();
void setNumVerticies(GLsizei);
void setDrawMode(GLenum);
void setVertexData(const GLfloat*, GLsizeiptr, GLchar *);
void setVertexData(const GLfloat*, GLsizeiptr, GLuint);
void setVertexData(const vertexData_t &, GLuint);
void setUniformData(UNIFORM_TYPE type, const GLfloat *, GLchar *);
void setUniformData(UNIFORM_TYPE type, const GLfloat *, GLuint location);
void setShaderProgram(GLuint);
GeometryRepr *getGeometryRepr();
virtual void Draw();
};
}
#endif /* ITEM_H_ */
| [
"[email protected]"
] | [
[
[
1,
52
]
]
] |
f2ac09128eb3d0261e3f06b2c2f13c18f88cefa7 | ffadac985f616b08e142033e7acb1aa240f82fd4 | /src/ProjectionMatrix.cpp | bbf7dc4efce25f77a8398e3c4d732ae281d9c107 | [] | no_license | jfischoff/obido_math | 9184aea6e975db4164b6e973d0e4fd5b21d024ba | 5b892bf5c0615912613ef9719cb4e9944ab2c444 | refs/heads/master | 2016-09-06T06:18:49.577093 | 2011-10-11T14:53:37 | 2011-10-11T14:53:37 | 2,555,941 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,990 | cpp | #include "ProjectionMatrix.h"
void* ProjectionMatrix::Constructor()
{
return new ProjectionMatrix();
}
ProjectionMatrix::ProjectionMatrix()
{
}
ProjectionMatrix::ProjectionMatrix(const Vector3& near, const Vector3& far)
{
m_Near = near;
m_Far = far;
}
ProjectionMatrix::ProjectionMatrix(const ProjectionMatrix& other)
{
copy(other);
}
ProjectionMatrix& ProjectionMatrix::operator=(const ProjectionMatrix& other)
{
copy(other);
return *this;
}
void ProjectionMatrix::copy(const ProjectionMatrix& other)
{
m_Near = other.m_Near;
m_Far = other.m_Far;
}
void ProjectionMatrix::setFrustrum(const Vector3& near,
const Vector3& far)
{
m_Near = near;
m_Far = far;
}
void ProjectionMatrix::setFrustrum(Float nearX, Float nearY, Float nearZ,
Float farX, Float farY, Float farZ)
{
m_Near.setX(nearX);
m_Near.setY(nearY);
m_Near.setZ(nearZ);
m_Far.setX(farX);
m_Far.setY(farY);
m_Far.setZ(farZ);
}
Matrix4x4 ProjectionMatrix::getMatrix() const
{
//the idea is that the extents are setup so
//I need to make it so the farX and farY become as small as the nearX and nearY
Matrix4x4 projection = Matrix4x4::Identity();
double n = m_Near.getZ();
double r = m_Near.getX();
double t = m_Near.getY();
double f = m_Far.getZ();
double m00 = n / r;
double m11 = n / t;
double m22 = -(f + n) / (f - n);
double m23 = -1.0;
double m32 = (-2.0*f*n) / (f - n);
double m33 = 0.0;
projection.setElement(0, 0, m00);
projection.setElement(1, 1, m11);
projection.setElement(2, 2, m22);
projection.setElement(2, 3, m23);
projection.setElement(3, 2, m32);
projection.setElement(3, 3, m33);
return projection;
}
Float ProjectionMatrix::getNearZ() const
{
return m_Near.getZ();
}
Vector3 ProjectionMatrix::getNear()
{
return m_Near;
}
Vector3 ProjectionMatrix::getFar()
{
return m_Far;
}
| [
"[email protected]"
] | [
[
[
1,
103
]
]
] |
3e89d1d5a1ffb829fd540a80e809b826bfa48453 | c5534a6df16a89e0ae8f53bcd49a6417e8d44409 | /trunk/nGENE Proj/FileArchive.h | 6d300f8381c1db14d587362031336e3f20794050 | [] | no_license | svn2github/ngene | b2cddacf7ec035aa681d5b8989feab3383dac012 | 61850134a354816161859fe86c2907c8e73dc113 | refs/heads/master | 2023-09-03T12:34:18.944872 | 2011-07-27T19:26:04 | 2011-07-27T19:26:04 | 78,163,390 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,626 | h | /*
---------------------------------------------------------------------------
This source file is part of nGENE Tech.
Copyright (c) 2006- Wojciech Toman
This program is free software.
File: FileArchive.h
Version: 0.01
---------------------------------------------------------------------------
*/
#pragma once
#ifndef __INC_FILEARCHIVE_H_
#define __INC_FILEARCHIVE_H_
#include "FileManager.h"
#include "FileNarrow.h"
#include "Prerequisities.h"
namespace nGENE
{
/** This file class provides VFS functionality.
@remarks
It is base class.
*/
class nGENEDLL FileArchive: public FileNarrow
{
public:
FileArchive();
/** Constructs the File and opens it.
@param
_fileName wide char file name.
@param
_openMode combination of flags of OPEN_MODE type. You
can combine any of them.
*/
FileArchive(const wstring& _fileName, dword _openMode);
/// Copy constructor.
FileArchive(const FileArchive& src);
/// Closes and than releases wfstream.
virtual ~FileArchive();
/// Assignment operator.
FileArchive& operator=(const FileArchive& rhs);
/// Returns entry with the given name.
virtual VFS_ENTRY* getEntry(const string& _fileName)=0;
/// Checks if a specified entry exists in the archive.
virtual bool hasEntry(const string& _fileName)=0;
/// Inserts file to the archive when opened in OPEN_WRITE mode.
virtual void insertFile(IFile* _file)=0;
/// Initializes archive file.
virtual void init()=0;
/// Returns number of files in the archive
virtual uint getEntriesCount()=0;
};
}
#endif | [
"Riddlemaster@fdc6060e-f348-4335-9a41-9933a8eecd57"
] | [
[
[
1,
67
]
]
] |
fde077c0769ad6ff2e25e706c2c30d50c491ded2 | e59eeaca030f1fdf12cb79de0e646fafdaab2c64 | /DCPlot.h | 1046057f5fd709d1f448ff1f76c57f183503fee7 | [] | no_license | jcccf/hepth | 5215c5056845efb06601ad20ea975587bfa8463d | 093ad00ec8e833be8b8a7501245be09489887371 | refs/heads/master | 2021-01-22T09:54:57.305488 | 2010-12-05T04:16:15 | 2010-12-05T04:16:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 952 | h | #ifndef DCPLOT_H_
#define DCPLOT_H_
#include "stdafx.h"
#include <list>
#include <algorithm>
using namespace std;
///<summary>Manages plots of directed closures of PNGraphs</summary>
class DCPlot{
TGnuPlot* m_gp;
public:
DCPlot(TStr filename, TStr title);
TGnuPlot get();
///<summary>Plots integer points on a graph. If the list contains {3,6,9}, the points (0,3) (1,6) and (2,9) are plotted.</summary>
///<param name="columnWidth">The width of the sliding window to use.</param>
void plotLineFromList(TIntV ilist, TInt columnWidth = 100);
///<summary>Plots lists of integer points on a graph.</summary>
///<param name="columnWidth">The width of the sliding window to use.</param>
///<param name="withAverage">Whether to plot a mean line.</param>
void plotLinesFromList(TVec<TIntV> vilist, TInt columnWidth = 100, bool withAverage = false);
void savePNG(TStr xLabel, TStr yLabel);
~DCPlot();
};
#endif | [
"[email protected]"
] | [
[
[
1,
31
]
]
] |
82690b03f6957ac44504517af7fb0eaf75d96bd4 | b8fbe9079ce8996e739b476d226e73d4ec8e255c | /src/engine/rb_physics/colsphere.cpp | d8d07d56332c8d9a94d385a064055dc215bfffb6 | [] | no_license | dtbinh/rush | 4294f84de1b6e6cc286aaa1dd48cf12b12a467d0 | ad75072777438c564ccaa29af43e2a9fd2c51266 | refs/heads/master | 2021-01-15T17:14:48.417847 | 2011-06-16T17:41:20 | 2011-06-16T17:41:20 | 41,476,633 | 1 | 0 | null | 2015-08-27T09:03:44 | 2015-08-27T09:03:44 | null | UTF-8 | C++ | false | false | 1,838 | cpp | /***********************************************************************************/
// File: ColSphere.cpp
// Date: 25.08.2005
// Author: Ruslan Shestopalyuk
/***********************************************************************************/
#include "stdafx.h"
#include "ColSphere.h"
#include "PhysicsServer.h"
#include "OdeUtil.h"
/***********************************************************************************/
/* ColSphere implementation
/***********************************************************************************/
decl_class(ColSphere);
ColSphere::ColSphere()
{
m_Radius = 100.0f;
}
void ColSphere::Synchronize( bool bFromSolver )
{
ColGeom::Synchronize( bFromSolver );
if (!bFromSolver)
{
float scale = GetBodyScale()*PhysicsServer::s_pInstance->GetWorldScale();
dGeomSphereSetRadius( GetID(), m_Radius*scale );
}
} // ColSphere::Synchronize
void ColSphere::DrawBounds()
{
DWORD geomColor = PhysicsServer::s_pInstance->GetGeomColor();
DWORD linesColor = PhysicsServer::s_pInstance->GetGeomLinesColor();
Mat4 tm = GetTM();
g_pDrawServer->SetWorldTM( tm );
g_pDrawServer->SetZEnable( true );
g_pDrawServer->DrawSphere( Vec3::null, m_Radius, linesColor, geomColor );
g_pDrawServer->SetZEnable( false );
g_pDrawServer->Flush();
} // ColSphere::DrawBounds
dGeomID ColSphere::CreateGeom( dSpaceID spaceID )
{
float scale = PhysicsServer::s_pInstance->GetWorldScale();
return dCreateSphere( spaceID, m_Radius*scale );
} // ColSphere::CreateGeom
dMass ColSphere::GetMass() const
{
dMass m;
Convert( m.c, Vec4( 0, 0, 0, 1 ) );
float scale = PhysicsServer::s_pInstance->GetWorldScale();
dMassSetSphere( &m, GetDensity(), m_Radius*scale );
return m;
}
| [
"[email protected]"
] | [
[
[
1,
57
]
]
] |
092f0d54a31468822b438972f2afd4eb767b357b | be7df324d5509c7ebb368c884b53ea9445d32e4f | /GUI/Cardiac/SFScalarField.h | 4eb48478e917eb6f64135eae6b36064b5a45d0ad | [] | no_license | shadimsaleh/thesis.code | b75281001aa0358282e9cceefa0d5d0ecfffdef1 | 085931bee5b07eec9e276ed0041d494c4a86f6a5 | refs/heads/master | 2021-01-11T12:20:13.655912 | 2011-10-19T13:34:01 | 2011-10-19T13:34:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,652 | h | //////////////////////////////////////////////////////////////////////////////
//
// Author : Josh Grant
// Date : December 16th, 2001
// File : SFScalarField.h
// Description : Header file defining the SFScalarField class
//
//////////////////////////////////////////////////////////////////////////////
#ifndef _SF_SCALAR_FIELD_
#define _SF_SCALAR_FIELD_
#include <Inventor/fields/SoSubField.h>
#include <Inventor/SbLinear.h>
//////////////////////////////////////////////////////////////////////////////
//
// Class: SFScalarField
//
// Base class for all data fields. Even though this class can be
// instantiated it was meant to only serve as an abstract class. It offers
// the ability to add a data field to an Inventor node or engine so that the
// Database detects when it has been updated. It is very similar to the
// SoSFImage field, except for one major difference. It also has an option in
// the setValue() function for copying the data or not. This is very useful
// when setting a field from an Engine. It can greatly improve the
// performance time of interactive tools.
//
// The copy option works by either copying all the data or just saving the
// pointer to the data. Of course this will only work if the memory the
// pointer references isn't deleted.
//
//////////////////////////////////////////////////////////////////////////////
class SFScalarField : public SoSField {
// Inventor defined macros for subclassing SoSField
SO_SFIELD_REQUIRED_HEADER(SFScalarField);
SO_SFIELD_CONSTRUCTOR_HEADER(SFScalarField);
public:
static void initClass ();
// set the dimensions, number of dimensions, number of data components and
// the pointer to the data, triggers a valueChanged() to Inventor
void setValue (const int dm[3], float *ptr, bool copyData=true);
// get the data value, triggers an evaluate() to Inventor
float * getValue (int dm[3]) const;
// the following functions do not trigger any Inventor calls
float * getDataPtr () const {return data;}
const int * getDims () const {return dims;}
int getNumValues () const {return numValues;}
bool getDataCopied () const {return dataCopied;}
void getMinMax (float &min, float &max) const;
void allocateSpace (const int dm[3]);
int operator == (const SFScalarField &d) const;
int operator != (const SFScalarField &d) const
{ return !((*this) == d); }
protected:
// used to maintain the dimensions of the data.
int dims[3];
// these variables are here just to keep the code general, currently they
// are just constants
int numComponents;
int numDimensions;
// current number of values being managed, this is the product of all the
// dimension values times the number of components.
int numValues;
// pointer to data
float *data;
private:
// used to determine if the data was copied over to this field or if this
// field just points to it somewhere else
bool dataCopied;
// whenever the data is copied space is allocated. this variable is used
// to keep track of how many values have been allocated. This way if data
// of the same or smaller size needs to be copied, we don't need to
// allocate more memory.
int valuesAllocated;
// pointer to allocated array.
float *myData;
virtual SbBool readValue (SoInput *in);
virtual void writeValue (SoOutput *out) const;
};
#endif /* _SF_SCALAR_FIELD_ */
| [
"[email protected]"
] | [
[
[
1,
97
]
]
] |
e9d563d40de6886ad25f11b17f73c70f7a33bf78 | 48a185f4f05cc5dff3a6253b2e73664554a64a25 | /src/md5.h | 373adb5a0ba6d511ce093ef992b369cdff2d7a72 | [] | no_license | flice/QQ2005 | b2a6ef6b7827c3c5ebee5b2acf00d792b360d5f3 | df90907fb209f8d4cd61e3dd94755ee051a22f5f | refs/heads/master | 2020-03-27T03:07:13.390666 | 2011-11-17T17:52:09 | 2011-11-18T14:59:03 | 145,839,766 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,305 | h | #ifndef MD5_H_
#define MD5_H_
#include <string>
#include <fstream>
#include <cstring>
#include "def.h"
using std::string;
using std::ifstream;
/* MD5 declaration. */
class MD5
{
public:
MD5();
MD5(const void* input, size_t length);
MD5(const string& str);
MD5(ifstream& in);
void update(const void* input, size_t length);
void update(const string& str);
void update(ifstream& in);
const uint8_t* digest();
string to_string();
void reset();
private:
void update(const uint8_t* input, size_t length);
void final();
void transform(const uint8_t block[64]);
void encode(const uint32_t* input, uint8_t* output, size_t length);
void decode(const uint8_t* input, uint32_t* output, size_t length);
string bytes_to_hex_string(const uint8_t* input, size_t length);
/* class uncopyable */
MD5(const MD5&);
MD5& operator=(const MD5&);
private:
uint32_t _state[4]; /* state (ABCD) */
uint32_t _count[2]; /* number of bits, modulo 2^64 (low-order word first) */
uint8_t _buffer[64]; /* input buffer */
uint8_t _digest[16]; /* message digest */
bool _finished; /* calculate finished ? */
static const uint8_t PADDING[64]; /* padding for calculate */
static const char HEX[16];
static const size_t BUFFER_SIZE;
};
#endif /* MD5_H_ */
| [
"[email protected]"
] | [
[
[
1,
51
]
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.