text:
@implementation egwImage

static egwTextureJumpTable _egwTJT = { NULL };
static egwRenderableJumpTable _egwRJT = { NULL };

+ (id)allocWithZone:(NSZone*)zone {
    NSObject* inst = (NSObject*)[super allocWithZone:zone];

    if(!_egwTJT.fpRetain && [inst isMemberOfClass:[egwImage class]]) {
        _egwTJT.fpRetain = (id(*)(id, SEL))[inst methodForSelector:@selector(retain)];
        _egwTJT.fpRelease = (void(*)(id, SEL))[inst methodForSelector:@selector(release)];
        _egwTJT.fpTBind = (BOOL(*)(id, SEL, EGWuint, EGWuint))[inst methodForSelector:@selector(bindForTexturingStage:withFlags:)];
        _egwTJT.fpTUnbind = (BOOL(*)(id, SEL, EGWuint))[inst methodForSelector:@selector(unbindTexturingWithFlags:)];
        _egwTJT.fpTBase = (id<NSObject>(*)(id, SEL))[inst methodForSelector:@selector(textureBase)];
        _egwTJT.fpTID = (const EGWuint*(*)(id, SEL))[inst methodForSelector:@selector(textureID)];
        _egwTJT.fpTSync = (egwValidater*(*)(id, SEL))[inst methodForSelector:@selector(texturingSync)];
        _egwTJT.fpTLBStage = (EGWuint(*)(id, SEL))[inst methodForSelector:@selector(lastTexturingBindingStage)];
        _egwTJT.fpOpaque = (BOOL(*)(id, SEL))[inst methodForSelector:@selector(isOpaque)];
        _egwRJT.fpRetain = (id(*)(id, SEL))[inst methodForSelector:@selector(retain)];
        _egwRJT.fpRelease = (void(*)(id, SEL))[inst methodForSelector:@selector(release)];
        _egwRJT.fpRender = (void(*)(id, SEL, EGWuint))[inst methodForSelector:@selector(renderWithFlags:)];
        _egwRJT.fpRBase = (id<NSObject>(*)(id, SEL))[inst methodForSelector:@selector(renderingBase)];
        _egwRJT.fpRFlags = (EGWuint32(*)(id, SEL))[inst methodForSelector:@selector(renderingFlags)];
        _egwRJT.fpRFrame = (EGWuint16(*)(id, SEL))[inst methodForSelector:@selector(renderingFrame)];
        _egwRJT.fpRSource = (const egwVector4f*(*)(id, SEL))[inst methodForSelector:@selector(renderingSource)];
        _egwRJT.fpRSync = (egwValidater*(*)(id, SEL))[inst methodForSelector:@selector(renderingSync)];
        _egwRJT.fpLStack = (egwLightStack*(*)(id, SEL))[inst methodForSelector:@selector(lightStack)];
        _egwRJT.fpMStack = (egwMaterialStack*(*)(id, SEL))[inst methodForSelector:@selector(materialStack)];
        _egwRJT.fpSStack = (egwShaderStack*(*)(id, SEL))[inst methodForSelector:@selector(shaderStack)];
        _egwRJT.fpTStack = (egwTextureStack*(*)(id, SEL))[inst methodForSelector:@selector(textureStack)];
        _egwRJT.fpSetRFrame = (void(*)(id, SEL, EGWuint16))[inst methodForSelector:@selector(setRenderingFrame:)];
        _egwRJT.fpOpaque = (BOOL(*)(id, SEL))[inst methodForSelector:@selector(isOpaque)];
        _egwRJT.fpRendering = (BOOL(*)(id, SEL))[inst methodForSelector:@selector(isRendering)];
    }

    return (id)inst;
}

- (id)init {
    if([self isMemberOfClass:[egwImage class]]) { [self release]; return (self = nil); }
    return (self = [super init]);
}

- (id)initWithIdentity:(NSString*)assetIdent imageSurface:(egwSurface*)surface imageWidth:(EGWuint16)width imageHeight:(EGWuint16)height geometryStorage:(EGWuint)storage textureEnvironment:(EGWuint)environment texturingTransforms:(EGWuint)transforms texturingFilter:(EGWuint)filter lightStack:(egwLightStack*)lghtStack materialStack:(egwMaterialStack*)mtrlStack shaderStack:(egwShaderStack*)shdrStack {
    if(!(self = [super init])) { [self release]; return (self = nil); }

    if(!(_base = [[egwImageBase alloc] initWithIdentity:assetIdent imageSurface:surface imageWidth:width imageHeight:height geometryStorage:storage texturingTransforms:transforms texturingFilter:filter])) { [self release]; return (self = nil); }
    if(!(_ident = [[NSString alloc] initWithFormat:@"%@_default", assetIdent])) { [self release]; return (self = nil); }

    _rFlags = EGW_GFXOBJ_RNDRFLG_DFLT;
    _rFrame = EGW_FRAME_ALWAYSPASS;
    if(!(_rSync = [[egwValidater alloc] initWithOwner:self coreObjectTypes:[self coreObjectTypes]])) { [self release]; return (self = nil); }
    if(!(_lStack = (lghtStack ? [lghtStack retain] : [[egwLightStack alloc] init]))) { [self release]; return (self = nil); }
    if(!(_mStack = (mtrlStack ? [mtrlStack retain] : [[egwSIEngine defaultMaterialStack] retain]))) { [self release]; return (self = nil); }
    _sStack = (shdrStack ? [shdrStack retain] : nil);

    _isEnabled = _isVisible = YES;

    _lastTBind = NSNotFound;
    _texEnv = environment;
    if(!(_tSync = [[egwValidater alloc] initWithOwner:self coreObjectTypes:[self coreObjectTypes]])) { [self release]; return (self = nil); }

    egwMatCopy44f(&egwSIMatIdentity44f, &_lcsTrans);
    egwMatCopy44f(&egwSIMatIdentity44f, &_wcsTrans);
    if(!(_wcsRBVol = [(NSObject*)[_base renderingBounding] copy])) { [self release]; return (self = nil); }

    _texID = [_base textureID];
    _mcsTrans = [_base mcsTransform];
    _iMesh = [_base widgetMesh];
    _geoAID = [_base geometryArraysID];

    return self;
}

- (id)initBlankWithIdentity:(NSString*)assetIdent surfaceFormat:(EGWuint32)format imageWidth:(EGWuint16)width imageHeight:(EGWuint16)height geometryStorage:(EGWuint)storage textureEnvironment:(EGWuint)environment texturingTransforms:(EGWuint)transforms texturingFilter:(EGWuint)filter lightStack:(egwLightStack*)lghtStack materialStack:(egwMaterialStack*)mtrlStack shaderStack:(egwShaderStack*)shdrStack {
    if(!(self = [super init])) { [self release]; return (self = nil); }

    if(!(_base = [[egwImageBase alloc] initBlankWithIdentity:assetIdent surfaceFormat:format imageWidth:width imageHeight:height geometryStorage:storage texturingTransforms:transforms texturingFilter:filter])) { [self release]; return (self = nil); }
    if(!(_ident = [[NSString alloc] initWithFormat:@"%@_default", assetIdent])) { [self release]; return (self = nil); }

    _rFlags = EGW_GFXOBJ_RNDRFLG_DFLT;
    _rFrame = EGW_FRAME_ALWAYSPASS;
    if(!(_rSync = [[egwValidater alloc] initWithOwner:self coreObjectTypes:[self coreObjectTypes]])) { [self release]; return (self = nil); }
    if(!(_lStack = (lghtStack ? [lghtStack retain] : [[egwLightStack alloc] init]))) { [self release]; return (self = nil); }
    if(!(_mStack = (mtrlStack ? [mtrlStack retain] : [[egwSIEngine defaultMaterialStack] retain]))) { [self release]; return (self = nil); }
    _sStack = (shdrStack ? [shdrStack retain] : nil);

    _isEnabled = _isVisible = YES;

    _lastTBind = NSNotFound;
    _texEnv = environment;
    if(!(_tSync = [[egwValidater alloc] initWithOwner:self coreObjectTypes:[self coreObjectTypes]])) { [self release]; return (self = nil); }

    egwMatCopy44f(&egwSIMatIdentity44f, &_lcsTrans);
    egwMatCopy44f(&egwSIMatIdentity44f, &_wcsTrans);
    if(!(_wcsRBVol = [(NSObject*)[_base renderingBounding] copy])) { [self release]; return (self = nil); }

    _texID = [_base textureID];
    _mcsTrans = [_base mcsTransform];
    _iMesh = [_base widgetMesh];
    _geoAID = [_base geometryArraysID];

    return self;
}

- (id)initLoadedFromResourceFile:(NSString*)resourceFile withIdentity:(NSString*)assetIdent imageWidth:(EGWuint16)width imageHeight:(EGWuint16)height geometryStorage:(EGWuint)storage textureEnvironment:(EGWuint)environment texturingTransforms:(EGWuint)transforms texturingFilter:(EGWuint)filter lightStack:(egwLightStack*)lghtStack materialStack:(egwMaterialStack*)mtrlStack shaderStack:(egwShaderStack*)shdrStack {
    egwSurface surface; memset((void*)&surface, 0, sizeof(egwSurface));

    if(!([egwSIAsstMngr loadSurface:&surface fromFile:resourceFile withTransforms:(transforms & ~EGW_SURFACE_TRFM_ENSRPOW2)])) {
        if(surface.data) egwSrfcFree(&surface);
        [self release]; return (self = nil);
    }

    if(!(self = [self initWithIdentity:assetIdent imageSurface:&surface imageWidth:width imageHeight:height geometryStorage:storage textureEnvironment:environment texturingTransforms:(transforms | EGW_SURFACE_TRFM_ENSRPOW2) texturingFilter:filter lightStack:lghtStack materialStack:mtrlStack shaderStack:shdrStack])) {
        if(surface.data) egwSrfcFree(&surface);
        return nil;
    }

    return self;
}

- (id)initCopyOf:(id<egwPWidget>)widget withIdentity:(NSString*)assetIdent {
    if(!([widget isKindOfClass:[self class]]) || !(self = [super init])) { [self release]; return (self = nil); }

    if(!(_base = (egwImageBase*)[[(egwImage*)widget assetBase] retain])) { [self release]; return (self = nil); }
    if(!(_ident = [assetIdent retain])) { [self release]; return (self = nil); }

    _rFlags = [(egwImage*)widget renderingFlags];
    _rFrame = EGW_FRAME_ALWAYSPASS;
    if(!(_rSync = [[egwValidater alloc] initWithOwner:self coreObjectTypes:[self coreObjectTypes]])) { [self release]; return (self = nil); }
    if(!(_lStack = [[widget lightStack] retain])) { [self release]; return (self = nil); }
    if(!(_mStack = [[widget materialStack] retain])) { [self release]; return (self = nil); }
    _sStack = [[widget shaderStack] retain];

    _isEnabled = [widget isEnabled];
    _isVisible = [widget isVisible];

    _lastTBind = NSNotFound;
    _texEnv = [widget textureEnvironment];
    if(!(_tSync = [[egwValidater alloc] initWithOwner:self coreObjectTypes:[self coreObjectTypes]])) { [self release]; return (self = nil); }

    egwMatCopy44f([(egwImage*)widget wcsTransform], &_wcsTrans);
    egwMatCopy44f([(egwImage*)widget lcsTransform], &_lcsTrans);
    if(!(_wcsRBVol = [(NSObject*)[(egwImage*)widget renderingBounding] copy])) { [self release]; return (self = nil); }
    if([(id<egwPOrientated>)widget offsetDriver] && ![self trySetOffsetDriver:[(id<egwPOrientated>)widget offsetDriver]]) { [self release]; return (self = nil); }
    if([(id<egwPOrientated>)widget orientateDriver] && ![self trySetOrientateDriver:[(id<egwPOrientated>)widget orientateDriver]]) { [self release]; return (self = nil); }

    _texID = [_base textureID];
    _mcsTrans = [_base mcsTransform];
    _iMesh = [_base widgetMesh];
    _geoAID = [_base geometryArraysID];

    return self;
}

- (id)copyWithZone:(NSZone*)zone {
    egwImage* copy = nil;
    NSString* copyIdent = nil;

    if([_ident hasSuffix:@"_default"])
        copyIdent = [[NSString alloc] initWithFormat:@"%@_%d", [_base identity], [_base nextInstanceIndex]];
    else copyIdent = [[NSString alloc] initWithFormat:@"copy_%@", _ident];

    if(!(copy = [[egwImage allocWithZone:zone] initCopyOf:self
                                             withIdentity:copyIdent])) {
        NSLog(@"egwImage: copyWithZone: Failure initializing new image from instance asset '%@' (%p). Failure creating copy.", _ident, self);
        [copyIdent release]; copyIdent = nil;
        return nil;
    } else { [copyIdent release]; copyIdent = nil; }

    return copy;
}

- (void)dealloc {
    if(_isTBound) [self unbindTexturingWithFlags:EGW_BNDOBJ_BINDFLG_DFLT];

    [_lStack release]; _lStack = nil;
    [_mStack release]; _mStack = nil;
    [_sStack release]; _sStack = nil;
    [_rSync release]; _rSync = nil;

    [_wcsRBVol release]; _wcsRBVol = nil;

    if(_lcsIpo) { [_lcsIpo removeTargetWithObject:self]; [_lcsIpo release]; _lcsIpo = nil; }
    if(_wcsIpo) { [_wcsIpo removeTargetWithObject:self]; [_wcsIpo release]; _wcsIpo = nil; }

    _texID = NULL;
    _mcsTrans = NULL;
    _iMesh = NULL;
    _geoAID = NULL;

    [_tSync release]; _tSync = nil;

    [_delegate release]; _delegate = nil;
    if(_parent) [self setParent:nil];
    [_ident release]; _ident = nil;
    [_base release]; _base = nil;

    [super dealloc];
}

