caps.js

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015 Sylvain Peyrefitte
 *
 * This file is part of node-rdpjs.
 *
 * node-rdpjs is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
var type = require('../../core').type;
var log = require('../../core').log;
var error = require('../../core').error;
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240486.aspx
 */
var CapsType = {
    CAPSTYPE_GENERAL : 0x0001,
    CAPSTYPE_BITMAP : 0x0002,
    CAPSTYPE_ORDER : 0x0003,
    CAPSTYPE_BITMAPCACHE : 0x0004,
    CAPSTYPE_CONTROL : 0x0005,
    CAPSTYPE_ACTIVATION : 0x0007,
    CAPSTYPE_POINTER : 0x0008,
    CAPSTYPE_SHARE : 0x0009,
    CAPSTYPE_COLORCACHE : 0x000A,
    CAPSTYPE_SOUND : 0x000C,
    CAPSTYPE_INPUT : 0x000D,
    CAPSTYPE_FONT : 0x000E,
    CAPSTYPE_BRUSH : 0x000F,
    CAPSTYPE_GLYPHCACHE : 0x0010,
    CAPSTYPE_OFFSCREENCACHE : 0x0011,
    CAPSTYPE_BITMAPCACHE_HOSTSUPPORT : 0x0012,
    CAPSTYPE_BITMAPCACHE_REV2 : 0x0013,
    CAPSTYPE_VIRTUALCHANNEL : 0x0014,
    CAPSTYPE_DRAWNINEGRIDCACHE : 0x0015,
    CAPSTYPE_DRAWGDIPLUS : 0x0016,
    CAPSTYPE_RAIL : 0x0017,
    CAPSTYPE_WINDOW : 0x0018,
    CAPSETTYPE_COMPDESK : 0x0019,
    CAPSETTYPE_MULTIFRAGMENTUPDATE : 0x001A,
    CAPSETTYPE_LARGE_POINTER : 0x001B,
    CAPSETTYPE_SURFACE_COMMANDS : 0x001C,
    CAPSETTYPE_BITMAP_CODECS : 0x001D,
    CAPSSETTYPE_FRAME_ACKNOWLEDGE : 0x001E
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240549.aspx
 */
var MajorType = {
    OSMAJORTYPE_UNSPECIFIED : 0x0000,
    OSMAJORTYPE_WINDOWS : 0x0001,
    OSMAJORTYPE_OS2 : 0x0002,
    OSMAJORTYPE_MACINTOSH : 0x0003,
    OSMAJORTYPE_UNIX : 0x0004,
    OSMAJORTYPE_IOS : 0x0005,
    OSMAJORTYPE_OSX : 0x0006,
    OSMAJORTYPE_ANDROID : 0x0007
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240549.aspx
 */
var MinorType = {
    OSMINORTYPE_UNSPECIFIED : 0x0000,
    OSMINORTYPE_WINDOWS_31X : 0x0001,
    OSMINORTYPE_WINDOWS_95 : 0x0002,
    OSMINORTYPE_WINDOWS_NT : 0x0003,
    OSMINORTYPE_OS2_V21 : 0x0004,
    OSMINORTYPE_POWER_PC : 0x0005,
    OSMINORTYPE_MACINTOSH : 0x0006,
    OSMINORTYPE_NATIVE_XSERVER : 0x0007,
    OSMINORTYPE_PSEUDO_XSERVER : 0x0008,
    OSMINORTYPE_WINDOWS_RT : 0x0009
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240549.aspx
 */
var GeneralExtraFlag = {
    FASTPATH_OUTPUT_SUPPORTED : 0x0001,
    NO_BITMAP_COMPRESSION_HDR : 0x0400,
    LONG_CREDENTIALS_SUPPORTED : 0x0004,
    AUTORECONNECT_SUPPORTED : 0x0008,
    ENC_SALTED_CHECKSUM : 0x0010
};
 
var Boolean = {
    FALSE : 0x00,
    TRUE : 0x01
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240556.aspx
 */
var OrderFlag = {
    NEGOTIATEORDERSUPPORT : 0x0002,
    ZEROBOUNDSDELTASSUPPORT : 0x0008,
    COLORINDEXSUPPORT : 0x0020,
    SOLIDPATTERNBRUSHONLY : 0x0040,
    ORDERFLAGS_EXTRA_FLAGS : 0x0080
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240556.aspx
 */
var Order = {
    TS_NEG_DSTBLT_INDEX : 0x00,
    TS_NEG_PATBLT_INDEX : 0x01,
    TS_NEG_SCRBLT_INDEX : 0x02,
    TS_NEG_MEMBLT_INDEX : 0x03,
    TS_NEG_MEM3BLT_INDEX : 0x04,
    TS_NEG_DRAWNINEGRID_INDEX : 0x07,
    TS_NEG_LINETO_INDEX : 0x08,
    TS_NEG_MULTI_DRAWNINEGRID_INDEX : 0x09,
    TS_NEG_SAVEBITMAP_INDEX : 0x0B,
    TS_NEG_MULTIDSTBLT_INDEX : 0x0F,
    TS_NEG_MULTIPATBLT_INDEX : 0x10,
    TS_NEG_MULTISCRBLT_INDEX : 0x11,
    TS_NEG_MULTIOPAQUERECT_INDEX : 0x12,
    TS_NEG_FAST_INDEX_INDEX : 0x13,
    TS_NEG_POLYGON_SC_INDEX : 0x14,
    TS_NEG_POLYGON_CB_INDEX : 0x15,
    TS_NEG_POLYLINE_INDEX : 0x16,
    TS_NEG_FAST_GLYPH_INDEX : 0x18,
    TS_NEG_ELLIPSE_SC_INDEX : 0x19,
    TS_NEG_ELLIPSE_CB_INDEX : 0x1A,
    TS_NEG_INDEX_INDEX : 0x1B
};
 
var OrderEx = {
    ORDERFLAGS_EX_CACHE_BITMAP_REV3_SUPPORT : 0x0002,
    ORDERFLAGS_EX_ALTSEC_FRAME_MARKER_SUPPORT : 0x0004
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240563.aspx
 */
var InputFlags = {
    INPUT_FLAG_SCANCODES : 0x0001,
    INPUT_FLAG_MOUSEX : 0x0004,
    INPUT_FLAG_FASTPATH_INPUT : 0x0008,
    INPUT_FLAG_UNICODE : 0x0010,
    INPUT_FLAG_FASTPATH_INPUT2 : 0x0020,
    INPUT_FLAG_UNUSED1 : 0x0040,
    INPUT_FLAG_UNUSED2 : 0x0080,
    TS_INPUT_FLAG_MOUSE_HWHEEL : 0x0100
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240564.aspx
 */
var BrushSupport = {
    BRUSH_DEFAULT : 0x00000000,
    BRUSH_COLOR_8x8 : 0x00000001,
    BRUSH_COLOR_FULL : 0x00000002
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240565.aspx
 */
var GlyphSupport = {
    GLYPH_SUPPORT_NONE : 0x0000,
    GLYPH_SUPPORT_PARTIAL : 0x0001,
    GLYPH_SUPPORT_FULL : 0x0002,
    GLYPH_SUPPORT_ENCODE : 0x0003
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240550.aspx
 */
var OffscreenSupportLevel = {
    FALSE : 0x00000000,
    TRUE : 0x00000001
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240551.aspx
 */
var VirtualChannelCompressionFlag = {
    VCCAPS_NO_COMPR : 0x00000000,
    VCCAPS_COMPR_SC : 0x00000001,
    VCCAPS_COMPR_CS_8K : 0x00000002
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240552.aspx
 */
var SoundFlag = {
    NONE : 0x0000,
    SOUND_BEEPS_FLAG : 0x0001
};
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240549.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function generalCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_GENERAL,
        osMajorType : new type.UInt16Le(),
        osMinorType : new type.UInt16Le(),
        protocolVersion : new type.UInt16Le(0x0200, {constant : true}),
        pad2octetsA : new type.UInt16Le(),
        generalCompressionTypes : new type.UInt16Le(0, {constant : true}),
        extraFlags : new type.UInt16Le(),
        updateCapabilityFlag : new type.UInt16Le(0, {constant : true}),
        remoteUnshareFlag : new type.UInt16Le(0, {constant : true}),
        generalCompressionLevel : new type.UInt16Le(0, {constant : true}),
        refreshRectSupport : new type.UInt8(),
        suppressOutputSupport : new type.UInt8()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240554.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function bitmapCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_BITMAP,
        preferredBitsPerPixel : new type.UInt16Le(),
        receive1BitPerPixel : new type.UInt16Le(0x0001),
        receive4BitsPerPixel : new type.UInt16Le(0x0001),
        receive8BitsPerPixel : new type.UInt16Le(0x0001),
        desktopWidth : new type.UInt16Le(),
        desktopHeight : new type.UInt16Le(),
        pad2octets : new type.UInt16Le(),
        desktopResizeFlag : new type.UInt16Le(),
        bitmapCompressionFlag : new type.UInt16Le(0x0001, {constant : true}),
        highColorFlags : new type.UInt8(0),
        drawingFlags : new type.UInt8(),
        multipleRectangleSupport : new type.UInt16Le(0x0001, {constant : true}),
        pad2octetsB : new type.UInt16Le()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240556.aspx
 * @param orders {type.BinaryString|null} list of available orders
 * @param opt {object} type options
 * @returns {type.Component}
 */
function orderCapability(orders, opt) {
    if(orders && orders.size() !== 32) {
        throw new error.FatalError('NODE_RDP_PROTOCOL_PDU_CAPS_BAD_ORDERS_SIZE');
    }
    
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_ORDER,
        terminalDescriptor : new type.BinaryString(Buffer.from(Array(16 + 1).join('\x00'), 'binary'), {readLength : new type.CallableValue(16)}),
        pad4octetsA : new type.UInt32Le(0),
        desktopSaveXGranularity : new type.UInt16Le(1),
        desktopSaveYGranularity : new type.UInt16Le(20),
        pad2octetsA : new type.UInt16Le(0),
        maximumOrderLevel : new type.UInt16Le(1),
        numberFonts : new type.UInt16Le(),
        orderFlags : new type.UInt16Le(OrderFlag.NEGOTIATEORDERSUPPORT),
        orderSupport : orders || new type.Factory(function(s) {
            self.orderSupport = new type.BinaryString(null, {readLength : new type.CallableValue(32)}).read(s);
        }),
        textFlags : new type.UInt16Le(),
        orderSupportExFlags : new type.UInt16Le(),
        pad4octetsB : new type.UInt32Le(),
        desktopSaveSize : new type.UInt32Le(480 * 480),
        pad2octetsC : new type.UInt16Le(),
        pad2octetsD : new type.UInt16Le(),
        textANSICodePage : new type.UInt16Le(0),
        pad2octetsE : new type.UInt16Le()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240559.aspx
 * @param opt type options
 * @returns {type.Component}
 */
function bitmapCacheCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_BITMAPCACHE,
        pad1 : new type.UInt32Le(),
        pad2 : new type.UInt32Le(),
        pad3 : new type.UInt32Le(),
        pad4 : new type.UInt32Le(),
        pad5 : new type.UInt32Le(),
        pad6 : new type.UInt32Le(),
        cache0Entries : new type.UInt16Le(),
        cache0MaximumCellSize : new type.UInt16Le(),
        cache1Entries : new type.UInt16Le(),
        cache1MaximumCellSize : new type.UInt16Le(),
        cache2Entries : new type.UInt16Le(),
        cache2MaximumCellSize : new type.UInt16Le()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * 
 * @param isServer {boolean} true if in server mode
 * @param opt {object} type options
 * @returns {type.Component}
 */
function pointerCapability(isServer, opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_POINTER,
        colorPointerFlag : new type.UInt16Le(),
        colorPointerCacheSize : new type.UInt16Le(20),
        //old version of rdp doesn't support ...
        pointerCacheSize : new type.UInt16Le(null, {conditional : function() {
            return isServer || false;
        }})
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240563.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function inputCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_INPUT,
        inputFlags : new type.UInt16Le(),
        pad2octetsA : new type.UInt16Le(),
        // same value as gcc.ClientCoreSettings.kbdLayout
        keyboardLayout : new type.UInt32Le(),
        // same value as gcc.ClientCoreSettings.keyboardType
        keyboardType : new type.UInt32Le(),
        // same value as gcc.ClientCoreSettings.keyboardSubType
        keyboardSubType : new type.UInt32Le(),
        // same value as gcc.ClientCoreSettings.keyboardFnKeys
        keyboardFunctionKey : new type.UInt32Le(),
        // same value as gcc.ClientCoreSettingrrs.imeFileName
        imeFileName : new type.BinaryString(Buffer.from(Array(64 + 1).join('\x00'), 'binary'), {readLength : new type.CallableValue(64)})
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240564.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function brushCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_BRUSH,
        brushSupportLevel : new type.UInt32Le(BrushSupport.BRUSH_DEFAULT)
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240566.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function cacheEntry(opt) {
    var self = {
        cacheEntries : new type.UInt16Le(),
        cacheMaximumCellSize : new type.UInt16Le()  
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240565.aspx
 * @param entries {type.Component} cache entries
 * @param opt {object} type options
 * @returns {type.Component}
 */
function glyphCapability(entries, opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_GLYPHCACHE,
        glyphCache : entries || new type.Factory(function(s) {
            self.glyphCache = new type.Component([]);
            for(var i = 0; i < 10; i++) {
                self.glyphCache.obj.push(cacheEntry().read(s));
            }
        }),
        fragCache : new type.UInt32Le(),
        // all fonts are sent with bitmap format (very expensive)
        glyphSupportLevel : new type.UInt16Le(GlyphSupport.GLYPH_SUPPORT_NONE),
        pad2octets : new type.UInt16Le()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240550.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function offscreenBitmapCacheCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_OFFSCREENCACHE,
        offscreenSupportLevel : new type.UInt32Le(OffscreenSupportLevel.FALSE),
        offscreenCacheSize : new type.UInt16Le(),
        offscreenCacheEntries : new type.UInt16Le()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240551.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function virtualChannelCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_VIRTUALCHANNEL,
        flags : new type.UInt32Le(VirtualChannelCompressionFlag.VCCAPS_NO_COMPR),
        VCChunkSize : new type.UInt32Le(null, {optional : true})    
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240552.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function soundCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_SOUND,
        soundFlags : new type.UInt16Le(SoundFlag.NONE),
        pad2octetsA : new type.UInt16Le()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240568.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function controlCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_CONTROL,
        controlFlags : new type.UInt16Le(),
        remoteDetachFlag : new type.UInt16Le(),
        controlInterest : new type.UInt16Le(0x0002),
        detachInterest : new type.UInt16Le(0x0002)
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240569.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function windowActivationCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_ACTIVATION,
        helpKeyFlag : new type.UInt16Le(),
        helpKeyIndexFlag : new type.UInt16Le(),
        helpExtendedKeyFlag : new type.UInt16Le(),
        windowManagerKeyFlag : new type.UInt16Le()  
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240571.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function fontCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_FONT,
        fontSupportFlags : new type.UInt16Le(0x0001),
        pad2octets : new type.UInt16Le()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc241564.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function colorCacheCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_COLORCACHE,
        colorTableCacheSize : new type.UInt16Le(0x0006),
        pad2octets : new type.UInt16Le()
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240570.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function shareCapability(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSTYPE_SHARE,
        nodeId : new type.UInt16Le(),
        pad2octets : new type.UInt16Le()    
    };
    
    return new type.Component(self, opt);
}
 
/**
 * @see http://msdn.microsoft.com/en-us/library/cc240649.aspx
 * @param opt {object} type options
 * @returns {type.Component}
 */
function multiFragmentUpdate(opt) {
    var self = {
        __TYPE__ : CapsType.CAPSETTYPE_MULTIFRAGMENTUPDATE,
        MaxRequestSize : new type.UInt32Le(0)
    };
    
    return new type.Component(self, opt);
}
 
/**
 * Capability wrapper packet
 * @see http://msdn.microsoft.com/en-us/library/cc240486.aspx
 * @param cap {type.Component}
 * @param opt {object} type options
 * @returns {type.Component}
 */
function capability(cap, opt) {
    var self = {
        capabilitySetType : new type.UInt16Le(function() {
            return self.capability.obj.__TYPE__;
        }),
        lengthCapability : new type.UInt16Le(function() {
            return new type.Component(self).size();
        }),
        capability : cap || new type.Factory(function(s) {
            switch(self.capabilitySetType.value) {
            case CapsType.CAPSTYPE_GENERAL:
                self.capability = generalCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_BITMAP:
                self.capability = bitmapCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_ORDER:
                self.capability = orderCapability(null, {readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_BITMAPCACHE:
                self.capability = bitmapCacheCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_POINTER:
                self.capability = pointerCapability(false, {readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_INPUT:
                self.capability = inputCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_BRUSH:
                self.capability = brushCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_GLYPHCACHE:
                self.capability = glyphCapability(null, {readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_OFFSCREENCACHE:
                self.capability = offscreenBitmapCacheCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_VIRTUALCHANNEL:
                self.capability = virtualChannelCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_SOUND:
                self.capability = soundCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_CONTROL:
                self.capability = controlCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_ACTIVATION:
                self.capability = windowActivationCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_FONT:
                self.capability = fontCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_COLORCACHE:
                self.capability = colorCacheCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSTYPE_SHARE:
                self.capability = shareCapability({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            case CapsType.CAPSETTYPE_MULTIFRAGMENTUPDATE:
                self.capability = multiFragmentUpdate({readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
                break;
            default:
                log.debug('unknown capability ' + self.capabilitySetType.value);
                self.capability = new type.BinaryString(null, {readLength : new type.CallableValue(function() {
                    return self.lengthCapability.value - 4;
                })}).read(s);
            }
        })
    };
    
    return new type.Component(self, opt);
}
 
/**
 * Module exports
 */
module.exports = {
    CapsType : CapsType,
    MajorType : MajorType,
    MinorType : MinorType,
    GeneralExtraFlag : GeneralExtraFlag,
    Boolean : Boolean,
    OrderFlag : OrderFlag,
    Order : Order,
    OrderEx : OrderEx,
    InputFlags : InputFlags,
    BrushSupport : BrushSupport,
    GlyphSupport : GlyphSupport,
    OffscreenSupportLevel : OffscreenSupportLevel,
    VirtualChannelCompressionFlag : VirtualChannelCompressionFlag,
    SoundFlag : SoundFlag,
    generalCapability : generalCapability,
    bitmapCapability : bitmapCapability,
    orderCapability : orderCapability,
    bitmapCacheCapability : bitmapCacheCapability,
    pointerCapability : pointerCapability,
    inputCapability : inputCapability,
    brushCapability : brushCapability,
    cacheEntry : cacheEntry,
    glyphCapability : glyphCapability,
    offscreenBitmapCacheCapability : offscreenBitmapCacheCapability,
    virtualChannelCapability : virtualChannelCapability,
    soundCapability : soundCapability,
    controlCapability : controlCapability,
    windowActivationCapability : windowActivationCapability,
    fontCapability : fontCapability,
    colorCacheCapability : colorCacheCapability,
    shareCapability : shareCapability,
    multiFragmentUpdate : multiFragmentUpdate,
    capability : capability
};