- (void)applyOrientation {
    if(_ortPending && !_invkParent) {
        _invkParent = YES;

        [(id<egwPOrientated>)_parent applyOrientation]; // NOTE: Because the parent contains self, it will always be an orientated branch line, also parents never call a child's applyOrientation method -jw

        egwMatrix44f twcsTrans;
        if(!(_rFlags & EGW_OBJEXTEND_FLG_ALWAYSOTGHMG))
            egwMatMultiply44f(&_wcsTrans, &_lcsTrans, &twcsTrans);
        else
            egwMatMultiplyHmg44f(&_wcsTrans, &_lcsTrans, &twcsTrans);

        [_wcsRBVol orientateByTransform:&twcsTrans fromVolume:[_base renderingBounding]];

        _ortPending = NO;

        if((EGW_NODECMPMRG_GRAPHIC & (EGW_CORECMP_TYPE_BVOLS | EGW_CORECMP_TYPE_SOURCES | EGW_CORECMP_TYPE_SYNCS)) &&
           _parent && ![_parent isInvokingChild]) {
            EGWuint cmpntTypes = (((_rFlags & EGW_OBJTREE_FLG_NOUMRGBVOLS) || [_wcsRBVol class] == [egwZeroBounding class]) ? 0 : EGW_CORECMP_TYPE_BVOLS & EGW_NODECMPMRG_GRAPHIC) |
                                   (_rFlags & EGW_OBJTREE_FLG_NOUMRGSYNCS ? 0 : EGW_CORECMP_TYPE_SOURCES & EGW_NODECMPMRG_GRAPHIC) |
                                   (_rFlags & EGW_OBJTREE_FLG_NOUMRGSOURCES ? 0 : EGW_CORECMP_TYPE_SYNCS & EGW_NODECMPMRG_GRAPHIC);
            if(cmpntTypes)
                [_parent performSelector:@selector(mergeCoreComponentTypes:forCoreObjectTypes:) withObject:(id)cmpntTypes withObject:(id)[self coreObjectTypes] inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
        }

        _invkParent = NO;
    }
}

- (BOOL)bindForTexturingStage:(EGWuint)txtrStage withFlags:(EGWuint)flags {
    // NOTE: The code below is non-abstracted OpenGLES dependent. Staying this way till ES2. -jw
    if(!_isTBound || (flags & EGW_BNDOBJ_BINDFLG_APISYNCINVLD) || egwSFPVldtrIsInvalidated(_tSync, @selector(isInvalidated))) {
        GLenum texture = GL_TEXTURE0 + (_lastTBind = txtrStage);

        //glActiveTexture(texture);
        egw_glClientActiveTexture(texture);

        if(!(flags & EGW_BNDOBJ_BINDFLG_SAMELASTBASE)) {
            if(_texID && *_texID) {
                egw_glBindTexture(texture, GL_TEXTURE_2D, (GLuint)*_texID);
                //glFinish();
            } else return NO;
        }

        //if(!_isTBound || (flags & EGW_BNDOBJ_BINDFLG_APISYNCINVLD) || egwSFPVldtrIsInvalidated(_tSync, @selector(isInvalidated)))
            egw_glBindEnvironment(_texEnv);

        _isTBound = YES;
        egwSFPVldtrValidate(_tSync, @selector(validate));
        return YES;
    }

    return NO;
}

- (BOOL)unbindTexturingWithFlags:(EGWuint)flags {
    // NOTE: The code below is non-abstracted OpenGLES dependent. Staying this way till ES2. -jw
    if(_isTBound) {
        if(flags & EGW_BNDOBJ_BINDFLG_TOGGLE) {
            GLenum texture = GL_TEXTURE0 + _lastTBind;
            //glActiveTexture(texture);
            egw_glClientActiveTexture(texture);
            egw_glBindTexture(texture, GL_TEXTURE_2D, (GLuint)NSNotFound);
            //glFinish();
        }

        _isTBound = NO;
        return YES;
    }

    return NO;
}

- (void)illuminateWithLight:(id<egwPLight>)light {
    [_lStack addLight:light sortByPosition:(egwVector3f*)[_wcsRBVol boundingOrigin]];
}

- (void)offsetByTransform:(const egwMatrix44f*)lcsTransform {
    egwMatCopy44f(lcsTransform, &_lcsTrans);

    _ortPending = YES;

    egwSFPVldtrInvalidate(_rSync, @selector(invalidate));
}

- (void)orientateByTransform:(const egwMatrix44f*)wcsTransform {
    egwMatCopy44f(wcsTransform, &_wcsTrans);

    _ortPending = YES;

    egwSFPVldtrInvalidate(_rSync, @selector(invalidate));
}

- (void)orientateByImpending {
    _ortPending = YES;

    egwSFPVldtrInvalidate(_rSync, @selector(invalidate));
}

- (void)startRendering {
    [egwSIGfxRdr renderObject:self]; // TODO: Replace with call to world scene.
}

- (void)stopRendering {
    [egwSIGfxRdr removeObject:self]; // TODO: Replace with call to world scene.
}

- (void)renderWithFlags:(EGWuint32)flags {
    // NOTE: The code below is non-abstracted OpenGLES dependent. Staying this way till ES2. -jw
    if(flags & EGW_GFXOBJ_RPLYFLY_DORENDERPASS) {
        if(_isVisible) {
            if(_lStack) egwSFPLghtStckPushAndBindLights(_lStack, @selector(pushAndBindLights));
            else egwAFPGfxCntxBindLights(egwAIGfxCntx, @selector(bindLights));
            if(_mStack) egwSFPMtrlStckPushAndBindMaterials(_mStack, @selector(pushAndBindMaterials));
            else egwAFPGfxCntxBindMaterials(egwAIGfxCntx, @selector(bindMaterials));
            if(_sStack) egwSFPShdrStckPushAndBindShaders(_sStack, @selector(pushAndBindShaders));
            else egwAFPGfxCntxBindShaders(egwAIGfxCntx, @selector(bindShaders));
            egwAFPGfxCntxPushTexture(egwAIGfxCntx, @selector(pushTexture:withTextureJumpTable:), self, &_egwTJT);
            egwAFPGfxCntxBindTextures(egwAIGfxCntx, @selector(bindTextures));

            if(_isTBound) {
                glPushMatrix();

                glMultMatrixf((const GLfloat*)&_wcsTrans);
                glMultMatrixf((const GLfloat*)&_lcsTrans);
                glMultMatrixf((const GLfloat*)_mcsTrans);

                if(*_geoAID) {
                    if(egw_glBindBuffer(GL_ARRAY_BUFFER, *_geoAID) || !(flags & EGW_GFXOBJ_RPLYFLG_SAMELASTBASE)) {
                        glVertexPointer((GLint)3, GL_FLOAT, (GLsizei)0, (const GLvoid*)(EGWuintptr)0);
                        glNormalPointer(GL_FLOAT, (GLsizei)0, (const GLvoid*)(EGWuintptr)((EGWuint)sizeof(egwVector3f) * 4));
                        glTexCoordPointer((GLint)2, GL_FLOAT, (GLsizei)0, (const GLvoid*)(EGWuintptr)((EGWuint)sizeof(egwVector3f) * 4 * 2));
                    }
                } else {
                    if(egw_glBindBuffer(GL_ARRAY_BUFFER, 0) || !(flags & EGW_GFXOBJ_RPLYFLG_SAMELASTBASE)) {
                        glVertexPointer((GLint)3, GL_FLOAT, (GLsizei)0, (const GLvoid*)&_iMesh->vCoords[0]);
                        glNormalPointer(GL_FLOAT, (GLsizei)0, (const GLvoid*)&_iMesh->nCoords[0]);
                        glTexCoordPointer((GLint)2, GL_FLOAT, (GLsizei)0, (const GLvoid*)&_iMesh->tCoords[0]);
                    }
                }

                glDrawArrays(GL_TRIANGLE_FAN, 0, (GLsizei)4);

                glPopMatrix();
            }

            egwAFPGfxCntxPopTextures(egwAIGfxCntx, @selector(popTextures:), 1);
            if(_sStack) egwSFPShdrStckPopShaders(_sStack, @selector(popShaders));
            if(_mStack) egwSFPMtrlStckPopMaterials(_mStack, @selector(popMaterials));
            if(_lStack) egwSFPLghtStckPopLights(_lStack, @selector(popLights));
        }
    } else if(flags & EGW_GFXOBJ_RPLYFLG_DORENDERSTART) {
        _isRendering = YES;

        if(_delegate)
            [_delegate widget:self did:EGW_ACTION_START];
    } else if(flags & EGW_GFXOBJ_RPLYFLG_DORENDERSTOP) {
        _isRendering = NO;

        egwSFPVldtrInvalidate(_rSync, @selector(invalidate));

        if(_delegate)
            [_delegate widget:self did:EGW_ACTION_STOP];
    }
}

- (id<egwPAssetBase>)assetBase {
    return (id<egwPAssetBase>)_base;
}

- (EGWuint)coreObjectTypes {
    return (EGW_COREOBJ_TYPE_GRAPHIC | EGW_COREOBJ_TYPE_ORIENTABLE | EGW_COREOBJ_TYPE_TEXTURE | EGW_COREOBJ_TYPE_WIDGET);
}

- (egwValidater*)geometryBufferSync {
    return [_base geometryBufferSync];
}

- (EGWuint)geometryStorage {
    return [_base geometryStorage];
}

- (NSString*)identity {
    return _ident;
}

- (EGWuint)lastTexturingBindingStage {
    return _lastTBind;
}

- (const egwRenderableJumpTable*)renderableJumpTable {
    return &_egwRJT;
}

- (egwLightStack*)lightStack {
    return _lStack;
}

- (egwMaterialStack*)materialStack {
    return _mStack;
}

- (egwShaderStack*)shaderStack {
    return _sStack;
}

- (const EGWuint*)textureID {
    return _texID;
}

- (egwTextureStack*)textureStack {
    return nil;
}

- (id<egwPInterpolator>)offsetDriver {
    return _lcsIpo;
}

- (id<egwPInterpolator>)orientateDriver {
    return _wcsIpo;
}

- (id<NSObject>)renderingBase {
    return (id<NSObject>)_base;
}

- (id<egwPBounding>)renderingBounding {
    return _wcsRBVol;
}

- (EGWuint32)renderingFlags {
    return _rFlags;
}

- (EGWuint16)renderingFrame {
    return _rFrame;
}

- (const egwVector4f*)renderingSource {
    return [_wcsRBVol boundingOrigin];
}

- (egwValidater*)renderingSync {
    return _rSync;
}

- (egwValidater*)textureBufferSync {
    return [_base textureBufferSync];
}

- (const egwTextureJumpTable*)textureJumpTable {
    return &_egwTJT;
}

- (id<NSObject>)textureBase {
    return (id<NSObject>)_base;
}

- (EGWuint)textureEnvironment {
    return _texEnv;
}

- (EGWuint)texturingFilter {
    return [_base texturingFilter];
}

- (egwValidater*)texturingSync {
    return _tSync;
}

- (EGWuint)texturingTransforms {
    return [_base texturingTransforms];
}

- (EGWuint16)texturingSWrap {
    return [_base texturingSWrap];
}

- (EGWuint16)texturingTWrap {
    return [_base texturingTWrap];
}

- (const egwMatrix44f*)lcsTransform {
    return &_lcsTrans;
}

- (const egwMatrix44f*)wcsTransform {
    return &_wcsTrans;
}

- (const egwSize2i*)widgetSize {
    return [_base widgetSize];
}

- (id<egwPObjectBranch>)parent {
    return _parent;
}

- (id<egwPObjectBranch>)root {
    return (_parent ? [_parent root] : nil);
}

- (void)setDelegate:(id<egwDWidgetEvent>)delegate {
    [delegate retain];
    [_delegate release];
    _delegate = delegate;
}

- (void)setParent:(id<egwPObjectBranch>)parent {
	if(_parent != parent && (id)_parent != (id)self && !_invkParent) {
		[self retain];

		if(_parent && ![_parent isInvokingChild]) {
			_invkParent = YES;
			[_parent removeChild:self];
			[_parent performSelector:@selector(decrementCoreObjectTypes:countBy:) withObject:(id)[self coreObjectTypes] withObject:(id)1 inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
			[_parent performSelector:@selector(mergeCoreComponentTypes:forCoreObjectTypes:) withObject:(id)EGW_CORECMP_TYPE_ALL withObject:(id)[self coreObjectTypes] inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
			_invkParent = NO;
		}

        if(parent && _wcsIpo) {
            NSLog(@"egwImage: setParent: Warning: Object system is overriding WCS interpolator driver for instance asset '%@' (%p).", _ident, self);
            [self trySetOrientateDriver:nil];
        }

		_parent = parent; // NOTE: Weak reference, do not retain! -jw

		if(_parent && ![_parent isInvokingChild]) {
			_invkParent = YES;
			[_parent addChild:self];
			[_parent performSelector:@selector(incrementCoreObjectTypes:countBy:) withObject:(id)[self coreObjectTypes] withObject:(id)1 inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
			[_parent performSelector:@selector(mergeCoreComponentTypes:forCoreObjectTypes:) withObject:(id)EGW_CORECMP_TYPE_ALL withObject:(id)[self coreObjectTypes] inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
			_invkParent = NO;
		}

		[self release];
	}
}

- (void)setEnabled:(BOOL)enable {
    _isEnabled = enable;
}

- (void)setLightStack:(egwLightStack*)lghtStack {
    if(lghtStack && _lStack != lghtStack) {
        [lghtStack retain];
        [_lStack release];
        _lStack = lghtStack;

        egwSFPVldtrInvalidate(_rSync, @selector(invalidate));
    }
}

- (void)setMaterialStack:(egwMaterialStack*)mtrlStack {
    if(mtrlStack && _mStack != mtrlStack) {
        [mtrlStack retain];
        [_mStack release];
        _mStack = mtrlStack;

        egwSFPVldtrInvalidate(_rSync, @selector(invalidate));
    }
}

- (void)setShaderStack:(egwShaderStack*)shdrStack {
    [shdrStack retain];
    [_sStack release];
    _sStack = shdrStack;

    egwSFPVldtrInvalidate(_rSync, @selector(invalidate));
}

- (void)setTextureStack:(egwTextureStack*)txtrStack {
    return;
}

- (void)setRenderingFlags:(EGWuint)flags {
	_rFlags = flags;

	if((EGW_NODECMPMRG_GRAPHIC & EGW_CORECMP_TYPE_FLAGS) &&
	   _parent && !_invkParent && ![_parent isInvokingChild]) {
		_invkParent = YES;
		EGWuint cmpntTypes = (_rFlags & EGW_OBJTREE_FLG_NOUMRGFLAGS ? 0 : EGW_CORECMP_TYPE_FLAGS & EGW_NODECMPMRG_GRAPHIC);
		if(cmpntTypes)
			[_parent performSelector:@selector(mergeCoreComponentTypes:forCoreObjectTypes:) withObject:(id)cmpntTypes withObject:(id)[self coreObjectTypes] inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
		_invkParent = NO;
	}
}

- (void)setRenderingFrame:(EGWint)frmNumber {
	_rFrame = frmNumber;

	if((EGW_NODECMPMRG_GRAPHIC & EGW_CORECMP_TYPE_FRAMES) &&
	   _parent && !_invkParent && ![_parent isInvokingChild]) {
		_invkParent = YES;
		EGWuint cmpntTypes = (_rFlags & EGW_OBJTREE_FLG_NOUMRGFRAMES ? 0 : EGW_CORECMP_TYPE_FRAMES & EGW_NODECMPMRG_GRAPHIC);
		if(cmpntTypes)
			[_parent performSelector:@selector(mergeCoreComponentTypes:forCoreObjectTypes:) withObject:(id)cmpntTypes withObject:(id)[self coreObjectTypes] inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
		_invkParent = NO;
	}
}

- (void)setVisible:(BOOL)visible {
    _isVisible = visible;

    egwSFPVldtrInvalidate(_rSync, @selector(invalidate));
}

- (BOOL)trySetGeometryDataPersistence:(BOOL)persist {
    return [_base trySetGeometryDataPersistence:persist];
}

- (BOOL)trySetGeometryStorage:(EGWuint)storage {
    return [_base trySetGeometryStorage:storage];
}

- (BOOL)trySetOffsetDriver:(id<egwPInterpolator>)lcsIpo {
    if(lcsIpo) {
        if(([lcsIpo isKindOfClass:[egwOrientationInterpolator class]]) ||
           ([lcsIpo isKindOfClass:[egwValueInterpolator class]] && [(egwValueInterpolator*)lcsIpo channelCount] == 16 && [(egwValueInterpolator*)lcsIpo channelFormat] == EGW_KEYCHANNEL_FRMT_SINGLE)) {
            [_lcsIpo removeTargetWithObject:self];
            [lcsIpo retain];
            [_lcsIpo release];
            _lcsIpo = lcsIpo;
            [_lcsIpo addTargetWithObject:self method:@selector(offsetByTransform:)];

            return YES;
        }
    } else {
        [_lcsIpo removeTargetWithObject:self];
        [_lcsIpo release]; _lcsIpo = nil;

        return YES;
    }

    return NO;
}

- (BOOL)trySetOrientateDriver:(id<egwPInterpolator>)wcsIpo {
    if(wcsIpo) {
        if(!_parent &&
           (([wcsIpo isKindOfClass:[egwOrientationInterpolator class]]) ||
            ([wcsIpo isKindOfClass:[egwValueInterpolator class]] && [(egwValueInterpolator*)wcsIpo channelCount] == 16 && [(egwValueInterpolator*)wcsIpo channelFormat] == EGW_KEYCHANNEL_FRMT_SINGLE))) {
            [_wcsIpo removeTargetWithObject:self];
            [wcsIpo retain];
            [_wcsIpo release];
            _wcsIpo = wcsIpo;
            [_wcsIpo addTargetWithObject:self method:@selector(orientateByTransform:)];

            return YES;
        }
    } else {
        [_wcsIpo removeTargetWithObject:self];
        [_wcsIpo release]; _wcsIpo = nil;

        return YES;
    }

    return NO;
}

- (BOOL)trySetTextureDataPersistence:(BOOL)persist {
    return [_base trySetTextureDataPersistence:persist];
}

- (BOOL)trySetTextureEnvironment:(EGWuint)environment {
    _texEnv = environment;

    egwSFPVldtrInvalidate(_tSync, @selector(invalidate));

    return YES;
}

- (BOOL)trySetTexturingFilter:(EGWuint)filter {
    return [_base trySetTexturingFilter:filter];
}

- (BOOL)trySetTexturingWrapS:(EGWuint16)sWrap {
    return [_base trySetTexturingWrapS:sWrap];
}

- (BOOL)trySetTexturingWrapT:(EGWuint16)tWrap {
    return [_base trySetTexturingWrapT:tWrap];
}

- (BOOL)isChildOf:(id<egwPObjectBranch>)parent {
    return (_parent == parent ? YES : NO);
}

- (BOOL)isGeometryDataPersistent {
    return [_base isGeometryDataPersistent];
}

- (BOOL)isInvokingParent {
    return _invkParent;
}

- (BOOL)isLeaf {
    return YES;
}

- (BOOL)isOrientationPending {
    return _ortPending;
}

- (BOOL)isRendering {
    return _isRendering;
}

- (BOOL)isBoundForTexturing {
    return _isTBound;
}

- (BOOL)isEnabled {
    return _isEnabled;
}

- (BOOL)isOpaque {
    return !(_rFlags & EGW_GFXOBJ_RNDRFLG_ISTRANSPARENT) && ((_rFlags & EGW_GFXOBJ_RNDRFLG_ISOPAQUE) || ((([_base widgetSurface]->format & EGW_SURFACE_FRMT_EXAC) ? NO : ((!_mStack || egwSFPMtrlStckOpaque(_mStack, @selector(isOpaque))) && (!_sStack || egwSFPShdrStckOpaque(_sStack, @selector(isOpaque)))))));
}

- (BOOL)isTextureDataPersistent {
    return [_base isTextureDataPersistent];
}

- (BOOL)isVisible {
    return _isVisible;
}

- (void)validaterDidValidate:(egwValidater*)validater {
    if(_ortPending) [self applyOrientation];

    if(_rSync == validater &&
       (EGW_NODECMPMRG_GRAPHIC & EGW_CORECMP_TYPE_SYNCS) &&
       _parent && !_invkParent && ![_parent isInvokingChild]) {
        _invkParent = YES;
        EGWuint cmpntTypes = (_rFlags & EGW_OBJTREE_FLG_NOUMRGSYNCS ? 0 : EGW_OBJTREE_FLG_NOUMRGSYNCS & EGW_NODECMPMRG_GRAPHIC);
        if(cmpntTypes)
            [_parent performSelector:@selector(mergeCoreComponentTypes:forCoreObjectTypes:) withObject:(id)cmpntTypes withObject:(id)[validater coreObjects] inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
        _invkParent = NO;
    }
}

- (void)validaterDidInvalidate:(egwValidater*)validater {
    if(_rSync == validater &&
       (EGW_NODECMPMRG_GRAPHIC & EGW_CORECMP_TYPE_SYNCS) &&
       _parent && !_invkParent && ![_parent isInvokingChild]) {
        _invkParent = YES;
        EGWuint cmpntTypes = (_rFlags & EGW_OBJTREE_FLG_NOUMRGSYNCS ? 0 : EGW_OBJTREE_FLG_NOUMRGSYNCS & EGW_NODECMPMRG_GRAPHIC);
        if(cmpntTypes)
            [_parent performSelector:@selector(mergeCoreComponentTypes:forCoreObjectTypes:) withObject:(id)cmpntTypes withObject:(id)[validater coreObjects] inDirection:EGW_NODEMSG_DIR_BREADTHUPWARDS];
        _invkParent = NO;
    }
}

@end

// !!!: ***** egwImageBase *****

@implementation egwImageBase

+ (id)allocWithZone:(NSZone*)zone {
    id alloc = [super allocWithZone:zone];
    if(alloc) [egwAssetManager incBaseRef];
    if(EGW_ENGINE_ASSETS_CREATIONMSGS) NSLog(@"egwImageBase: allocWithZone: Creating new image base asset (%p).", alloc);
    return alloc;
}

- (id)init {
    if([self isMemberOfClass:[egwImageBase class]]) { [self release]; return (self = nil); }
    return (self = [super init]);
}

- (id)initWithIdentity:(NSString*)assetIdent imageSurface:(egwSurface*)surface imageWidth:(EGWuint16)width imageHeight:(EGWuint16)height geometryStorage:(EGWuint)storage texturingTransforms:(EGWuint)transforms texturingFilter:(EGWuint)filter {
    egwSize2i maxTexSize; memcpy((void*)&maxTexSize, (const void*)[egwAIGfxCntx maxTextureSize], sizeof(egwSize2i));

    if(!(surface && surface->data && !(surface->format & EGW_SURFACE_FRMT_EXPLT) &&
         surface->size.span.width <= maxTexSize.span.width && surface->size.span.height <= maxTexSize.span.height &&
         (self = [super init]))) { [self release]; return (self = nil); }

    if(!(_ident = [assetIdent retain])) { [self release]; return (self = nil); }

    _geoStrg = storage;
    if(!(_gbSync = [[egwValidater alloc] initWithOwner:self validation:(_geoStrg & EGW_GEOMETRY_STRG_EXVBO ? NO : YES) coreObjectTypes:EGW_COREOBJ_TYPE_INTERNAL])) { [self release]; return (self = nil); }

    if(!(_tbSync = [[egwValidater alloc] initWithOwner:self validation:NO coreObjectTypes:EGW_COREOBJ_TYPE_INTERNAL])) { [self release]; return (self = nil); }
    _texID = NSNotFound;
    _texTrans = transforms;
    _texFltr = filter;

    egwMatCopy44f(&egwSIMatIdentity44f, &_mcsTrans);
    if(!(_mmcsRBVol = [[egwBoundingBox alloc] init])) { [self release]; return (self = nil); }

    memcpy((void*)&_iSrfc, (const void*)surface, sizeof(egwSurface));
    memset((void*)surface, 0, sizeof(egwSurface));

    // Assign appropriate width and height (or auto-assign)
    // NOTE: This auto-assignment won't be accurate in the case of pre-upscaled-to-pow2 images. No fix possible. -jw
    {   register EGWuint16 autoWidth = _iSrfc.size.span.width;
        register EGWuint16 autoHeight = _iSrfc.size.span.height;

        if(!width || width > autoWidth) width = autoWidth;
        if(!height || height > autoHeight) height = autoHeight;
    }

    _iSize.span.width = width;
    _iSize.span.height = height;

    // Smudge extend to power-of-2 surface
    if(!(_iSrfc.format & EGW_SURFACE_FRMT_EXCMPRSD) &&
       !(egwIsPow2ui((EGWuint)_iSrfc.size.span.width) && egwIsPow2ui((EGWuint)_iSrfc.size.span.height)) &&
       !(egwSrfcSmdgExtd(egwRoundUpPow2ui16(_iSrfc.size.span.width),
                         egwRoundUpPow2ui16(_iSrfc.size.span.height),
                         &_iSrfc, &_iSrfc))) { [self release]; return (self = nil); }

    egwWdgtMeshBVInit(&_iMesh, _mmcsRBVol, ((_iSrfc.format & EGW_SURFACE_FRMT_EXAC) && !(_iSrfc.format & EGW_SURFACE_FRMT_EXCMPRSD) ? YES : NO), &_iSize, &_iSrfc.size);

    if(!([egwAIGfxCntxAGL isActive] && [self performSubTaskForComponent:egwAIGfxCntxAGL forSync:_tbSync])) // Attempt to load, if context active on this thread
        [egwAIGfxCntx addSubTask:self forSync:_tbSync]; // Delayed load for context sub task to handle

    if((_geoStrg & EGW_GEOMETRY_STRG_EXVBO) && !([egwAIGfxCntxAGL isActive] && [self performSubTaskForComponent:egwAIGfxCntxAGL forSync:_gbSync])) // Attempt to load, if context active on this thread
        [egwAIGfxCntx addSubTask:self forSync:_gbSync]; // Delayed load for context sub task to handle

    return self;
}

- (id)initBlankWithIdentity:(NSString*)assetIdent surfaceFormat:(EGWuint32)format imageWidth:(EGWuint16)width imageHeight:(EGWuint16)height geometryStorage:(EGWuint)storage texturingTransforms:(EGWuint)transforms texturingFilter:(EGWuint)filter {
    egwSize2i maxTexSize; memcpy((void*)&maxTexSize, (const void*)[egwAIGfxCntx maxTextureSize], sizeof(egwSize2i));

    if(!(width && width <= maxTexSize.span.width && height && height <= maxTexSize.span.height && (self = [super init]))) { [self release]; return (self = nil); }
    if(!format) format = EGW_SURFACE_FRMT_R8G8B8A8;
    format = egwFormatFromSrfcTrfm(transforms, format);
    if(!(format == EGW_SURFACE_FRMT_GS8 || format == EGW_SURFACE_FRMT_GS8A8 || format == EGW_SURFACE_FRMT_R5G6B5 || format == EGW_SURFACE_FRMT_R5G5B5A1 || format == EGW_SURFACE_FRMT_R4G4B4A4 || format == EGW_SURFACE_FRMT_R8G8B8 || format == EGW_SURFACE_FRMT_R8G8B8A8)) { [self release]; return (self = nil); }

    if(!(_ident = [assetIdent retain])) { [self release]; return (self = nil); }

    _iSize.span.width = width;
    _iSize.span.height = height;

    _geoStrg = storage;
    if(!(_gbSync = [[egwValidater alloc] initWithOwner:self validation:(_geoStrg & EGW_GEOMETRY_STRG_EXVBO ? NO : YES) coreObjectTypes:EGW_COREOBJ_TYPE_INTERNAL])) { [self release]; return (self = nil); }

    if(!(_tbSync = [[egwValidater alloc] initWithOwner:self validation:YES coreObjectTypes:EGW_COREOBJ_TYPE_INTERNAL])) { [self release]; return (self = nil); }
    _texID = NSNotFound;
    _texTrans = transforms;
    _texFltr = filter;

    egwMatCopy44f(&egwSIMatIdentity44f, &_mcsTrans);
    if(!(_mmcsRBVol = [[egwBoundingBox alloc] init])) { [self release]; return (self = nil); }

    if(!(egwSrfcAlloc(&_iSrfc, format, egwRoundUpPow2ui16(_iSize.span.width), egwRoundUpPow2ui16(_iSize.span.height), (EGWuint16)egwBytePackingFromSrfcTrfm(transforms, EGW_SURFACE_DFLTBPACKING)))) { [self release]; return (self = nil); }

    egwWdgtMeshBVInit(&_iMesh, _mmcsRBVol, ((_iSrfc.format & EGW_SURFACE_FRMT_EXAC) && !(_iSrfc.format & EGW_SURFACE_FRMT_EXCMPRSD) ? YES : NO), &_iSize, &_iSrfc.size);

    if((_geoStrg & EGW_GEOMETRY_STRG_EXVBO) && !([egwAIGfxCntxAGL isActive] && [self performSubTaskForComponent:egwAIGfxCntxAGL forSync:_gbSync])) // Attempt to load, if context active on this thread
        [egwAIGfxCntx addSubTask:self forSync:_gbSync]; // Delayed load for context sub task to handle

    // NOTE: Delayed load will occur on buffer sync invalidation. -jw

    return self;
}

- (id)copyWithZone:(NSZone*)zone {
    return nil;
}

- (id)mutableCopyWithZone:(NSZone*)zone {
    return nil;
}

- (void)dealloc {
    if(_texID && _texID != NSNotFound)
        _texID = [egwAIGfxCntxAGL returnUsedTextureID:_texID];
    if(_geoAID)
        _geoAID = [egwAIGfxCntxAGL returnUsedBufferID:_geoAID];

    egwSrfcFree(&_iSrfc);

    [_tbSync release]; _tbSync = nil;

    [_gbSync release]; _gbSync = nil;

    [_mmcsRBVol release]; _mmcsRBVol = nil;

    if(EGW_ENGINE_ASSETS_DESTROYMSGS) NSLog(@"egwImageBase: dealloc: Destroying image base asset '%@' (%p).", _ident, self);
    [_ident release]; _ident = nil;
    [egwAssetManager decBaseRef];
    [super dealloc];
}

- (void)baseOffsetByTransform:(const egwMatrix44f*)transform {
    egwMatMultiply44f(&_mcsTrans, transform, &_mcsTrans);
    [_mmcsRBVol baseOffsetByTransform:transform];
}

- (void)baseOffsetByZeroAlign:(EGWuint)zfAlign {
    egwVector3f offset, min, max;
    egwMatrix44f transform;

    // NOTE: Since mesh is not directly transformed by _mcsTrans and vCoords are distortion offsetted -> rebuild vCoords get offsets. -jw

    {   egwVector3f vCoords[4];
        EGWsingle thalfWidth = (EGWsingle)_iSize.span.width * 0.5f;
        EGWsingle thalfHeight = (EGWsingle)_iSize.span.height * 0.5f;
        vCoords[0].axis.x = -thalfWidth; vCoords[0].axis.y = -thalfHeight; vCoords[0].axis.z = 0.0f;
        vCoords[1].axis.x =  thalfWidth; vCoords[1].axis.y = -thalfHeight; vCoords[1].axis.z = 0.0f;
        vCoords[2].axis.x =  thalfWidth; vCoords[2].axis.y =  thalfHeight; vCoords[2].axis.z = 0.0f;
        vCoords[3].axis.x = -thalfWidth; vCoords[3].axis.y =  thalfHeight; vCoords[3].axis.z = 0.0f;
        egwVecTransform443fv(&_mcsTrans, (egwVector3f*)&vCoords, &egwSIOnef, (egwVector3f*)&vCoords, -sizeof(egwMatrix44f), 0, -sizeof(EGWsingle), 0, 4);
        egwVecFindExtentsAxs3fv((egwVector3f*)&vCoords, &min, &max, 0, 4);
    }

    switch(zfAlign & EGW_GFXOBJ_ZFALIGN_EXX) {
        case EGW_GFXOBJ_ZFALIGN_XMIN: {
            offset.axis.x = -min.axis.x;
        } break;
        case EGW_GFXOBJ_ZFALIGN_XCTR: {
            offset.axis.x = -((min.axis.x + max.axis.x) * 0.5f);
        } break;
        case EGW_GFXOBJ_ZFALIGN_XMAX: {
            offset.axis.x = -max.axis.x;
        } break;
        default: offset.axis.x = 0.0f;
    }

    switch(zfAlign & EGW_GFXOBJ_ZFALIGN_EXY) {
        case EGW_GFXOBJ_ZFALIGN_YMIN: {
            offset.axis.y = -min.axis.y;
        } break;
        case EGW_GFXOBJ_ZFALIGN_YCTR: {
            offset.axis.y = -((min.axis.y + max.axis.y) * 0.5f);
        } break;
        case EGW_GFXOBJ_ZFALIGN_YMAX: {
            offset.axis.y = -max.axis.y;
        } break;
        default: offset.axis.y = 0.0f;
    }

    switch(zfAlign & EGW_GFXOBJ_ZFALIGN_EXZ) {
        case EGW_GFXOBJ_ZFALIGN_ZMIN: {
            offset.axis.z = -min.axis.z;
        } break;
        case EGW_GFXOBJ_ZFALIGN_ZCTR: {
            offset.axis.z = -((min.axis.z + max.axis.z) * 0.5f);
        } break;
        case EGW_GFXOBJ_ZFALIGN_ZMAX: {
            offset.axis.z = -max.axis.z;
        } break;
        default: offset.axis.z = 0.0f;
    }

    egwMatTranslate44f(NULL, &offset, &transform);
    if(zfAlign & EGW_GFXOBJ_ZFALIGN_EXINV)
        egwMatScale44fs(&transform, (zfAlign & EGW_GFXOBJ_ZFALIGN_XINV ? -1.0f : 1.0f), (zfAlign & EGW_GFXOBJ_ZFALIGN_YINV ? -1.0f : 1.0f), (zfAlign & EGW_GFXOBJ_ZFALIGN_ZINV ? -1.0f : 1.0f), &transform);

    [self baseOffsetByTransform:&transform];
}

- (BOOL)performSubTaskForComponent:(id<NSObject>)component forSync:(egwValidater*)sync {
    if((id)component == (id)egwAIGfxCntxAGL) {
        if(_tbSync == sync && _iSrfc.data) {
            egwSurface usageSurface; memcpy((void*)&usageSurface, (const void*)&_iSrfc, sizeof(egwSurface));

            if(_isTDPersist && (_texFltr & EGW_TEXTURE_FLTR_EXDSTRYP)) {
                // Use temporary space for texture filters that destroy surface if persistence needs to be maintained
                if(!(usageSurface.data = (EGWbyte*)malloc(((size_t)usageSurface.pitch * (size_t)usageSurface.size.span.height)))) {
                    NSLog(@"egwImageBase: performSubTaskForComponent:forSync: Failure allocating %lu bytes for temporary image surface. Failure buffering widget texture for asset '%@' (%p).", ((size_t)usageSurface.pitch * (size_t)usageSurface.size.span.height), _ident, self);
                    return NO;
                } else
                    memcpy((void*)usageSurface.data, (const void*)_iSrfc.data, ((size_t)usageSurface.pitch * (size_t)usageSurface.size.span.height));
            }

            if([egwAIGfxCntxAGL loadTextureID:&_texID withSurface:&usageSurface texturingTransforms:_texTrans texturingFilter:_texFltr texturingSWrap:EGW_TEXTURE_WRAP_CLAMP texturingTWrap:EGW_TEXTURE_WRAP_CLAMP]) {
                if(usageSurface.data && usageSurface.data != _iSrfc.data) {
                    free((void*)usageSurface.data); usageSurface.data = NULL;
                }

                egwSFPVldtrValidate(_tbSync, @selector(validate)); // Event delegate will dealloc if not persistent

                return YES; // Done with this item, no other work left
            } else
                NSLog(@"egwImageBase: performSubTaskForComponent:forSync: Failure buffering widget texture for asset '%@' (%p).", _ident, self);

            if(usageSurface.data && usageSurface.data != _iSrfc.data) {
                free((void*)usageSurface.data); usageSurface.data = NULL;
            }

            return NO; // Failure to load, try again next time
        } else if(_gbSync == sync && (_geoStrg & EGW_GEOMETRY_STRG_EXVBO)) {
            if([egwAIGfxCntxAGL loadBufferArraysID:&_geoAID withSQVAMesh:&_iMesh geometryStorage:_geoStrg]) {
                egwSFPVldtrValidate(_gbSync, @selector(validate)); // Event delegate will dealloc if not persistent

                return YES; // Done with this item, no other work left
            } else
                NSLog(@"egwImageBase: performSubTaskForComponent:forSync: Failure buffering geometry mesh for asset '%@' (%p).", _ident, self);

            return NO; // Failure to load, try again next time
        }
    }

    return YES; // Nothing to do
}

- (const EGWuint*)geometryArraysID {
    return &_geoAID;
}

- (egwValidater*)geometryBufferSync {
    return _gbSync;
}

- (EGWuint)geometryStorage {
    return _geoStrg;
}

- (NSString*)identity {
    return _ident;
}

- (const egwMatrix44f*)mcsTransform {
    return &_mcsTrans;
}

- (EGWuint)nextInstanceIndex {
    return ++_instCounter;
}

- (id<egwPBounding>)renderingBounding {
    return _mmcsRBVol;
}

- (egwValidater*)textureBufferSync {
    return _tbSync;
}

- (const EGWuint*)textureID {
    return &_texID;
}

- (EGWuint)texturingFilter {
    return _texFltr;
}

- (EGWuint)texturingTransforms {
    return _texTrans;
}

- (EGWuint16)texturingSWrap {
    return EGW_TEXTURE_WRAP_CLAMP;
}

- (EGWuint16)texturingTWrap {
    return EGW_TEXTURE_WRAP_CLAMP;
}

- (const egwSQVAMesh4f*)widgetMesh {
    return &_iMesh;
}

- (const egwSize2i*)widgetSize {
    return &_iSize;
}

- (const egwSurface*)widgetSurface {
    return &_iSrfc;
}

- (BOOL)trySetGeometryDataPersistence:(BOOL)persist {
    // Not supported
    return NO;
}

- (BOOL)trySetGeometryStorage:(EGWuint)storage {
    _geoStrg = storage;

    egwSFPVldtrInvalidate(_gbSync, @selector(invalidate));

    return YES;
}

- (BOOL)trySetTextureDataPersistence:(BOOL)persist {
    _isTDPersist = persist;

    if(!_isTDPersist && egwSFPVldtrIsValidated(_tbSync, @selector(isValidated))) {
        if(_iSrfc.data) {
            free((void*)_iSrfc.data); _iSrfc.data = NULL;
        }
    }

    return YES;
}

- (BOOL)trySetTexturingFilter:(EGWuint)filter {
    if(!_iSrfc.data)
        return NO;

    _texFltr = filter;
    egwSFPVldtrInvalidate(_tbSync, @selector(invalidate));
    return YES;
}

- (BOOL)trySetTexturingWrapS:(EGWuint16)sWrap {
    // Not supported
    return NO;
}

- (BOOL)trySetTexturingWrapT:(EGWuint16)tWrap {
    // Not supported
    return NO;
}

- (BOOL)isGeometryDataPersistent {
    return YES;
}

- (BOOL)isTextureDataPersistent {
    return _isTDPersist;
}

- (void)validaterDidValidate:(egwValidater*)validater {
    if(_tbSync == validater) {
        if(!_isTDPersist && _iSrfc.data) { // Persistence check & dealloc
            // NOTE: The widget surface is still used even after image data is deleted - do not free the surface! -jw
            free((void*)_iSrfc.data); _iSrfc.data = NULL;
        }
    }
}

- (void)validaterDidInvalidate:(egwValidater*)validater {
    if(_tbSync == validater) {
        if(_iSrfc.data) // Buffer image data up through context
            [egwAIGfxCntx addSubTask:self forSync:_tbSync];
        else
            egwSFPVldtrValidate(_tbSync, @selector(validate));
    } else if(_gbSync == validater) {
        if(_geoStrg & EGW_GEOMETRY_STRG_EXVBO) // Buffer mesh data up through context
            [egwAIGfxCntx addSubTask:self forSync:_gbSync];
        else
            egwSFPVldtrValidate(_gbSync, @selector(validate));
    }
}

@end


text:
package io.dropwizard.metrics;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * A MetricNameFormatter is used to convert a {@link MetricName} into a string.
 */
public interface MetricNameFormatter {

    /**
     * Format the given {@link MetricName} into a String
     * @param name the MetricName to format
     * @return the formatted string from the MetricName
     */
    public String formatMetricName(MetricName name);

    /**
     * A {@link MetricNameFormatter} that will only use the name part of the {@link MetricName} and
     * ignore all tags
     */
    public static final MetricNameFormatter NAME_ONLY = name -> name.getKey();

    /**
     * A {@link MetricNameFormatter} that will invoke {@link MetricName#toString()}
     */
    public static final MetricNameFormatter METRIC_NAME_TOSTRING =name -> name.toString();

    /**
     * A {@link MetricNameFormatter} that will append tag names and values to the metric string.
     * The tags are sorted by tag key and then appended in sorted order to the name.
     * For example: foo.bar.time[m=b,d=e] will result in foo.bar.time.d.e.m.b
     */
    public static final MetricNameFormatter APPEND_TAGS = name -> {
        StringBuilder sb = new StringBuilder(name.getKey());
        Map<String,String> tags = name.getTags();
        List<String> tagNames = new ArrayList<>(tags.keySet());
        Collections.sort(tagNames);
        tagNames.forEach( tag -> {
            sb.append(".");
            sb.append(tag);
            sb.append(".");
            sb.append(tags.get(tag));
        });

        return sb.toString();
    };

    /**
     * A {@link MetricNameFormatter} that will append only the values to the metric string. The
     * tag values are sorted and then appended in sorted order.
     * For example: foo.bar.time[m=b,d=e,f=a] will result in foo.bar.time.a.b.e
     */
    public static final MetricNameFormatter APPEND_TAG_VALUES = name -> {
        StringBuilder sb = new StringBuilder(name.getKey());
        List<String> tagValues = new ArrayList<>(name.getTags().values());
        Collections.sort(tagValues);
        tagValues.forEach( value -> {
            sb.append(".");
            sb.append(value);
        });

        return sb.toString();
    };

}

redpajama_set_name: RedPajamaGithub


text:
import IconCancel from "binary-ui-icons/binary/Cancel";
import IconDone from "binary-ui-icons/binary/Done";
import React from "react";

import { storiesOf } from "@storybook/react";
import { action } from "@storybook/addon-actions";
import { withInfo } from "@storybook/addon-info";

import StackPage from "binary-ui-stack";

const { height, width } = { height: 500, width: 400 };

storiesOf("Examples", module).add(
  "stack page empty clickable",
  withInfo("")(() => (
    <div style={{ height, width }}>
      <style>
        {`html, body, #CardsApp { width: 100%; height: 100%; } body {  margin: 0; background-color: #eeeae5; }`}
      </style>
      <StackPage
        headerButtonLeft={{
          isDisabled: true,
          renderIcon: props => <IconCancel {...props} />,
          onClick: action()
        }}
        headerButtonRight={{
          isDisabled: true,
          renderIcon: props => <IconDone {...props} />,
          onClick: action()
        }}
        headerTitle={{
          children: "Custom Stack",
          isActionable: true
        }}
        pageHeight={height}
        searchValue=""
        onOpenDone={action()}
        onCloseDone={action()}
      >
        Stack Empty
      </StackPage>
    </div>
  ))
);


text:
"""
Kay URL dispatch setting.

:Copyright: (c) 2009 Accense Technology, Inc. All rights reserved.
:license: BSD, see LICENSE for more details.
"""

from werkzeug.routing import (
  Map, Rule, Submount,
  EndpointPrefix, RuleTemplate,
)

def make_url():
  return Map([
    Rule('/_ah/queue/deferred', endpoint='deferred'),
  ])

all_views = {
  'deferred': 'kay.handlers.task.task_handler',
}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<title></title>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<link rel="stylesheet" type="text/css" href="search.css"/>

Loading...

  k100
  Steinberg::Vst::SpeakerArr

  k101
  Steinberg::Vst::SpeakerArr

  k101MPEG3D
  Steinberg::Vst::SpeakerArr

  k102
  Steinberg::Vst::SpeakerArr

  k110
  Steinberg::Vst::SpeakerArr

  k111
  Steinberg::Vst::SpeakerArr

  k122
  Steinberg::Vst::SpeakerArr

  k130
  Steinberg::Vst::SpeakerArr

  k131
  Steinberg::Vst::SpeakerArr

  k222
  Steinberg::Vst::SpeakerArr

  k30Cine
  Steinberg::Vst::SpeakerArr

  k30Music
  Steinberg::Vst::SpeakerArr

  k31Cine
  Steinberg::Vst::SpeakerArr

  k31Music
  Steinberg::Vst::SpeakerArr

  k40Cine
  Steinberg::Vst::SpeakerArr

  k40Music
  Steinberg::Vst::SpeakerArr

  k41Cine
  Steinberg::Vst::SpeakerArr

  k41Music
  Steinberg::Vst::SpeakerArr

  k50
  Steinberg::Vst::SpeakerArr

  k51
  Steinberg::Vst::SpeakerArr

  k60Cine
  Steinberg::Vst::SpeakerArr

  k60Music
  Steinberg::Vst::SpeakerArr

  k61Cine
  Steinberg::Vst::SpeakerArr

  k61Music
  Steinberg::Vst::SpeakerArr

  k70Cine
  Steinberg::Vst::SpeakerArr

  k70Music
  Steinberg::Vst::SpeakerArr

  k71Cine
  Steinberg::Vst::SpeakerArr

  k71CineCenterHigh
  Steinberg::Vst::SpeakerArr

  k71CineFrontHigh
  Steinberg::Vst::SpeakerArr

  k71CineFullFront
  Steinberg::Vst::SpeakerArr

  k71CineFullRear
  Steinberg::Vst::SpeakerArr

  k71CineSideFill
  Steinberg::Vst::SpeakerArr

  k71CineSideHigh
  Steinberg::Vst::SpeakerArr

  k71CineTopCenter
  Steinberg::Vst::SpeakerArr

  k71MPEG3D
  Steinberg::Vst::SpeakerArr

  k71Music
  Steinberg::Vst::SpeakerArr

  k80Cine
  Steinberg::Vst::SpeakerArr

  k80Cube
  Steinberg::Vst::SpeakerArr

  k80Music
  Steinberg::Vst::SpeakerArr

  k81Cine
  Steinberg::Vst::SpeakerArr

  k81MPEG3D
  Steinberg::Vst::SpeakerArr

  k81Music
  Steinberg::Vst::SpeakerArr

  k90
  Steinberg::Vst::SpeakerArr

  k91
  Steinberg::Vst::SpeakerArr

  kAccordion
  Steinberg::Vst::MusicalInstrument

  kAccordionAccordion
  Steinberg::Vst::MusicalInstrument

  kAccordionHarmonica
  Steinberg::Vst::MusicalInstrument

  kAccordionOther
  Steinberg::Vst::MusicalInstrument

  kAcoustic
  Steinberg::Vst::MusicalCharacter

  kAlternateKey
  Steinberg

  kAlternativeIndie
  Steinberg::Vst::MusicalStyle

  kAlternativeIndieCollegeRock
  Steinberg::Vst::MusicalStyle

  kAlternativeIndieDarkWave
  Steinberg::Vst::MusicalStyle

  kAlternativeIndieGothRock
  Steinberg::Vst::MusicalStyle

  kAlternativeIndieGrunge
  Steinberg::Vst::MusicalStyle

  kAlternativeIndieHardcore
  Steinberg::Vst::MusicalStyle

  kAlternativeIndieNewWave
  Steinberg::Vst::MusicalStyle

  kAlternativeIndiePunk
  Steinberg::Vst::MusicalStyle

  kAmbientChillOut
  Steinberg::Vst::MusicalStyle

  kAmbientChillOutDarkAmbient
  Steinberg::Vst::MusicalStyle

  kAmbientChillOutDowntempo
  Steinberg::Vst::MusicalStyle

  kAmbientChillOutLounge
  Steinberg::Vst::MusicalStyle

  kAmbientChillOutNewAgeMeditation
  Steinberg::Vst::MusicalStyle

  kAnalog
  Steinberg::Vst::MusicalCharacter

  kAnalyzer
  Steinberg::Vst::PlugType

  kAttack
  Steinberg::Vst::MusicalCharacter

  kBass
  Steinberg::Vst::MusicalInstrument

  kBassABass
  Steinberg::Vst::MusicalInstrument

  kBassEBass
  Steinberg::Vst::MusicalInstrument

  kBassOther
  Steinberg::Vst::MusicalInstrument

  kBassSynthBass
  Steinberg::Vst::MusicalInstrument

  kBFormat
  Steinberg::Vst::SpeakerArr

  kBFormat1stOrder
  Steinberg::Vst::SpeakerArr

  kBlockSize
  Steinberg::Vst::VstTestEnh

  kBlues
  Steinberg::Vst::MusicalStyle

  kBluesAcousticBlues
  Steinberg::Vst::MusicalStyle

  kBluesChicagoBlues
  Steinberg::Vst::MusicalStyle

  kBluesCountryBlues
  Steinberg::Vst::MusicalStyle

  kBluesElectricBlues
  Steinberg::Vst::MusicalStyle

  kBrass
  Steinberg::Vst::MusicalInstrument

  kBrassFrenchHorn
  Steinberg::Vst::MusicalInstrument

  kBrassOther
  Steinberg::Vst::MusicalInstrument

  kBrassSection
  Steinberg::Vst::MusicalInstrument

  kBrassSynth
  Steinberg::Vst::MusicalInstrument

  kBrassTrombone
  Steinberg::Vst::MusicalInstrument

  kBrassTrumpet
  Steinberg::Vst::MusicalInstrument

  kBrassTuba
  Steinberg::Vst::MusicalInstrument

  kBright
  Steinberg::Vst::MusicalCharacter

  kCategorySize
  Steinberg::PClassInfo

  kChanged
  Steinberg::IDependent

  kCharacter
  Steinberg::Vst::PresetAttributes

  kChromaticPerc
  Steinberg::Vst::MusicalInstrument

  kChromaticPercBell
  Steinberg::Vst::MusicalInstrument

  kChromaticPercMallett
  Steinberg::Vst::MusicalInstrument

  kChromaticPercOther
  Steinberg::Vst::MusicalInstrument

  kChromaticPercPercussion
  Steinberg::Vst::MusicalInstrument

  kChromaticPercTimpani
  Steinberg::Vst::MusicalInstrument

  kChromaticPercWood
  Steinberg::Vst::MusicalInstrument

  kCLASS_UID
  Steinberg::FUID

  kClassesDiscardable
  Steinberg::PFactoryInfo

  kClassical
  Steinberg::Vst::MusicalStyle

  kClassicalBaroque
  Steinberg::Vst::MusicalStyle

  kClassicalChamberMusic
  Steinberg::Vst::MusicalStyle

  kClassicalClassic
  Steinberg::Vst::MusicalStyle

  kClassicalGregorian
  Steinberg::Vst::MusicalStyle

  kClassicalMedieval
  Steinberg::Vst::MusicalStyle

  kClassicalModernComposition
  Steinberg::Vst::MusicalStyle

  kClassicalOpera
  Steinberg::Vst::MusicalStyle

  kClassicalRenaissance
  Steinberg::Vst::MusicalStyle

  kClassicalRomantic
  Steinberg::Vst::MusicalStyle

  kClassicalSoundtrack
  Steinberg::Vst::MusicalStyle

  kClean
  Steinberg::Vst::MusicalCharacter

  kClear
  Steinberg::Vst::MusicalCharacter

  kCold
  Steinberg::Vst::MusicalCharacter

  kCommandKey
  Steinberg

  kComponentNonDiscardable
  Steinberg::PFactoryInfo

  kControlKey
  Steinberg

  kCountry
  Steinberg::Vst::MusicalStyle

  kCountryAmericana
  Steinberg::Vst::MusicalStyle

  kCountryBluegrass
  Steinberg::Vst::MusicalStyle

  kCountryCountryWestern
  Steinberg::Vst::MusicalStyle

  kCountryHonkyTonk
  Steinberg::Vst::MusicalStyle

  kCountryNorthAmericanFolk
  Steinberg::Vst::MusicalStyle

  kCountrySquaredance
  Steinberg::Vst::MusicalStyle

  kCountryUrbanCowboy
  Steinberg::Vst::MusicalStyle

  kDark
  Steinberg::Vst::MusicalCharacter

  kDecay
  Steinberg::Vst::MusicalCharacter

  kDECLARE_UID
  Steinberg::FUID

  kDefault
  Steinberg::Vst::StateType

  kDefaultFactoryFlags
  Steinberg::Vst

  kDestroyed
  Steinberg::IDependent

  kDigital
  Steinberg::Vst::MusicalCharacter

  kDissonant
  Steinberg::Vst::MusicalCharacter

  kDistorted
  Steinberg::Vst::MusicalCharacter

  kDrumPerc
  Steinberg::Vst::MusicalInstrument

  kDrumPercBeats
  Steinberg::Vst::MusicalInstrument

  kDrumPercCymbals
  Steinberg::Vst::MusicalInstrument

  kDrumPercDrumMenues
  Steinberg::Vst::MusicalInstrument

  kDrumPercDrumset
  Steinberg::Vst::MusicalInstrument

  kDrumPercDrumsetGM
  Steinberg::Vst::MusicalInstrument

  kDrumPercHiHats
  Steinberg::Vst::MusicalInstrument

  kDrumPercKickDrum
  Steinberg::Vst::MusicalInstrument

  kDrumPercOther
  Steinberg::Vst::MusicalInstrument

  kDrumPercPercussion
  Steinberg::Vst::MusicalInstrument

  kDrumPercSnareDrum
  Steinberg::Vst::MusicalInstrument

  kDrumPercToms
  Steinberg::Vst::MusicalInstrument

  kDry
  Steinberg::Vst::MusicalCharacter

  kEditor
  Steinberg::Vst::ViewType

  kElectric
  Steinberg::Vst::MusicalCharacter

  kElectronicaDance
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceBigBeats
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceClassicHouse
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceDrumNBassJungle
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceDub
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceElectronicBodyMusic
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceElektro
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceElektroHouse
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceFunkyHouse
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceIndustrial
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceMinimal
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceTechno
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceTrance
  Steinberg::Vst::MusicalStyle

  kElectronicaDanceTripHop
  Steinberg::Vst::MusicalStyle

  kEmailSize
  Steinberg::PFactoryInfo

  kEmpty

    Steinberg::FVariant::kEmpty()
    Steinberg::Vst::SpeakerArr::kEmpty()

  kEnsemble
  Steinberg::Vst::MusicalCharacter

  kEthnic
  Steinberg::Vst::MusicalInstrument

  kEthnicAfrican
  Steinberg::Vst::MusicalInstrument

  kEthnicAlien
  Steinberg::Vst::MusicalInstrument

  kEthnicAmerican
  Steinberg::Vst::MusicalInstrument

  kEthnicAsian
  Steinberg::Vst::MusicalInstrument

  kEthnicEuropean
  Steinberg::Vst::MusicalInstrument

  kEthnicLatin
  Steinberg::Vst::MusicalInstrument

  kEthnicOther
  Steinberg::Vst::MusicalInstrument

  kExperimental
  Steinberg::Vst::MusicalStyle

  kExperimentalElectronicArtMusic
  Steinberg::Vst::MusicalStyle

  kExperimentalFreeImprovisation
  Steinberg::Vst::MusicalStyle

  kExperimentalNewMusic
  Steinberg::Vst::MusicalStyle

  kExperimentalNoise
  Steinberg::Vst::MusicalStyle

  KEY_ADD
  Steinberg

  KEY_ALT
  Steinberg

  KEY_BACK
  Steinberg

  KEY_CLEAR
  Steinberg

  KEY_CONTEXTMENU
  Steinberg

  KEY_CONTROL
  Steinberg

  KEY_DECIMAL
  Steinberg

  KEY_DELETE
  Steinberg

  KEY_DIVIDE
  Steinberg

  KEY_DOWN
  Steinberg

  KEY_END
  Steinberg

  KEY_ENTER
  Steinberg

  KEY_EQUALS
  Steinberg

  KEY_ESCAPE
  Steinberg

  KEY_F1
  Steinberg

  KEY_F10
  Steinberg

  KEY_F11
  Steinberg

  KEY_F12
  Steinberg

  KEY_F13
  Steinberg

  KEY_F14
  Steinberg

  KEY_F15
  Steinberg

  KEY_F16
  Steinberg

  KEY_F17
  Steinberg

  KEY_F18
  Steinberg

  KEY_F19
  Steinberg

  KEY_F2
  Steinberg

  KEY_F3
  Steinberg

  KEY_F4
  Steinberg

  KEY_F5
  Steinberg

  KEY_F6
  Steinberg

  KEY_F7
  Steinberg

  KEY_F8
  Steinberg

  KEY_F9
  Steinberg

  KEY_HELP
  Steinberg

  KEY_HOME
  Steinberg

  KEY_INSERT
  Steinberg

  KEY_LEFT
  Steinberg

  KEY_MEDIA_NEXT
  Steinberg

  KEY_MEDIA_PLAY
  Steinberg

  KEY_MEDIA_PREV
  Steinberg

  KEY_MEDIA_STOP
  Steinberg

  KEY_MULTIPLY
  Steinberg

  KEY_NEXT
  Steinberg

  KEY_NUMLOCK
  Steinberg

  KEY_NUMPAD0
  Steinberg

  KEY_NUMPAD1
  Steinberg

  KEY_NUMPAD2
  Steinberg

  KEY_NUMPAD3
  Steinberg

  KEY_NUMPAD4
  Steinberg

  KEY_NUMPAD5
  Steinberg

  KEY_NUMPAD6
  Steinberg

  KEY_NUMPAD7
  Steinberg

  KEY_NUMPAD8
  Steinberg

  KEY_NUMPAD9
  Steinberg

  KEY_PAGEDOWN
  Steinberg

  KEY_PAGEUP
  Steinberg

  KEY_PAUSE
  Steinberg

  KEY_PRINT
  Steinberg

  KEY_RETURN
  Steinberg

  KEY_RIGHT
  Steinberg

  KEY_SCROLL
  Steinberg

  KEY_SELECT
  Steinberg

  KEY_SEPARATOR
  Steinberg

  KEY_SHIFT
  Steinberg

  KEY_SNAPSHOT
  Steinberg

  KEY_SPACE
  Steinberg

  KEY_SUBTRACT
  Steinberg

  KEY_TAB
  Steinberg

  KEY_UP
  Steinberg

  KEY_VOLUME_DOWN
  Steinberg

  KEY_VOLUME_UP
  Steinberg

  keyNote
  Steinberg::Vst::Chord

  keyRemapped
  Steinberg::Vst::KeyswitchInfo

  keyswitchMax
  Steinberg::Vst::KeyswitchInfo

  keyswitchMin
  Steinberg::Vst::KeyswitchInfo

  kFast
  Steinberg::Vst::MusicalCharacter

  kFastAttack
  Steinberg::Vst::MusicalCharacter

  kFilePathStringType
  Steinberg::Vst::PresetAttributes

  kFlags
  Steinberg::Vst::Attributes

  kFloat
  Steinberg::FVariant

  kFUID
  Steinberg::FUID

  kFunction
  Steinberg::Vst::Attributes

  kFx
  Steinberg::Vst::PlugType

  kFxAnalyzer
  Steinberg::Vst::PlugType

  kFxDelay
  Steinberg::Vst::PlugType

  kFxDistortion
  Steinberg::Vst::PlugType

  kFxDynamics
  Steinberg::Vst::PlugType

  kFxEQ
  Steinberg::Vst::PlugType

  kFxFilter
  Steinberg::Vst::PlugType

  kFxGenerator
  Steinberg::Vst::PlugType

  kFxInstrument
  Steinberg::Vst::PlugType

  kFxInstrumentExternal
  Steinberg::Vst::PlugType

  kFxMastering
  Steinberg::Vst::PlugType

  kFxModulation
  Steinberg::Vst::PlugType

  kFxNetwork
  Steinberg::Vst::PlugType

  kFxPitchShift
  Steinberg::Vst::PlugType

  kFxRestoration
  Steinberg::Vst::PlugType

  kFxReverb
  Steinberg::Vst::PlugType

  kFxSpatial
  Steinberg::Vst::PlugType

  kFxSurround
  Steinberg::Vst::PlugType

  kFxTools
  Steinberg::Vst::PlugType

  kGainReductionFunc
  Steinberg::Vst::AttributesFunction

  kGlass
  Steinberg::Vst::MusicalCharacter

  kGlide
  Steinberg::Vst::MusicalCharacter

  kGlissando
  Steinberg::Vst::MusicalCharacter

  kGuitar
  Steinberg::Vst::MusicalInstrument

  kGuitarAGuitar
  Steinberg::Vst::MusicalInstrument

  kGuitarEGuitar
  Steinberg::Vst::MusicalInstrument

  kGuitarEthnic
  Steinberg::Vst::MusicalInstrument

  kGuitarHarp
  Steinberg::Vst::MusicalInstrument

  kGuitarOther
  Steinberg::Vst::MusicalInstrument

  kHarmonic
  Steinberg::Vst::MusicalCharacter

  kHideableFlag
  Steinberg::Vst::AttributesFlags

  kIBSeekCur
  Steinberg::IBStream

  kIBSeekEnd
  Steinberg::IBStream

  kIBSeekSet
  Steinberg::IBStream

  kInCell
  Steinberg::Vst::XmlRepresentationHelper

  kInLayer
  Steinberg::Vst::XmlRepresentationHelper

  kINLINE_UID
  Steinberg::FUID

  kInName
  Steinberg::Vst::XmlRepresentationHelper

  kInPage
  Steinberg::Vst::XmlRepresentationHelper

  kInRepresentation
  Steinberg::Vst::XmlRepresentationHelper

  kInstrument

    Steinberg::Vst::PlugType::kInstrument()
    Steinberg::Vst::PresetAttributes::kInstrument()

  kInstrumentDrum
  Steinberg::Vst::PlugType

  kInstrumentExternal
  Steinberg::Vst::PlugType

  kInstrumentSampler
  Steinberg::Vst::PlugType

  kInstrumentSynth
  Steinberg::Vst::PlugType

  kInstrumentSynthSampler
  Steinberg::Vst::PlugType

  kInteger
  Steinberg::FVariant

  kInternalError
  Steinberg

  kInTitleDisplay
  Steinberg::Vst::XmlRepresentationHelper

  kInvalidArgument
  Steinberg

  kInverseStyle
  Steinberg::Vst::AttributesStyle

  kJazz
  Steinberg::Vst::MusicalStyle

  kJazzAvantgarde
  Steinberg::Vst::MusicalStyle

  kJazzFreeJazz
  Steinberg::Vst::MusicalStyle

  kJazzFusion
  Steinberg::Vst::MusicalStyle

  kJazzLatinJazz
  Steinberg::Vst::MusicalStyle

  kJazzNewOrleansJazz
  Steinberg::Vst::MusicalStyle

  kJazzOldtimeJazzDixiland
  Steinberg::Vst::MusicalStyle

  kJazzRagtime
  Steinberg::Vst::MusicalStyle

  kJazzTraditionalJazz
  Steinberg::Vst::MusicalStyle

  kKeyboard
  Steinberg::Vst::MusicalInstrument

  kKeyboardClavi
  Steinberg::Vst::MusicalInstrument

  kKeyboardEPiano
  Steinberg::Vst::MusicalInstrument

  kKeyboardHarpsichord
  Steinberg::Vst::MusicalInstrument

  kKeyboardOther
  Steinberg::Vst::MusicalInstrument

  kKnobTurnsPerFullRange
  Steinberg::Vst::Attributes

  kLayer
  Steinberg::Vst::MusicalCharacter

  kLEDBoostCutStyle
  Steinberg::Vst::AttributesStyle

  kLEDSingleDotStyle
  Steinberg::Vst::AttributesStyle

  kLEDSpreadStyle
  Steinberg::Vst::AttributesStyle

  kLEDStyle
  Steinberg::Vst::Attributes

  kLEDWrapLeftStyle
  Steinberg::Vst::AttributesStyle

  kLEDWrapRightStyle
  Steinberg::Vst::AttributesStyle

  kLicenseCheck
  Steinberg::PFactoryInfo

  kLong
  Steinberg::Vst::MusicalCharacter

  kLongRelease
  Steinberg::Vst::MusicalCharacter

  kLoop
  Steinberg::Vst::MusicalCharacter

  kMajor
  Steinberg::Vst::MusicalCharacter

  kManyInstances
  Steinberg::PClassInfo

  kMaxEntries
  Steinberg::Vst::PresetFile

  kMaxSamplesPerBlock
  Steinberg::Vst::VstTestEnh

  kMetallic
  Steinberg::Vst::MusicalCharacter

  kMinor
  Steinberg::Vst::MusicalCharacter

  kModern
  Steinberg::Vst::MusicalCharacter

  kMono

    Steinberg::Vst::PlugType::kMono()
    Steinberg::Vst::MusicalCharacter::kMono()
    Steinberg::Vst::SpeakerArr::kMono()

  kMoving
  Steinberg::Vst::MusicalCharacter

  kMusicalFX
  Steinberg::Vst::MusicalInstrument

  kMusicalFXBeepsBlips
  Steinberg::Vst::MusicalInstrument

  kMusicalFXHitsStabs
  Steinberg::Vst::MusicalInstrument

  kMusicalFXMotion
  Steinberg::Vst::MusicalInstrument

  kMusicalFXOther
  Steinberg::Vst::MusicalInstrument

  kMusicalFXScratches
  Steinberg::Vst::MusicalInstrument

  kMusicalFXSweeps
  Steinberg::Vst::MusicalInstrument

  kMuteFunc
  Steinberg::Vst::AttributesFunction

  kNameSize

    Steinberg::PFactoryInfo::kNameSize()
    Steinberg::PClassInfo::kNameSize()

  kNew
  Steinberg::Vst::MusicalCharacter

  kNoFlags
  Steinberg::PFactoryInfo

  kNoInterface
  Steinberg

  kNoisy
  Steinberg::Vst::MusicalCharacter

  kNoOfflineProcess
  Steinberg::Vst::PlugType

  kNotImplemented
  Steinberg

  kNotInitialized
  Steinberg

  kObject
  Steinberg::FVariant

  kOld
  Steinberg::Vst::MusicalCharacter

  kOneShot
  Steinberg::Vst::MusicalCharacter

  kOnlyOfflineProcess
  Steinberg::Vst::PlugType

  kOnlyRealTime
  Steinberg::Vst::PlugType

  kOrgan
  Steinberg::Vst::MusicalInstrument

  kOrganElectric
  Steinberg::Vst::MusicalInstrument

  kOrganOther
  Steinberg::Vst::MusicalInstrument

  kOrganPipe
  Steinberg::Vst::MusicalInstrument

  kOutOfMemory
  Steinberg

  kOwner
  Steinberg::FVariant

  kPanLawFunc
  Steinberg::Vst::AttributesFunction

  kPanLfeGainFunc
  Steinberg::Vst::AttributesFunction

  kPanMirrorModeFunc
  Steinberg::Vst::AttributesFunction

  kPanPosCenterXFunc
  Steinberg::Vst::AttributesFunction

  kPanPosCenterYFunc
  Steinberg::Vst::AttributesFunction

  kPanPosFrontLeftXFunc
  Steinberg::Vst::AttributesFunction

  kPanPosFrontLeftYFunc
  Steinberg::Vst::AttributesFunction

  kPanPosFrontRightXFunc
  Steinberg::Vst::AttributesFunction

  kPanPosFrontRightYFunc
  Steinberg::Vst::AttributesFunction

  kPanRotationFunc
  Steinberg::Vst::AttributesFunction

  kPercussive
  Steinberg::Vst::MusicalCharacter

  kPiano
  Steinberg::Vst::MusicalInstrument

  kPianoAPiano
  Steinberg::Vst::MusicalInstrument

  kPianoEGrand
  Steinberg::Vst::MusicalInstrument

  kPianoOther
  Steinberg::Vst::MusicalInstrument

  kPlastic
  Steinberg::Vst::MusicalCharacter

  kPlatformStringIOS
  Steinberg

  kPlatformStringMac
  Steinberg

  kPlatformStringWin
  Steinberg

  kPlatformTypeHIView
  Steinberg

  kPlatformTypeHWND
  Steinberg

  kPlatformTypeNSView
  Steinberg

  kPlatformTypeUIView
  Steinberg

  kPlugInCategory
  Steinberg::Vst::PresetAttributes

  kPlugInName
  Steinberg::Vst::PresetAttributes

  kPoly
  Steinberg::Vst::MusicalCharacter

  kPop
  Steinberg::Vst::MusicalStyle

  kPop80sPop
  Steinberg::Vst::MusicalStyle

  kPopBritpop
  Steinberg::Vst::MusicalStyle

  kPopChartDance
  Steinberg::Vst::MusicalStyle

  kPopDancehall
  Steinberg::Vst::MusicalStyle

  kPopDisco
  Steinberg::Vst::MusicalStyle

  kPopRock
  Steinberg::Vst::MusicalStyle

  kPopTeenPop
  Steinberg::Vst::MusicalStyle

  kProcessed
  Steinberg::Vst::MusicalCharacter

  kProject
  Steinberg::Vst::StateType

  kRelease
  Steinberg::Vst::MusicalCharacter

  kResultFalse
  Steinberg

  kResultOk
  Steinberg

  kResultTrue
  Steinberg

  kRich
  Steinberg::Vst::MusicalCharacter

  kRockMetal
  Steinberg::Vst::MusicalStyle

  kRockMetalAlternativeRock
  Steinberg::Vst::MusicalStyle

  kRockMetalBallad
  Steinberg::Vst::MusicalStyle

  kRockMetalBluesRock
  Steinberg::Vst::MusicalStyle

  kRockMetalClassicRock
  Steinberg::Vst::MusicalStyle

  kRockMetalDeathBlackMetal
  Steinberg::Vst::MusicalStyle

  kRockMetalHardRock
  Steinberg::Vst::MusicalStyle

  kRockMetalHeavyMetal
  Steinberg::Vst::MusicalStyle

  kRockMetalNuMetal
  Steinberg::Vst::MusicalStyle

  kRockMetalProgressiveRock
  Steinberg::Vst::MusicalStyle

  kRockMetalReggae
  Steinberg::Vst::MusicalStyle

  kRockMetalRockabilly
  Steinberg::Vst::MusicalStyle

  kRockMetalRockRoll
  Steinberg::Vst::MusicalStyle

  kRockMetalSingerSongwriter
  Steinberg::Vst::MusicalStyle

  kRockMetalThrashMetal
  Steinberg::Vst::MusicalStyle

  kSampleRate
  Steinberg::Vst::VstTestEnh

  kSegment
  Steinberg::Vst::CurveType

  kShiftKey
  Steinberg

  kShort
  Steinberg::Vst::MusicalCharacter

  kShortRelease
  Steinberg::Vst::MusicalCharacter

  kSingle
  Steinberg::Vst::MusicalCharacter

  kSlow
  Steinberg::Vst::MusicalCharacter

  kSlowAttack
  Steinberg::Vst::MusicalCharacter

  kSoft
  Steinberg::Vst::MusicalCharacter

  kSoloFunc
  Steinberg::Vst::AttributesFunction

  kSoundFX
  Steinberg::Vst::MusicalInstrument

  kSoundFXMechanical
  Steinberg::Vst::MusicalInstrument

  kSoundFXNature
  Steinberg::Vst::MusicalInstrument

  kSoundFXOther
  Steinberg::Vst::MusicalInstrument

  kSoundFXSynthetic
  Steinberg::Vst::MusicalInstrument

  kSpatial
  Steinberg::Vst::PlugType

  kSpatialFx
  Steinberg::Vst::PlugType

  kSpeakerBfc
  Steinberg::Vst

  kSpeakerBfl
  Steinberg::Vst

  kSpeakerBfr
  Steinberg::Vst

  kSpeakerC
  Steinberg::Vst

  kSpeakerCs
  Steinberg::Vst

  kSpeakerL
  Steinberg::Vst

  kSpeakerLc
  Steinberg::Vst

  kSpeakerLcs
  Steinberg::Vst

  kSpeakerLfe
  Steinberg::Vst

  kSpeakerLfe2
  Steinberg::Vst

  kSpeakerLs
  Steinberg::Vst

  kSpeakerM
  Steinberg::Vst

  kSpeakerR
  Steinberg::Vst

  kSpeakerRc
  Steinberg::Vst

  kSpeakerRcs
  Steinberg::Vst

  kSpeakerRs
  Steinberg::Vst

  kSpeakerS
  Steinberg::Vst

  kSpeakerSl
  Steinberg::Vst

  kSpeakerSr
  Steinberg::Vst

  kSpeakerTfc
  Steinberg::Vst

  kSpeakerTfl
  Steinberg::Vst

  kSpeakerTfr
  Steinberg::Vst

  kSpeakerTm
  Steinberg::Vst

  kSpeakerTrc
  Steinberg::Vst

  kSpeakerTrl
  Steinberg::Vst

  kSpeakerTrr
  Steinberg::Vst

  kSpeakerTsl
  Steinberg::Vst

  kSpeakerTsr
  Steinberg::Vst

  kSpeakerW
  Steinberg::Vst

  kSpeakerX
  Steinberg::Vst

  kSpeakerY
  Steinberg::Vst

  kSpeakerZ
  Steinberg::Vst

  kSplit
  Steinberg::Vst::MusicalCharacter

  kStateType
  Steinberg::Vst::PresetAttributes

  kStatic
  Steinberg::Vst::MusicalCharacter

  kStdChangeMessageLast
  Steinberg::IDependent

  kStereo

    Steinberg::Vst::PlugType::kStereo()
    Steinberg::Vst::SpeakerArr::kStereo()

  kStereoCenter
  Steinberg::Vst::SpeakerArr

  kStereoCLfe
  Steinberg::Vst::SpeakerArr

  kStereoSide
  Steinberg::Vst::SpeakerArr

  kStereoSurround
  Steinberg::Vst::SpeakerArr

  kString100
  Steinberg::Vst::SpeakerArr

  kString100S
  Steinberg::Vst::SpeakerArr

  kString101
  Steinberg::Vst::SpeakerArr

  kString101MPEGS
  Steinberg::Vst::SpeakerArr

  kString101S
  Steinberg::Vst::SpeakerArr

  kString102
  Steinberg::Vst::SpeakerArr

  kString102S
  Steinberg::Vst::SpeakerArr

  kString110
  Steinberg::Vst::SpeakerArr

  kString110S
  Steinberg::Vst::SpeakerArr

  kString111
  Steinberg::Vst::SpeakerArr

  kString111S
  Steinberg::Vst::SpeakerArr

  kString122
  Steinberg::Vst::SpeakerArr

  kString122S
  Steinberg::Vst::SpeakerArr

  kString130
  Steinberg::Vst::SpeakerArr

  kString130S
  Steinberg::Vst::SpeakerArr

  kString131
  Steinberg::Vst::SpeakerArr

  kString131S
  Steinberg::Vst::SpeakerArr

  kString16
  Steinberg::FVariant

  kString222
  Steinberg::Vst::SpeakerArr

  kString222S
  Steinberg::Vst::SpeakerArr

  kString30Cine
  Steinberg::Vst::SpeakerArr

  kString30CineS
  Steinberg::Vst::SpeakerArr

  kString30Music
  Steinberg::Vst::SpeakerArr

  kString30MusicS
  Steinberg::Vst::SpeakerArr

  kString31Cine
  Steinberg::Vst::SpeakerArr

  kString31CineS
  Steinberg::Vst::SpeakerArr

  kString31Music
  Steinberg::Vst::SpeakerArr

  kString31MusicS
  Steinberg::Vst::SpeakerArr

  kString40Cine
  Steinberg::Vst::SpeakerArr

  kString40CineS
  Steinberg::Vst::SpeakerArr

  kString40Music
  Steinberg::Vst::SpeakerArr

  kString40MusicS
  Steinberg::Vst::SpeakerArr

  kString41Cine
  Steinberg::Vst::SpeakerArr

  kString41CineS
  Steinberg::Vst::SpeakerArr

  kString41Music
  Steinberg::Vst::SpeakerArr

  kString41MusicS
  Steinberg::Vst::SpeakerArr

  kString50
  Steinberg::Vst::SpeakerArr

  kString50S
  Steinberg::Vst::SpeakerArr

  kString51
  Steinberg::Vst::SpeakerArr

  kString51S
  Steinberg::Vst::SpeakerArr

  kString60Cine
  Steinberg::Vst::SpeakerArr

  kString60CineS
  Steinberg::Vst::SpeakerArr

  kString60Music
  Steinberg::Vst::SpeakerArr

  kString60MusicS
  Steinberg::Vst::SpeakerArr

  kString61Cine
  Steinberg::Vst::SpeakerArr

  kString61CineS
  Steinberg::Vst::SpeakerArr

  kString61Music
  Steinberg::Vst::SpeakerArr

  kString61MusicS
  Steinberg::Vst::SpeakerArr

  kString70Cine
  Steinberg::Vst::SpeakerArr

  kString70CineS
  Steinberg::Vst::SpeakerArr

  kString70Music
  Steinberg::Vst::SpeakerArr

  kString70MusicS
  Steinberg::Vst::SpeakerArr

  kString71Cine
  Steinberg::Vst::SpeakerArr

  kString71CineCenterHigh
  Steinberg::Vst::SpeakerArr

  kString71CineCenterHighS
  Steinberg::Vst::SpeakerArr

  kString71CineFrontHigh
  Steinberg::Vst::SpeakerArr

  kString71CineFrontHighS
  Steinberg::Vst::SpeakerArr

  kString71CineFullRear
  Steinberg::Vst::SpeakerArr

  kString71CineFullRearS
  Steinberg::Vst::SpeakerArr

  kString71CineS
  Steinberg::Vst::SpeakerArr

  kString71CineSideHigh
  Steinberg::Vst::SpeakerArr

  kString71CineSideHighS
  Steinberg::Vst::SpeakerArr

  kString71CineTopCenter
  Steinberg::Vst::SpeakerArr

  kString71CineTopCenterS
  Steinberg::Vst::SpeakerArr

  kString71Music
  Steinberg::Vst::SpeakerArr

  kString71MusicS
  Steinberg::Vst::SpeakerArr

  kString8
  Steinberg::FVariant

  kString80Cine
  Steinberg::Vst::SpeakerArr

  kString80CineS
  Steinberg::Vst::SpeakerArr

  kString80Cube
  Steinberg::Vst::SpeakerArr

  kString80CubeS
  Steinberg::Vst::SpeakerArr

  kString80Music
  Steinberg::Vst::SpeakerArr

  kString80MusicS
  Steinberg::Vst::SpeakerArr

  kString81Cine
  Steinberg::Vst::SpeakerArr

  kString81CineS
  Steinberg::Vst::SpeakerArr

  kString81MPEGS
  Steinberg::Vst::SpeakerArr

  kString81Music
  Steinberg::Vst::SpeakerArr

  kString81MusicS
  Steinberg::Vst::SpeakerArr

  kString90
  Steinberg::Vst::SpeakerArr

  kString90S
  Steinberg::Vst::SpeakerArr

  kString91
  Steinberg::Vst::SpeakerArr

  kString91S
  Steinberg::Vst::SpeakerArr

  kStringBFormat1stOrder
  Steinberg::Vst::SpeakerArr

  kStringBFormat1stOrderS
  Steinberg::Vst::SpeakerArr

  kStringEmpty
  Steinberg::Vst::SpeakerArr

  kStringMono
  Steinberg::Vst::SpeakerArr

  kStringMonoS
  Steinberg::Vst::SpeakerArr

  kStrings
  Steinberg::Vst::MusicalInstrument

  kStringsBass
  Steinberg::Vst::MusicalInstrument

  kStringsCello
  Steinberg::Vst::MusicalInstrument

  kStringsOther
  Steinberg::Vst::MusicalInstrument

  kStringsSection
  Steinberg::Vst::MusicalInstrument

  kStringsSynth
  Steinberg::Vst::MusicalInstrument

  kStringStereo
  Steinberg::Vst::SpeakerArr

  kStringStereoC
  Steinberg::Vst::SpeakerArr

  kStringStereoCLfe
  Steinberg::Vst::SpeakerArr

  kStringStereoCLfeS
  Steinberg::Vst::SpeakerArr

  kStringStereoCS
  Steinberg::Vst::SpeakerArr

  kStringStereoR
  Steinberg::Vst::SpeakerArr

  kStringStereoRS
  Steinberg::Vst::SpeakerArr

  kStringStereoS
  Steinberg::Vst::SpeakerArr

  kStringStereoSide
  Steinberg::Vst::SpeakerArr

  kStringStereoSS
  Steinberg::Vst::SpeakerArr

  kStringsViola
  Steinberg::Vst::MusicalInstrument

  kStringsViolin
  Steinberg::Vst::MusicalInstrument

  kStyle

    Steinberg::Vst::Attributes::kStyle()
    Steinberg::Vst::PresetAttributes::kStyle()

  kSubCategoriesSize

    Steinberg::PClassInfo2::kSubCategoriesSize()
    Steinberg::PClassInfoW::kSubCategoriesSize()

  kSurround
  Steinberg::Vst::PlugType

  kSustain
  Steinberg::Vst::MusicalCharacter

  kSwitchLatchStyle
  Steinberg::Vst::AttributesStyle

  kSwitchPushDecLoopedStyle
  Steinberg::Vst::AttributesStyle

  kSwitchPushDecStyle
  Steinberg::Vst::AttributesStyle

  kSwitchPushIncLoopedStyle
  Steinberg::Vst::AttributesStyle

  kSwitchPushIncStyle
  Steinberg::Vst::AttributesStyle

  kSwitchPushStyle
  Steinberg::Vst::AttributesStyle

  kSwitchStyle
  Steinberg::Vst::Attributes

  kSynthComp
  Steinberg::Vst::MusicalInstrument

  kSynthCompAnalog
  Steinberg::Vst::MusicalInstrument

  kSynthCompDigital
  Steinberg::Vst::MusicalInstrument

  kSynthCompOther
  Steinberg::Vst::MusicalInstrument

  kSynthLead
  Steinberg::Vst::MusicalInstrument

  kSynthLeadAnalog
  Steinberg::Vst::MusicalInstrument

  kSynthLeadArpeggio
  Steinberg::Vst::MusicalInstrument

  kSynthLeadDigital
  Steinberg::Vst::MusicalInstrument

  kSynthLeadOther
  Steinberg::Vst::MusicalInstrument

  kSynthPad
  Steinberg::Vst::MusicalInstrument

  kSynthPadAnalog
  Steinberg::Vst::MusicalInstrument

  kSynthPadDigital
  Steinberg::Vst::MusicalInstrument

  kSynthPadMotion
  Steinberg::Vst::MusicalInstrument

  kSynthPadOther
  Steinberg::Vst::MusicalInstrument

  kSynthPadSynthChoir
  Steinberg::Vst::MusicalInstrument

  kThin
  Steinberg::Vst::MusicalCharacter

  kUnicode
  Steinberg::PFactoryInfo

  kUpDownMix
  Steinberg::Vst::PlugType

  kUrbanHipHopRB
  Steinberg::Vst::MusicalStyle

  kUrbanHipHopRBClassic
  Steinberg::Vst::MusicalStyle

  kUrbanHipHopRBEastCoastHipHop
  Steinberg::Vst::MusicalStyle

  kUrbanHipHopRBFunk
  Steinberg::Vst::MusicalStyle

  kUrbanHipHopRBModern
  Steinberg::Vst::MusicalStyle

  kUrbanHipHopRBPop
  Steinberg::Vst::MusicalStyle

  kUrbanHipHopRBRapHipHop
  Steinberg::Vst::MusicalStyle

  kUrbanHipHopRBSoul
  Steinberg::Vst::MusicalStyle

  kUrbanHipHopRBWestCoastHipHop
  Steinberg::Vst::MusicalStyle

  kURLSize
  Steinberg::PFactoryInfo

  kValueList
  Steinberg::Vst::CurveType

  kVendorSize

    Steinberg::PClassInfo2::kVendorSize()
    Steinberg::PClassInfoW::kVendorSize()

  kVersionSize

    Steinberg::PClassInfo2::kVersionSize()
    Steinberg::PClassInfoW::kVersionSize()

  kVintage
  Steinberg::Vst::MusicalCharacter

  kVocal
  Steinberg::Vst::MusicalInstrument

  kVocalAdlibs
  Steinberg::Vst::MusicalInstrument

  kVocalChoir
  Steinberg::Vst::MusicalInstrument

  kVocalFX
  Steinberg::Vst::MusicalInstrument

  kVocalLeadVocal
  Steinberg::Vst::MusicalInstrument

  kVocalOther
  Steinberg::Vst::MusicalInstrument

  kVocalSolo
  Steinberg::Vst::MusicalInstrument

  kVocalSpoken
  Steinberg::Vst::MusicalInstrument

  kVolumeFunc
  Steinberg::Vst::AttributesFunction

  kWarm
  Steinberg::Vst::MusicalCharacter

  kWillChange
  Steinberg::IDependent

  kWillDestroy
  Steinberg::IDependent

  kWooden
  Steinberg::Vst::MusicalCharacter

  kWoodwinds
  Steinberg::Vst::MusicalInstrument

  kWoodwindsBassoon
  Steinberg::Vst::MusicalInstrument

  kWoodwindsClarinet
  Steinberg::Vst::MusicalInstrument

  kWoodwindsEnglHorn
  Steinberg::Vst::MusicalInstrument

  kWoodwindsEthnic
  Steinberg::Vst::MusicalInstrument

  kWoodwindsFlute
  Steinberg::Vst::MusicalInstrument

  kWoodwindsOboe
  Steinberg::Vst::MusicalInstrument

  kWoodwindsOther
  Steinberg::Vst::MusicalInstrument

  kWoodwindsSaxophone
  Steinberg::Vst::MusicalInstrument

  kWorldEthnic
  Steinberg::Vst::MusicalStyle

  kWorldEthnicAfrica
  Steinberg::Vst::MusicalStyle

  kWorldEthnicAsia
  Steinberg::Vst::MusicalStyle

  kWorldEthnicAustralia
  Steinberg::Vst::MusicalStyle

  kWorldEthnicCeltic
  Steinberg::Vst::MusicalStyle

  kWorldEthnicEasternEurope
  Steinberg::Vst::MusicalStyle

  kWorldEthnicEurope
  Steinberg::Vst::MusicalStyle

  kWorldEthnicIndiaOriental
  Steinberg::Vst::MusicalStyle

  kWorldEthnicKlezmer
  Steinberg::Vst::MusicalStyle

  kWorldEthnicNorthAmerica
  Steinberg::Vst::MusicalStyle

  kWorldEthnicScandinavia
  Steinberg::Vst::MusicalStyle

  kWorldEthnicSouthAmerica
  Steinberg::Vst::MusicalStyle

Searching...

No Matches


text:
// ----------------------------------------------------------------------------------
//
// Copyright Microsoft Corporation
// 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.
// ----------------------------------------------------------------------------------

using Microsoft.Azure.Commands.ApplicationInsights.Models;
using Microsoft.Azure.Commands.ResourceManager.Common.ArgumentCompleters;
using Microsoft.Azure.Management.ApplicationInsights.Management.Models;
using Microsoft.Azure.Management.Internal.Resources.Utilities.Models;
using System.Management.Automation;

namespace Microsoft.Azure.Commands.ApplicationInsights
{
    [Cmdlet("Set", ResourceManager.Common.AzureRMConstants.AzureRMPrefix + "ApplicationInsightsPricingPlan", DefaultParameterSetName = ComponentNameParameterSet, SupportsShouldProcess = true), OutputType(typeof(PSPricingPlan))]
    public class SetApplicationInsightsPricingPlanCommand : ApplicationInsightsBaseCmdlet
    {
        [Parameter(
            Position = 0,
            Mandatory = true,
            ParameterSetName = ComponentObjectParameterSet,
            ValueFromPipeline = true,
            HelpMessage = "Application Insights Component Object.")]
        [ValidateNotNull]
        public PSApplicationInsightsComponent ApplicationInsightsComponent { get; set; }

        [Parameter(
            Position = 0,
            Mandatory = true,
            ParameterSetName = ResourceIdParameterSet,
            ValueFromPipelineByPropertyName = true,
            HelpMessage = "Application Insights Component Resource Id.")]
        [ValidateNotNullOrEmpty]
        public string ResourceId { get; set; }

        [Parameter(
            Position = 0,
            Mandatory = true,
            ParameterSetName = ComponentNameParameterSet,
            HelpMessage = "Resource Group Name.")]
        [ResourceGroupCompleter]
        [ValidateNotNullOrEmpty]
        public string ResourceGroupName { get; set; }

        [Parameter(
            Position = 1,
            Mandatory = true,
            ParameterSetName = ComponentNameParameterSet,
            HelpMessage = "Application Insights Component Name.")]
        [Alias(ApplicationInsightsComponentNameAlias, ComponentNameAlias)]
        [ValidateNotNullOrEmpty]
        public string Name { get; set; }

        [Parameter(
            Mandatory = false,
            HelpMessage = "Pricing plan name.")]
        [ValidateSet(PricingPlans.Basic,
            PricingPlans.Enterprise,
            PricingPlans.LimitedBasic,
            IgnoreCase = true)]
        [ValidateNotNullOrEmpty]
        public string PricingPlan { get; set; }

        [Parameter(
            Mandatory = false,
            HelpMessage = "Daily Cap.")]
        public double? DailyCapGB { get; set; }

        [Parameter(
            Mandatory = false,
            HelpMessage = "Stop send notification when hit cap.")]
        public SwitchParameter DisableNotificationWhenHitCap { get; set; }

        public override void ExecuteCmdlet()
        {
            base.ExecuteCmdlet();

            if (this.ApplicationInsightsComponent != null)
            {
                this.ResourceGroupName = this.ApplicationInsightsComponent.ResourceGroupName;
                this.Name = this.ApplicationInsightsComponent.Name;
            }

            if (!string.IsNullOrEmpty(this.ResourceId))
            {
                ResourceIdentifier identifier = new ResourceIdentifier(this.ResourceId);
                this.ResourceGroupName = identifier.ResourceGroupName;
                this.Name = identifier.ResourceName;
            }

            ApplicationInsightsComponentBillingFeatures features =
                                                this.AppInsightsManagementClient
                                                        .ComponentCurrentBillingFeatures
                                                        .GetWithHttpMessagesAsync(
                                                            this.ResourceGroupName,
                                                            this.Name)
                                                        .GetAwaiter()
                                                        .GetResult()
                                                        .Body;
            if (!string.IsNullOrEmpty(this.PricingPlan))
            {
                if (this.PricingPlan.ToLowerInvariant().Contains("enterprise"))
                {
                    features.CurrentBillingFeatures = new string[] { "Application Insights Enterprise" };
                }
                else if (this.PricingPlan.ToLowerInvariant().Contains("limited"))
                {
                    features.CurrentBillingFeatures = new string[] { "Limited Basic" };
                }
                else
                {
                    features.CurrentBillingFeatures = new string[] { "Basic" };
                }
            }

            if (this.DailyCapGB != null)
            {
                features.DataVolumeCap.Cap = this.DailyCapGB.Value;
            }

            if (this.DisableNotificationWhenHitCap.IsPresent)
            {
                features.DataVolumeCap.StopSendNotificationWhenHitCap = true;
            }
            else
            {
                features.DataVolumeCap.StopSendNotificationWhenHitCap = false;
            }

            if (this.ShouldProcess(this.Name, "Update Pricing Plan"))
            {
                var putResponse = this.AppInsightsManagementClient
                                        .ComponentCurrentBillingFeatures
                                        .UpdateWithHttpMessagesAsync(
                                            this.ResourceGroupName,
                                            this.Name,
                                            features)
                                        .GetAwaiter()
                                        .GetResult();

                WriteCurrentFeatures(putResponse.Body);
            }
        }
    }
}


text:
<?php

require_once(dirname(__FILE__) . '/../interface/startOfLine.interface.php');
require_once(dirname(__FILE__) . '/../interface/endOfLine.interface.php');

class pmwiki_outdented implements startOfLine, endOfLine
{
    const regular_expression = '/^-\enabled = true;
        return "
" . substr($matches[0],2);
    }

    public function endOfLine($line_of_text)
    {
        if($this->enabled)
        {
            $this->enabled = false;
            return $line_of_text . "
";
        }
        else
        {
            return $line_of_text;
        }
    }

}

?>


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>All Classes</title>
    <meta name="date" content="2020-07-29">
<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">

All Classes

ApiChannel

ApiComposer

ApiComposer.Builder

ApiResponse

BytesReader

BytesWriter

Call

Call

CallAdapter

CallAdapter.Factory

Callback

Callback

ConnectionPool

DataApiResponse

DataSink

DataSource

DefaultHostnameVerifier

Endpoint

EndpointProvider

ForwardingProtocolReader

ForwardingProtocolRequestWriter

ForwardingProtocolResponseReader

ForwardingProtocolWriter

GuardedSerializationTypeAdapter

Interactor

Interactor

IOUtils

Method

MultiCall

MultiCall

MultiCallback

MultiCallback

MultiResponse

Parameter

ParameterValue

PCloudAPIClient

PCloudAPIClient.Builder

ProtocolReader

ProtocolRequestWriter

ProtocolResponseReader

ProtocolWriter

Request

Request.Builder

RequestBody

RequestBody

RequestData

RequestInterceptor

Response

Response.Builder

ResponseBody

ResponseData

ResponseInterceptor

RxObservableCallAdapter

RxSingleCallAdapter

SerializationException

TimestampDateTypeAdapter

TimestampDateTypeAdapterFactory

Transformer

Transformer.Builder

TypeAdapter

TypeAdapterFactory

TypeToken

UnserializableTypeException

Utils

ValueReader

ValueWriter


text:
package com.malalaoshi.android.entity;

/**
 * Create course order entity
 * Created by tianwei on 2/27/16.
 */
public class CreateChargeEntity {
    private String action;
    private String channel;

    public String getAction() {
        return action;
    }

    public void setAction(String action) {
        this.action = action;
    }

    public String getChannel() {
        return channel;
    }

    public void setChannel(String channel) {
        this.channel = channel;
    }
}


text:
using System;

namespace RawRabbit.Configuration.Consume
{
	public interface IConsumeConfigurationFactory
	{
		ConsumeConfiguration Create<TMessage>();
		ConsumeConfiguration Create(Type messageType);
		ConsumeConfiguration Create(string queueName, string exchangeName, string routingKey);
	}
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">

    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:mvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
</web-app>


text:
=encoding utf-8

=head1 Name

events - Connection processing methods

=head1

nginx supports a variety of connection processing methods.
The availability of a particular method depends on the platform used.
On platforms that support several methods nginx will normally
select the most efficient method automatically.
However, if needed, a connection processing method can be selected
explicitly with the
L<ngx_core_module> directive.

The following connection processing methods are supported:

=over

=item *

C<select>E<mdash>standard method.
The supporting module is built automatically on platforms that lack
more efficient methods.
The C<--with-select_module> and
C<--without-select_module> configuration parameters
can be used to forcibly enable or disable the build of this module.

=item *

C<poll>E<mdash>standard method.
The supporting module is built automatically on platforms that lack
more efficient methods.
The C<--with-poll_module> and
C<--without-poll_module> configuration parameters
can be used to forcibly enable or disable the build of this module.

=item *

C<kqueue>E<mdash>efficient method used on
FreeBSD 4.1+, OpenBSD 2.9+, NetBSD 2.0, and Mac OS X.

=item *

C<epoll>E<mdash>efficient method used on
Linux 2.6+.

B<NOTE>

The C<EPOLLRDHUP> (Linux 2.6.17, glibc 2.8)
and C<EPOLLEXCLUSIVE> (Linux 4.5, glibc 2.24)
flags are supported since 1.11.3.

B<NOTE>

Some older distributions like SuSE 8.2 provide patches
that add epoll support to 2.4 kernels.

=item *

C<E<sol>devE<sol>poll>E<mdash>efficient method used on
Solaris 7 11E<sol>99+, HPE<sol>UX 11.22+ (eventport), IRIX 6.5.15+,
and Tru64 UNIX 5.1A+.

=item *

C<eventport>E<mdash>event ports, efficient method
used on Solaris 10.

=back


text:
class FakeApplicationConfigManager
    : public chromium::cast::ApplicationConfigManager {
 public:
  // Default agent url used for all applications.
  static const char kFakeAgentUrl[];

  FakeApplicationConfigManager();
  ~FakeApplicationConfigManager() override;

  // Creates a config for a dummy application with the specified |id| and |url|.
  // Callers should updated the returned config as necessary and then register
  // the app by calling AddAppConfig().
  static chromium::cast::ApplicationConfig CreateConfig(const std::string& id,
                                                        const GURL& url);

  // Adds |app_config| to the list of apps.
  void AddAppConfig(chromium::cast::ApplicationConfig app_config);

  // Associates a Cast application |id| with the |url|.
  void AddApp(const std::string& id, const GURL& url);

  // chromium::cast::ApplicationConfigManager interface.
  void GetConfig(std::string id, GetConfigCallback config_callback) override;

 private:
  std::map<std::string, chromium::cast::ApplicationConfig> id_to_config_;

  DISALLOW_COPY_AND_ASSIGN(FakeApplicationConfigManager);
};

#endif  // FUCHSIA_RUNNERS_CAST_FAKE_APPLICATION_CONFIG_MANAGER_H_


text:
/*
 * Antonin Bas (antonin@barefootnetworks.com)
 *
 */

#include <PI/pi_base.h>
#include <PI/pi_clone.h>
#include <PI/pi_mc.h>
#include <PI/target/pi_clone_imp.h>

#include <stdlib.h>

pi_status_t pi_clone_session_set(
    pi_session_handle_t session_handle, pi_dev_tgt_t dev_tgt,
    pi_clone_session_id_t clone_session_id,
    const pi_clone_session_config_t *clone_session_config) {
  return _pi_clone_session_set(session_handle, dev_tgt, clone_session_id,
                               clone_session_config);
}

pi_status_t pi_clone_session_reset(pi_session_handle_t session_handle,
                                   pi_dev_tgt_t dev_tgt,
                                   pi_clone_session_id_t clone_session_id) {
  return _pi_clone_session_reset(session_handle, dev_tgt, clone_session_id);
}