# HG changeset patch # User Frank Benoit # Date 1216673644 -7200 # Node ID c39d1446f191a325b08d8af205f6cdd8b1180fa3 # Parent 00f135d0337dd33057fc39d961cc3b0ea33ef650 Added dev tools, so they are not in the release code. diff -r 00f135d0337d -r c39d1446f191 devhelpers/README.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/devhelpers/README.txt Mon Jul 21 22:54:04 2008 +0200 @@ -0,0 +1,4 @@ +Programs to help in development of DWT. +They are not intended to be useful for the DWT users. + + diff -r 00f135d0337d -r c39d1446f191 devhelpers/structslinux/results.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/devhelpers/structslinux/results.txt Mon Jul 21 22:54:04 2008 +0200 @@ -0,0 +1,794 @@ +AtkValueIface 32 +AtkMiscClass 204 +AtkMisc 12 +AtkTableIface 168 +AtkStreamableContentIface 36 +AtkStateSetClass 68 +AtkSelectionIface 48 +AtkRelationSetClass 76 +AtkRelationClass 68 +AtkRelation 20 +AtkRegistryClass 68 +AtkRegistry 20 +AtkNoOpObjectFactoryClass 88 +AtkNoOpObjectFactory 12 +AtkObjectFactoryClass 88 +AtkObjectFactory 12 +AtkNoOpObjectClass 176 +AtkNoOpObject 36 +AtkImageIface 32 +AtkHypertextIface 36 +AtkHyperlinkImplIface 16 +AtkHyperlinkClass 108 +AtkHyperlink 12 +AtkGObjectAccessibleClass 184 +AtkGObjectAccessible 36 +AtkEditableTextIface 44 +AtkTextRange 28 +AtkTextRectangle 16 +AtkTextIface 104 +AtkDocumentIface 48 +AtkRectangle 16 +AtkComponentIface 68 +AtkKeyEventStruct 28 +AtkUtilClass 96 +AtkUtil 12 +AtkActionIface 40 +AtkPropertyValues 44 +AtkStateSet 12 +AtkRelationSet 16 +AtkObjectClass 176 +AtkObject 36 +AtkImplementorIface 12 +AtkAttribute 8 +cairo_path_t 12 +cairo_path_data_t 16 +cairo_font_extents_t 40 +cairo_text_extents_t 48 +cairo_glyph_t 20 +cairo_rectangle_list_t 12 +cairo_rectangle_t 32 +cairo_user_data_key_t 4 +cairo_matrix_t 48 +GdkWindowObjectClass 224 +GdkWindowObject 92 +GdkPointerHooks 8 +GdkWindowAttr 60 +GdkGeometry 52 +GdkScreenClass 76 +GdkPixmapObjectClass 224 +GdkPixmapObject 20 +GdkPangoAttrEmbossColor 20 +GdkPangoAttrEmbossed 16 +GdkPangoAttrStipple 16 +GdkPangoRendererClass 124 +GdkPangoRenderer 36 +GdkDisplayManagerClass 72 +GdkKeymapClass 76 +GdkKeymap 16 +GdkKeymapKey 12 +GdkImageClass 68 +GdkTrapezoid 48 +GdkDrawableClass 224 +GdkGCClass 96 +GdkGCValues 88 +GdkDisplayPointerHooks 12 +GdkDisplayClass 88 +GdkEvent 68 +GdkEventGrabBroken 24 +GdkEventSetting 20 +GdkEventWindowState 20 +GdkEventDND 24 +GdkEventClient 40 +GdkEventProximity 20 +GdkEventOwnerChange 32 +GdkEventSelection 32 +GdkEventProperty 24 +GdkEventConfigure 28 +GdkEventCrossing 68 +GdkEventFocus 12 +GdkEventKey 36 +GdkEventScroll 60 +GdkEventButton 64 +GdkEventMotion 64 +GdkEventVisibility 16 +GdkEventNoExpose 12 +GdkEventExpose 36 +GdkEventAny 12 +GdkTimeCoord 1028 +GdkDevice 44 +GdkDeviceAxis 20 +GdkDeviceKey 8 +GdkDragContextClass 68 +GdkDragContext 52 +GdkPixbufLoaderClass 84 +GdkPixbufLoader 16 +GdkRgbCmap 1032 +GdkColormapClass 68 +GdkScreen 284 +GdkDisplay 80 +GdkDrawable 12 +GdkVisual 68 +GdkImage 52 +GdkGC 32 +GdkFont 12 +GdkCursor 8 +GdkColormap 28 +GdkColor 12 +GdkSpan 12 +GdkSegment 16 +GdkRectangle 16 +GdkPoint 8 +GStaticMutex 28 +GSystemThread 8 +GValueArray 12 +GTypePluginClass 24 +GTypeModuleClass 92 +GTypeModule 28 +GParamSpecGType 44 +GParamSpecOverride 44 +GParamSpecObject 40 +GParamSpecValueArray 48 +GParamSpecPointer 40 +GParamSpecBoxed 40 +GParamSpecParam 40 +GParamSpecString 56 +GParamSpecDouble 72 +GParamSpecFloat 56 +GParamSpecFlags 48 +GParamSpecEnum 48 +GParamSpecUnichar 44 +GParamSpecUInt64 64 +GParamSpecInt64 64 +GParamSpecULong 52 +GParamSpecLong 52 +GParamSpecUInt 52 +GParamSpecInt 52 +GParamSpecBoolean 44 +GParamSpecUChar 44 +GParamSpecChar 44 +GObjectConstructParam 8 +GObjectClass 68 +GObject 12 +GSignalInvocationHint 12 +GSignalQuery 28 +GCClosure 20 +GClosureNotifyData 8 +GClosure 16 +GParamSpecTypeInfo 28 +GParameter 24 +GParamSpecClass 40 +GParamSpec 40 +GFlagsValue 12 +GEnumValue 12 +GFlagsClass 16 +GEnumClass 20 +GTypeQuery 16 +GTypeValueTable 32 +GInterfaceInfo 12 +GTypeFundamentalInfo 4 +GTypeInfo 36 +GTypeInstance 4 +GTypeInterface 8 +GTypeClass 4 +GValue 20 +GThreadPool 12 +GTokenValue 8 +GScannerConfig 24 +GScanner 92 +GTuples 4 +GQueue 12 +GOptionEntry 28 +GNode 20 +GMarkupParser 20 +GIOFuncs 32 +GIOChannel 60 +GString 12 +GPollFD 8 +GSourceFuncs 24 +GSourceCallbackFuncs 12 +GSource 52 +GSList 8 +GHookList 28 +GHook 32 +GDate 8 +GCompletion 20 +GList 12 +GMemVTable 24 +GOnce 8 +GStaticRWLock 52 +GStaticRecMutex 40 +GThreadFunctions 84 +GStaticPrivate 4 +GThread 16 +GTrashStack 4 +GDebugKey 8 +GError 12 +GPtrArray 8 +GByteArray 8 +GArray 8 +GTimeVal 8 +GFloatIEEE754 4 +GDoubleIEEE754 8 +GLXEvent 96 +GLXPbufferClobberEvent 52 +GtkVSeparatorClass 364 +GtkVSeparator 60 +GtkVScaleClass 428 +GtkVScale 144 +GtkVRulerClass 388 +GtkVRuler 116 +GtkVPanedClass 456 +GtkVPaned 144 +GtkVolumeButtonClass 492 +GtkVButtonBoxClass 416 +GtkVButtonBox 96 +GtkUIManagerClass 108 +GtkUIManager 16 +GtkTreeStoreClass 84 +GtkTreeStore 60 +GtkTreeModelSortClass 84 +GtkTreeModelSort 76 +GtkTreeDragDestIface 16 +GtkTreeDragSourceIface 20 +GtkToolbarClass 440 +GtkToolbar 112 +GtkToolbarChild 16 +GtkTipsQueryClass 424 +GtkTipsQuery 136 +GtkTextViewClass 496 +GtkTextView 228 +GtkTextBufferClass 140 +GtkTextMarkClass 84 +GtkTextMark 16 +GtkTextTagTableClass 96 +GtkTearoffMenuItemClass 496 +GtkTearoffMenuItem 100 +GtkTableRowCol 8 +GtkTableChild 20 +GtkTableClass 416 +GtkTable 92 +GtkStockItem 20 +GtkStatusIconClass 104 +GtkStatusIcon 16 +GtkStatusbarClass 444 +GtkStatusbar 108 +GtkSpinButtonClass 448 +GtkSpinButton 188 +GtkSizeGroupClass 84 +GtkSizeGroup 28 +GtkSeparatorToolItemClass 460 +GtkSeparatorToolItem 80 +GtkSeparatorMenuItemClass 480 +GtkSeparatorMenuItem 96 +GtkScrolledWindowClass 444 +GtkScrolledWindow 84 +GtkViewportClass 420 +GtkViewport 92 +GtkScaleButtonClass 476 +GtkScaleButton 100 +GtkRecentChooserWidgetClass 416 +GtkRecentChooserWidget 80 +GtkRecentChooserMenuClass 496 +GtkRecentChooserMenu 180 +GtkRecentChooserDialogClass 480 +GtkRecentChooserDialog 164 +GtkRecentChooserIface 64 +GtkRecentFilterInfo 28 +GtkRecentActionClass 112 +GtkRecentAction 20 +GtkRecentManagerClass 88 +GtkRecentManager 16 +GtkRecentData 28 +GtkRadioToolButtonClass 504 +GtkRadioToolButton 84 +GtkToggleToolButtonClass 488 +GtkToggleToolButton 84 +GtkRadioMenuItemClass 520 +GtkRadioMenuItem 104 +GtkRadioButtonClass 512 +GtkRadioButton 96 +GtkRadioActionClass 152 +GtkRadioAction 24 +GtkToggleActionClass 132 +GtkToggleAction 20 +GtkProgressBarClass 408 +GtkProgressBar 124 +GtkProgressClass 392 +GtkProgress 84 +GtkPrintOperation 16 +GtkPrintOperationClass 136 +GtkPrintOperationPreviewIface 56 +GtkPageRange 8 +GtkPreviewClass 376 +GtkDitherInfo 4 +GtkPreviewInfo 12 +GtkPreview 80 +GtkPlugClass 476 +GtkPlug 168 +GtkSocketClass 440 +GtkSocket 96 +GtkPixmapClass 364 +GtkPixmap 88 +GtkOptionMenuClass 476 +GtkOptionMenu 100 +GtkOldEditableClass 432 +GtkOldEditable 80 +GtkNotebookClass 452 +GtkNotebook 104 +GtkMessageDialogClass 496 +GtkMessageDialog 168 +GtkMenuToolButton 84 +GtkMenuToolButtonClass 488 +GtkToolButtonClass 468 +GtkToolButton 80 +GtkToolItemClass 444 +GtkToolItem 76 +GtkTooltipsData 16 +GtkTooltipsClass 96 +GtkTooltips 52 +GtkMenuBarClass 480 +GtkMenuBar 92 +GtkListClass 428 +GtkList 116 +GtkListItemClass 484 +GtkListItem 72 +GtkLinkButtonClass 472 +GtkLinkButton 92 +GtkLayoutClass 436 +GtkLayout 108 +GtkInvisibleClass 380 +GtkInvisible 68 +GtkInputDialogClass 504 +GtkInputDialog 220 +GtkIMMulticontextClass 184 +GtkIMMulticontext 24 +GtkIMContextSimpleClass 168 +GtkIMContextSimple 60 +GtkImageMenuItemClass 480 +GtkImageMenuItem 100 +GtkIconViewClass 452 +GtkIconView 72 +GtkIconThemeClass 72 +GtkIconTheme 16 +GtkIconFactoryClass 84 +GtkHSeparatorClass 364 +GtkHSeparator 60 +GtkSeparatorClass 364 +GtkSeparator 60 +GtkHScaleClass 428 +GtkHScale 144 +GtkScaleClass 428 +GtkScale 144 +GtkHRulerClass 388 +GtkHRuler 116 +GtkRulerMetric 116 +GtkRulerClass 388 +GtkRuler 116 +GtkHPanedClass 456 +GtkHPaned 144 +GtkPanedClass 456 +GtkPaned 144 +GtkHButtonBoxClass 416 +GtkHButtonBox 96 +GtkHandleBoxClass 440 +GtkHandleBox 128 +GtkGammaCurveClass 432 +GtkGammaCurve 116 +GtkFontSelectionDialogClass 496 +GtkFontSelectionDialog 192 +GtkFontSelectionClass 432 +GtkFontSelection 132 +GtkFontButtonClass 476 +GtkFontButton 92 +GtkFileChooserWidgetClass 416 +GtkFileChooserWidget 80 +GtkFileChooserDialogClass 480 +GtkFileChooserDialog 164 +GtkFileChooserButtonClass 448 +GtkFileChooserButton 80 +GtkFileFilterInfo 20 +GtkFixedChild 12 +GtkFixedClass 416 +GtkFixed 72 +GtkFileSelectionClass 496 +GtkFileSelection 248 +GtkExpanderClass 420 +GtkExpander 76 +GtkEventBoxClass 416 +GtkEventBox 72 +GtkCurveClass 400 +GtkCurve 120 +GtkDrawingAreaClass 380 +GtkDrawingArea 64 +GtkCTreeNode 12 +GtkCTreeRow 80 +GtkCTreeClass 556 +GtkCTree 308 +GtkComboBoxEntryClass 452 +GtkComboBoxEntry 80 +GtkComboBoxClass 436 +GtkComboBox 76 +GtkTreeSelectionClass 88 +GtkTreeSelection 32 +GtkTreeViewClass 500 +GtkTreeView 72 +GtkEntryClass 416 +GtkEntry 152 +GtkEntryCompletionClass 92 +GtkEntryCompletion 16 +GtkTreeModelFilterClass 84 +GtkTreeModelFilter 16 +GtkListStoreClass 84 +GtkListStore 64 +GtkIMContextClass 168 +GtkIMContext 12 +GtkEditableClass 48 +GtkComboClass 432 +GtkCombo 112 +GtkHBoxClass 416 +GtkHBox 76 +GtkColorSelectionDialogClass 496 +GtkColorSelectionDialog 176 +GtkColorSelectionClass 436 +GtkColorSelection 80 +GtkVBoxClass 416 +GtkVBox 76 +GtkColorButtonClass 476 +GtkColorButton 92 +GtkCListDestInfo 12 +GtkCListCellInfo 8 +GtkCellWidget 16 +GtkCellPixText 28 +GtkCellPixmap 20 +GtkCellText 16 +GtkCell 28 +GtkCListRow 48 +GtkCListColumn 48 +GtkCListClass 532 +GtkCList 284 +GtkVScrollbarClass 420 +GtkVScrollbar 136 +GtkHScrollbarClass 420 +GtkHScrollbar 136 +GtkScrollbarClass 420 +GtkScrollbar 136 +GtkRangeClass 404 +GtkRange 136 +GtkTargetPair 12 +GtkTargetEntry 12 +GtkTargetList 8 +GtkTextBuffer 40 +GtkTextChildAnchorClass 84 +GtkTextChildAnchor 16 +GtkTextAppearance 44 +GtkTextTagClass 88 +GtkTextTag 32 +GtkTextAttributes 112 +GtkTextTagTable 28 +GtkTextIter 56 +GtkCheckMenuItemClass 504 +GtkCheckMenuItem 100 +GtkMenuItemClass 480 +GtkMenuItem 96 +GtkItemClass 444 +GtkItem 72 +GtkCheckButtonClass 496 +GtkCheckButton 92 +GtkToggleButtonClass 476 +GtkToggleButton 92 +GtkCellViewClass 364 +GtkCellView 64 +GtkCellRendererToggleClass 132 +GtkCellRendererToggle 44 +GtkCellRendererSpinClass 132 +GtkCellRendererSpin 88 +GtkCellRendererProgressClass 128 +GtkCellRendererProgress 44 +GtkCellRendererPixbufClass 128 +GtkCellRendererPixbuf 52 +GtkCellRendererComboClass 132 +GtkCellRendererCombo 104 +GtkCellRendererAccelClass 160 +GtkCellRendererAccel 116 +GtkCellRendererTextClass 132 +GtkCellRendererText 88 +GtkCellLayoutIface 40 +GtkTreeViewColumnClass 100 +GtkTreeViewColumn 124 +GtkTreeSortableIface 32 +GtkTreeModelIface 84 +GtkTreeIter 16 +GtkCellRendererClass 112 +GtkCellRenderer 40 +GtkCellEditableIface 20 +GtkCalendarClass 392 +GtkCalendar 996 +GtkButtonClass 456 +GtkButton 88 +GtkImageIconNameData 12 +GtkImageAnimationData 12 +GtkImageIconSetData 4 +GtkImageStockData 4 +GtkImagePixbufData 4 +GtkImageImageData 4 +GtkImagePixmapData 4 +GtkImageClass 380 +GtkImage 96 +GtkBuildableIface 48 +GtkBuilderClass 104 +GtkBuilder 16 +GtkBindingArg 12 +GtkBindingSignal 16 +GtkBindingEntry 28 +GtkBindingSet 32 +GtkButtonBoxClass 416 +GtkButtonBox 96 +GtkBoxChild 8 +GtkBoxClass 416 +GtkBox 76 +GtkAssistantClass 492 +GtkAssistant 176 +GtkAspectFrameClass 420 +GtkAspectFrame 136 +GtkFrameClass 420 +GtkFrame 104 +GtkArrowClass 364 +GtkArrow 76 +GtkAlignmentClass 416 +GtkAlignment 88 +GtkRadioActionEntry 24 +GtkToggleActionEntry 28 +GtkActionEntry 24 +GtkActionGroupClass 88 +GtkActionGroup 16 +GtkMenuEntry 20 +GtkItemFactoryItem 8 +GtkItemFactoryEntry 24 +GtkItemFactoryClass 100 +GtkItemFactory 44 +GtkActionClass 112 +GtkAction 16 +GtkAccessibleClass 196 +GtkAccessible 40 +GtkAccelLabelClass 440 +GtkAccelLabel 140 +GtkLabelClass 392 +GtkLabel 112 +GtkMenuClass 480 +GtkMenu 176 +GtkMenuShellClass 464 +GtkMenuShell 92 +GtkMiscClass 364 +GtkMisc 72 +GtkAboutDialogClass 496 +GtkAboutDialog 164 +GtkDialogClass 480 +GtkDialog 160 +GtkWindowGroupClass 84 +GtkWindowGroup 16 +GtkWindowClass 456 +GtkBinClass 416 +GtkBin 72 +GtkContainerClass 416 +GtkContainer 68 +GtkWindow 148 +GtkWidgetShapeInfo 8 +GtkWidgetAuxInfo 20 +GtkWidgetClass 364 +GtkSelectionData 28 +GtkRequisition 8 +GtkSettingsValue 24 +GtkSettingsClass 68 +GtkRcStyleClass 100 +GtkIconFactory 16 +GtkWidget 60 +GtkSettings 28 +GtkRcProperty 32 +GtkRcStyle 324 +GtkStyleClass 228 +GtkStyle 752 +GtkBorder 16 +GtkAdjustmentClass 104 +GtkAdjustment 64 +GtkObjectClass 80 +GtkTypeInfo 32 +GtkObject 16 +GtkArg 16 +GtkAccelGroupEntry 20 +GtkAccelKey 12 +GtkAccelGroupClass 88 +GtkAccelGroup 32 +GtkPrintUnixDialogClass 508 +GtkPrintUnixDialog 164 +GtkPrintJobClass 100 +GtkPrintJob 48 +GtkPrinterClass 100 +GtkPrinter 16 +GtkPageSetupUnixDialogClass 508 +GtkPageSetupUnixDialog 164 +PangoRendererClass 124 +PangoRenderer 32 +PangoLayoutLine 20 +PangoGlyphItem 8 +PangoGlyphString 16 +PangoGlyphInfo 20 +PangoGlyphVisAttr 4 +PangoGlyphGeometry 12 +PangoItem 36 +PangoAnalysis 24 +PangoAttrShape 56 +PangoAttrFontDesc 16 +PangoAttrColor 20 +PangoAttrFloat 20 +PangoAttrSize 20 +PangoAttrInt 16 +PangoAttrLanguage 16 +PangoAttrString 16 +PangoAttrClass 16 +PangoAttribute 12 +PangoColor 6 +PangoMatrix 48 +PangoRectangle 16 +PangoLogAttr 4 +XExtensionVersion 8 +XButtonState 36 +XKeyState 36 +XValuatorState 8 +XDeviceState 12 +XDeviceTimeCoord 8 +XEventList 8 +XDevice 12 +XInputClassInfo 2 +XValuatorInfo 20 +XAxisInfo 12 +XButtonInfo 12 +XKeyInfo 16 +XDeviceInfo 24 +XDeviceEnableControl 12 +XDeviceCoreState 16 +XDeviceCoreControl 12 +XDeviceAbsAreaControl 32 +XDeviceAbsCalibControl 40 +XDeviceResolutionState 24 +XDeviceResolutionControl 20 +XDeviceControl 8 +XLedFeedbackControl 20 +XBellFeedbackControl 24 +XIntegerFeedbackControl 16 +XStringFeedbackControl 20 +XKbdFeedbackControl 44 +XPtrFeedbackControl 24 +XFeedbackControl 12 +XLedFeedbackState 20 +XBellFeedbackState 24 +XStringFeedbackState 24 +XIntegerFeedbackState 24 +XPtrFeedbackState 24 +XKbdFeedbackState 68 +XFeedbackState 12 +XDevicePresenceNotifyEvent 36 +XChangeDeviceNotifyEvent 32 +XDeviceMappingEvent 40 +XButtonStatus 36 +XKeyStatus 36 +XValuatorStatus 28 +XDeviceStateNotifyEvent 96 +XInputClass 2 +XProximityNotifyEvent 92 +XDeviceFocusChangeEvent 36 +XDeviceMotionEvent 96 +XDeviceButtonEvent 96 +XDeviceKeyEvent 96 +XIMValuesList 8 +XIMHotKeyTriggers 8 +XIMHotKeyTrigger 12 +XIMStatusDrawCallbackStruct 8 +XIMPreeditCaretCallbackStruct 12 +XIMPreeditDrawCallbackStruct 16 +XIMStringConversionCallbackStruct 16 +XIMStringConversionText 16 +XIMPreeditStateNotifyCallbackStruct 4 +XIMText 16 +XICCallback 8 +XIMCallback 8 +XIMStyles 8 +XOMFontInfo 12 +XOMOrientation 8 +XOMCharSetList 8 +XwcTextItem 16 +XmbTextItem 16 +XFontSetExtents 16 +XEDataObject 4 +XTextItem16 16 +XChar2b 2 +XTextItem 16 +XFontStruct 80 +XFontProp 8 +XCharStruct 12 +XEvent 96 +XAnyEvent 20 +XErrorEvent 20 +XMappingEvent 32 +XClientMessageEvent 48 +XColormapEvent 32 +XSelectionEvent 36 +XSelectionRequestEvent 40 +XSelectionClearEvent 28 +XPropertyEvent 32 +XCirculateRequestEvent 28 +XCirculateEvent 28 +XConfigureRequestEvent 56 +XResizeRequestEvent 28 +XGravityEvent 32 +XConfigureEvent 52 +XReparentEvent 40 +XMapRequestEvent 24 +XMapEvent 28 +XUnmapEvent 28 +XDestroyWindowEvent 24 +XCreateWindowEvent 48 +XVisibilityEvent 24 +XNoExposeEvent 28 +XGraphicsExposeEvent 48 +XExposeEvent 40 +XKeymapEvent 52 +XFocusChangeEvent 28 +XCrossingEvent 68 +XMotionEvent 60 +XButtonEvent 60 +XKeyEvent 60 +XModifierKeymap 8 +XTimeCoord 8 +XKeyboardState 56 +XKeyboardControl 32 +XArc 12 +XRectangle 8 +XPoint 4 +XSegment 8 +XColor 12 +XWindowChanges 28 +XImage 88 +XServerInterpretedAddress 16 +XHostAddress 12 +XWindowAttributes 92 +XSetWindowAttributes 60 +ScreenFormat 16 +Screen 80 +Depth 12 +Visual 32 +XGCValues 92 +XPixmapFormatValues 12 +XExtCodes 16 +XExtData 16 +XConicalGradient 12 +XRadialGradient 24 +XLinearGradient 16 +XTrap 24 +XSpanFix 12 +XAnimCursor 8 +XIndexValue 12 +XFilters 16 +XTransform 36 +XTrapezoid 40 +XCircle 12 +XTriangle 24 +XLineFixed 16 +XPointFixed 8 +XPointDouble 16 +XGlyphElt32 20 +XGlyphElt16 20 +XGlyphElt8 20 +XGlyphInfo 12 +XRenderColor 8 +XRenderPictureAttributes 52 +XRenderPictFormat 32 +XRenderDirectFormat 16 +XStandardColormap 40 +XVisualInfo 40 +XComposeStatus 8 +XClassHint 8 +XIconSize 24 +XTextProperty 16 +XWMHints 36 +XSizeHints 72 diff -r 00f135d0337d -r c39d1446f191 devhelpers/structslinux/structs.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/devhelpers/structslinux/structs.c Mon Jul 21 22:54:04 2008 +0200 @@ -0,0 +1,831 @@ +// Author: Frank Benoit +// This prints the sizes of some C struct how the GCC sees them +// Build with: +// gcc structs.c `pkg-config --cflags xtst cairo-xlib-xrender gtk+-2.0 gtk+-x11-2.0 pangox gdk-2.0 fontconfig gthread-2.0 cairo-xlib cairo pango gtk+-unix-print-2.0` 2>&1 | head -n 20 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct { + const char* name; + int size; +} TSizeValue; + +const TSizeValue size_values[] = { + { "AtkValueIface", sizeof( AtkValueIface ) }, + { "AtkMiscClass", sizeof( AtkMiscClass ) }, + { "AtkMisc", sizeof( AtkMisc ) }, + { "AtkTableIface", sizeof( AtkTableIface ) }, + { "AtkStreamableContentIface", sizeof( AtkStreamableContentIface ) }, + { "AtkStateSetClass", sizeof( AtkStateSetClass ) }, + { "AtkSelectionIface", sizeof( AtkSelectionIface ) }, + { "AtkRelationSetClass", sizeof( AtkRelationSetClass ) }, + { "AtkRelationClass", sizeof( AtkRelationClass ) }, + { "AtkRelation", sizeof( AtkRelation ) }, + { "AtkRegistryClass", sizeof( AtkRegistryClass ) }, + { "AtkRegistry", sizeof( AtkRegistry ) }, + { "AtkNoOpObjectFactoryClass", sizeof( AtkNoOpObjectFactoryClass ) }, + { "AtkNoOpObjectFactory", sizeof( AtkNoOpObjectFactory ) }, + { "AtkObjectFactoryClass", sizeof( AtkObjectFactoryClass ) }, + { "AtkObjectFactory", sizeof( AtkObjectFactory ) }, + { "AtkNoOpObjectClass", sizeof( AtkNoOpObjectClass ) }, + { "AtkNoOpObject", sizeof( AtkNoOpObject ) }, + { "AtkImageIface", sizeof( AtkImageIface ) }, + { "AtkHypertextIface", sizeof( AtkHypertextIface ) }, + { "AtkHyperlinkImplIface", sizeof( AtkHyperlinkImplIface ) }, + { "AtkHyperlinkClass", sizeof( AtkHyperlinkClass ) }, + { "AtkHyperlink", sizeof( AtkHyperlink ) }, + { "AtkGObjectAccessibleClass", sizeof( AtkGObjectAccessibleClass ) }, + { "AtkGObjectAccessible", sizeof( AtkGObjectAccessible ) }, + { "AtkEditableTextIface", sizeof( AtkEditableTextIface ) }, + { "AtkTextRange", sizeof( AtkTextRange ) }, + { "AtkTextRectangle", sizeof( AtkTextRectangle ) }, + { "AtkTextIface", sizeof( AtkTextIface ) }, + { "AtkDocumentIface", sizeof( AtkDocumentIface ) }, + { "AtkRectangle", sizeof( AtkRectangle ) }, + { "AtkComponentIface", sizeof( AtkComponentIface ) }, + { "AtkKeyEventStruct", sizeof( AtkKeyEventStruct ) }, + { "AtkUtilClass", sizeof( AtkUtilClass ) }, + { "AtkUtil", sizeof( AtkUtil ) }, + { "AtkActionIface", sizeof( AtkActionIface ) }, + { "AtkPropertyValues", sizeof( AtkPropertyValues ) }, + { "AtkStateSet", sizeof( AtkStateSet ) }, + { "AtkRelationSet", sizeof( AtkRelationSet ) }, + { "AtkObjectClass", sizeof( AtkObjectClass ) }, + { "AtkObject", sizeof( AtkObject ) }, + { "AtkImplementorIface", sizeof( AtkImplementorIface ) }, + { "AtkAttribute", sizeof( AtkAttribute ) }, + { "cairo_path_t", sizeof( cairo_path_t ) }, + { "cairo_path_data_t", sizeof( cairo_path_data_t ) }, + { "cairo_font_extents_t", sizeof( cairo_font_extents_t ) }, + { "cairo_text_extents_t", sizeof( cairo_text_extents_t ) }, + { "cairo_glyph_t", sizeof( cairo_glyph_t ) }, + { "cairo_rectangle_list_t", sizeof( cairo_rectangle_list_t ) }, + { "cairo_rectangle_t", sizeof( cairo_rectangle_t ) }, + { "cairo_user_data_key_t", sizeof( cairo_user_data_key_t ) }, + { "cairo_matrix_t", sizeof( cairo_matrix_t ) }, + { "GdkWindowObjectClass", sizeof( GdkWindowObjectClass ) }, + { "GdkWindowObject", sizeof( GdkWindowObject ) }, + { "GdkPointerHooks", sizeof( GdkPointerHooks ) }, + { "GdkWindowAttr", sizeof( GdkWindowAttr ) }, + { "GdkGeometry", sizeof( GdkGeometry ) }, + { "GdkScreenClass", sizeof( GdkScreenClass ) }, + { "GdkPixmapObjectClass", sizeof( GdkPixmapObjectClass ) }, + { "GdkPixmapObject", sizeof( GdkPixmapObject ) }, + { "GdkPangoAttrEmbossColor", sizeof( GdkPangoAttrEmbossColor ) }, + { "GdkPangoAttrEmbossed", sizeof( GdkPangoAttrEmbossed ) }, + { "GdkPangoAttrStipple", sizeof( GdkPangoAttrStipple ) }, + { "GdkPangoRendererClass", sizeof( GdkPangoRendererClass ) }, + { "GdkPangoRenderer", sizeof( GdkPangoRenderer ) }, + { "GdkDisplayManagerClass", sizeof( GdkDisplayManagerClass ) }, + { "GdkKeymapClass", sizeof( GdkKeymapClass ) }, + { "GdkKeymap", sizeof( GdkKeymap ) }, + { "GdkKeymapKey", sizeof( GdkKeymapKey ) }, + { "GdkImageClass", sizeof( GdkImageClass ) }, + { "GdkTrapezoid", sizeof( GdkTrapezoid ) }, + { "GdkDrawableClass", sizeof( GdkDrawableClass ) }, + { "GdkGCClass", sizeof( GdkGCClass ) }, + { "GdkGCValues", sizeof( GdkGCValues ) }, + { "GdkDisplayPointerHooks", sizeof( GdkDisplayPointerHooks ) }, + { "GdkDisplayClass", sizeof( GdkDisplayClass ) }, + { "GdkEvent", sizeof( GdkEvent ) }, + { "GdkEventGrabBroken", sizeof( GdkEventGrabBroken ) }, + { "GdkEventSetting", sizeof( GdkEventSetting ) }, + { "GdkEventWindowState", sizeof( GdkEventWindowState ) }, + { "GdkEventDND", sizeof( GdkEventDND ) }, + { "GdkEventClient", sizeof( GdkEventClient ) }, + { "GdkEventProximity", sizeof( GdkEventProximity ) }, + { "GdkEventOwnerChange", sizeof( GdkEventOwnerChange ) }, + { "GdkEventSelection", sizeof( GdkEventSelection ) }, + { "GdkEventProperty", sizeof( GdkEventProperty ) }, + { "GdkEventConfigure", sizeof( GdkEventConfigure ) }, + { "GdkEventCrossing", sizeof( GdkEventCrossing ) }, + { "GdkEventFocus", sizeof( GdkEventFocus ) }, + { "GdkEventKey", sizeof( GdkEventKey ) }, + { "GdkEventScroll", sizeof( GdkEventScroll ) }, + { "GdkEventButton", sizeof( GdkEventButton ) }, + { "GdkEventMotion", sizeof( GdkEventMotion ) }, + { "GdkEventVisibility", sizeof( GdkEventVisibility ) }, + { "GdkEventNoExpose", sizeof( GdkEventNoExpose ) }, + { "GdkEventExpose", sizeof( GdkEventExpose ) }, + { "GdkEventAny", sizeof( GdkEventAny ) }, + { "GdkTimeCoord", sizeof( GdkTimeCoord ) }, + { "GdkDevice", sizeof( GdkDevice ) }, + { "GdkDeviceAxis", sizeof( GdkDeviceAxis ) }, + { "GdkDeviceKey", sizeof( GdkDeviceKey ) }, + { "GdkDragContextClass", sizeof( GdkDragContextClass ) }, + { "GdkDragContext", sizeof( GdkDragContext ) }, + { "GdkPixbufLoaderClass", sizeof( GdkPixbufLoaderClass ) }, + { "GdkPixbufLoader", sizeof( GdkPixbufLoader ) }, + { "GdkRgbCmap", sizeof( GdkRgbCmap ) }, + { "GdkColormapClass", sizeof( GdkColormapClass ) }, + { "GdkScreen", sizeof( GdkScreen ) }, + { "GdkDisplay", sizeof( GdkDisplay ) }, + { "GdkDrawable", sizeof( GdkDrawable ) }, + { "GdkVisual", sizeof( GdkVisual ) }, + { "GdkImage", sizeof( GdkImage ) }, + { "GdkGC", sizeof( GdkGC ) }, + { "GdkFont", sizeof( GdkFont ) }, + { "GdkCursor", sizeof( GdkCursor ) }, + { "GdkColormap", sizeof( GdkColormap ) }, + { "GdkColor", sizeof( GdkColor ) }, + { "GdkSpan", sizeof( GdkSpan ) }, + { "GdkSegment", sizeof( GdkSegment ) }, + { "GdkRectangle", sizeof( GdkRectangle ) }, + { "GdkPoint", sizeof( GdkPoint ) }, + { "GStaticMutex", sizeof( GStaticMutex ) }, + { "GSystemThread", sizeof( GSystemThread ) }, + { "GValueArray", sizeof( GValueArray ) }, + { "GTypePluginClass", sizeof( GTypePluginClass ) }, + { "GTypeModuleClass", sizeof( GTypeModuleClass ) }, + { "GTypeModule", sizeof( GTypeModule ) }, + { "GParamSpecGType", sizeof( GParamSpecGType ) }, + { "GParamSpecOverride", sizeof( GParamSpecOverride ) }, + { "GParamSpecObject", sizeof( GParamSpecObject ) }, + { "GParamSpecValueArray", sizeof( GParamSpecValueArray ) }, + { "GParamSpecPointer", sizeof( GParamSpecPointer ) }, + { "GParamSpecBoxed", sizeof( GParamSpecBoxed ) }, + { "GParamSpecParam", sizeof( GParamSpecParam ) }, + { "GParamSpecString", sizeof( GParamSpecString ) }, + { "GParamSpecDouble", sizeof( GParamSpecDouble ) }, + { "GParamSpecFloat", sizeof( GParamSpecFloat ) }, + { "GParamSpecFlags", sizeof( GParamSpecFlags ) }, + { "GParamSpecEnum", sizeof( GParamSpecEnum ) }, + { "GParamSpecUnichar", sizeof( GParamSpecUnichar ) }, + { "GParamSpecUInt64", sizeof( GParamSpecUInt64 ) }, + { "GParamSpecInt64", sizeof( GParamSpecInt64 ) }, + { "GParamSpecULong", sizeof( GParamSpecULong ) }, + { "GParamSpecLong", sizeof( GParamSpecLong ) }, + { "GParamSpecUInt", sizeof( GParamSpecUInt ) }, + { "GParamSpecInt", sizeof( GParamSpecInt ) }, + { "GParamSpecBoolean", sizeof( GParamSpecBoolean ) }, + { "GParamSpecUChar", sizeof( GParamSpecUChar ) }, + { "GParamSpecChar", sizeof( GParamSpecChar ) }, + { "GObjectConstructParam", sizeof( GObjectConstructParam ) }, + { "GObjectClass", sizeof( GObjectClass ) }, + { "GObject", sizeof( GObject ) }, + { "GSignalInvocationHint", sizeof( GSignalInvocationHint ) }, + { "GSignalQuery", sizeof( GSignalQuery ) }, + { "GCClosure", sizeof( GCClosure ) }, + { "GClosureNotifyData", sizeof( GClosureNotifyData ) }, + { "GClosure", sizeof( GClosure ) }, + { "GParamSpecTypeInfo", sizeof( GParamSpecTypeInfo ) }, + { "GParameter", sizeof( GParameter ) }, + { "GParamSpecClass", sizeof( GParamSpecClass ) }, + { "GParamSpec", sizeof( GParamSpec ) }, + { "GFlagsValue", sizeof( GFlagsValue ) }, + { "GEnumValue", sizeof( GEnumValue ) }, + { "GFlagsClass", sizeof( GFlagsClass ) }, + { "GEnumClass", sizeof( GEnumClass ) }, + { "GTypeQuery", sizeof( GTypeQuery ) }, + { "GTypeValueTable", sizeof( GTypeValueTable ) }, + { "GInterfaceInfo", sizeof( GInterfaceInfo ) }, + { "GTypeFundamentalInfo", sizeof( GTypeFundamentalInfo ) }, + { "GTypeInfo", sizeof( GTypeInfo ) }, + { "GTypeInstance", sizeof( GTypeInstance ) }, + { "GTypeInterface", sizeof( GTypeInterface ) }, + { "GTypeClass", sizeof( GTypeClass ) }, + { "GValue", sizeof( GValue ) }, + { "GThreadPool", sizeof( GThreadPool ) }, + { "GTokenValue", sizeof( GTokenValue ) }, + { "GScannerConfig", sizeof( GScannerConfig ) }, + { "GScanner", sizeof( GScanner ) }, + { "GTuples", sizeof( GTuples ) }, + { "GQueue", sizeof( GQueue ) }, + { "GOptionEntry", sizeof( GOptionEntry ) }, + { "GNode", sizeof( GNode ) }, + { "GMarkupParser", sizeof( GMarkupParser ) }, + { "GIOFuncs", sizeof( GIOFuncs ) }, + { "GIOChannel", sizeof( GIOChannel ) }, + { "GString", sizeof( GString ) }, + { "GPollFD", sizeof( GPollFD ) }, + { "GSourceFuncs", sizeof( GSourceFuncs ) }, + { "GSourceCallbackFuncs", sizeof( GSourceCallbackFuncs ) }, + { "GSource", sizeof( GSource ) }, + { "GSList", sizeof( GSList ) }, + { "GHookList", sizeof( GHookList ) }, + { "GHook", sizeof( GHook ) }, + { "GDate", sizeof( GDate ) }, + { "GCompletion", sizeof( GCompletion ) }, + { "GList", sizeof( GList ) }, + { "GMemVTable", sizeof( GMemVTable ) }, + { "GOnce", sizeof( GOnce ) }, + { "GStaticRWLock", sizeof( GStaticRWLock ) }, + { "GStaticRecMutex", sizeof( GStaticRecMutex ) }, + { "GThreadFunctions", sizeof( GThreadFunctions ) }, + { "GStaticPrivate", sizeof( GStaticPrivate ) }, + { "GThread", sizeof( GThread ) }, + { "GTrashStack", sizeof( GTrashStack ) }, + { "GDebugKey", sizeof( GDebugKey ) }, + { "GError", sizeof( GError ) }, + { "GPtrArray", sizeof( GPtrArray ) }, + { "GByteArray", sizeof( GByteArray ) }, + { "GArray", sizeof( GArray ) }, + { "GTimeVal", sizeof( GTimeVal ) }, + { "GFloatIEEE754", sizeof( GFloatIEEE754 ) }, + { "GDoubleIEEE754", sizeof( GDoubleIEEE754 ) }, + { "GLXEvent", sizeof( GLXEvent ) }, + { "GLXPbufferClobberEvent", sizeof( GLXPbufferClobberEvent ) }, + { "GtkVSeparatorClass", sizeof( GtkVSeparatorClass ) }, + { "GtkVSeparator", sizeof( GtkVSeparator ) }, + { "GtkVScaleClass", sizeof( GtkVScaleClass ) }, + { "GtkVScale", sizeof( GtkVScale ) }, + { "GtkVRulerClass", sizeof( GtkVRulerClass ) }, + { "GtkVRuler", sizeof( GtkVRuler ) }, + { "GtkVPanedClass", sizeof( GtkVPanedClass ) }, + { "GtkVPaned", sizeof( GtkVPaned ) }, + { "GtkVolumeButtonClass", sizeof( GtkVolumeButtonClass ) }, + { "GtkVButtonBoxClass", sizeof( GtkVButtonBoxClass ) }, + { "GtkVButtonBox", sizeof( GtkVButtonBox ) }, + { "GtkUIManagerClass", sizeof( GtkUIManagerClass ) }, + { "GtkUIManager", sizeof( GtkUIManager ) }, + { "GtkTreeStoreClass", sizeof( GtkTreeStoreClass ) }, + { "GtkTreeStore", sizeof( GtkTreeStore ) }, + { "GtkTreeModelSortClass", sizeof( GtkTreeModelSortClass ) }, + { "GtkTreeModelSort", sizeof( GtkTreeModelSort ) }, + { "GtkTreeDragDestIface", sizeof( GtkTreeDragDestIface ) }, + { "GtkTreeDragSourceIface", sizeof( GtkTreeDragSourceIface ) }, + { "GtkToolbarClass", sizeof( GtkToolbarClass ) }, + { "GtkToolbar", sizeof( GtkToolbar ) }, + { "GtkToolbarChild", sizeof( GtkToolbarChild ) }, + { "GtkTipsQueryClass", sizeof( GtkTipsQueryClass ) }, + { "GtkTipsQuery", sizeof( GtkTipsQuery ) }, + { "GtkTextViewClass", sizeof( GtkTextViewClass ) }, + { "GtkTextView", sizeof( GtkTextView ) }, + { "GtkTextBufferClass", sizeof( GtkTextBufferClass ) }, + { "GtkTextMarkClass", sizeof( GtkTextMarkClass ) }, + { "GtkTextMark", sizeof( GtkTextMark ) }, + { "GtkTextTagTableClass", sizeof( GtkTextTagTableClass ) }, + { "GtkTearoffMenuItemClass", sizeof( GtkTearoffMenuItemClass ) }, + { "GtkTearoffMenuItem", sizeof( GtkTearoffMenuItem ) }, + { "GtkTableRowCol", sizeof( GtkTableRowCol ) }, + { "GtkTableChild", sizeof( GtkTableChild ) }, + { "GtkTableClass", sizeof( GtkTableClass ) }, + { "GtkTable", sizeof( GtkTable ) }, + { "GtkStockItem", sizeof( GtkStockItem ) }, + { "GtkStatusIconClass", sizeof( GtkStatusIconClass ) }, + { "GtkStatusIcon", sizeof( GtkStatusIcon ) }, + { "GtkStatusbarClass", sizeof( GtkStatusbarClass ) }, + { "GtkStatusbar", sizeof( GtkStatusbar ) }, + { "GtkSpinButtonClass", sizeof( GtkSpinButtonClass ) }, + { "GtkSpinButton", sizeof( GtkSpinButton ) }, + { "GtkSizeGroupClass", sizeof( GtkSizeGroupClass ) }, + { "GtkSizeGroup", sizeof( GtkSizeGroup ) }, + { "GtkSeparatorToolItemClass", sizeof( GtkSeparatorToolItemClass ) }, + { "GtkSeparatorToolItem", sizeof( GtkSeparatorToolItem ) }, + { "GtkSeparatorMenuItemClass", sizeof( GtkSeparatorMenuItemClass ) }, + { "GtkSeparatorMenuItem", sizeof( GtkSeparatorMenuItem ) }, + { "GtkScrolledWindowClass", sizeof( GtkScrolledWindowClass ) }, + { "GtkScrolledWindow", sizeof( GtkScrolledWindow ) }, + { "GtkViewportClass", sizeof( GtkViewportClass ) }, + { "GtkViewport", sizeof( GtkViewport ) }, + { "GtkScaleButtonClass", sizeof( GtkScaleButtonClass ) }, + { "GtkScaleButton", sizeof( GtkScaleButton ) }, + { "GtkRecentChooserWidgetClass", sizeof( GtkRecentChooserWidgetClass ) }, + { "GtkRecentChooserWidget", sizeof( GtkRecentChooserWidget ) }, + { "GtkRecentChooserMenuClass", sizeof( GtkRecentChooserMenuClass ) }, + { "GtkRecentChooserMenu", sizeof( GtkRecentChooserMenu ) }, + { "GtkRecentChooserDialogClass", sizeof( GtkRecentChooserDialogClass ) }, + { "GtkRecentChooserDialog", sizeof( GtkRecentChooserDialog ) }, + { "GtkRecentChooserIface", sizeof( GtkRecentChooserIface ) }, + { "GtkRecentFilterInfo", sizeof( GtkRecentFilterInfo ) }, + { "GtkRecentActionClass", sizeof( GtkRecentActionClass ) }, + { "GtkRecentAction", sizeof( GtkRecentAction ) }, + { "GtkRecentManagerClass", sizeof( GtkRecentManagerClass ) }, + { "GtkRecentManager", sizeof( GtkRecentManager ) }, + { "GtkRecentData", sizeof( GtkRecentData ) }, + { "GtkRadioToolButtonClass", sizeof( GtkRadioToolButtonClass ) }, + { "GtkRadioToolButton", sizeof( GtkRadioToolButton ) }, + { "GtkToggleToolButtonClass", sizeof( GtkToggleToolButtonClass ) }, + { "GtkToggleToolButton", sizeof( GtkToggleToolButton ) }, + { "GtkRadioMenuItemClass", sizeof( GtkRadioMenuItemClass ) }, + { "GtkRadioMenuItem", sizeof( GtkRadioMenuItem ) }, + { "GtkRadioButtonClass", sizeof( GtkRadioButtonClass ) }, + { "GtkRadioButton", sizeof( GtkRadioButton ) }, + { "GtkRadioActionClass", sizeof( GtkRadioActionClass ) }, + { "GtkRadioAction", sizeof( GtkRadioAction ) }, + { "GtkToggleActionClass", sizeof( GtkToggleActionClass ) }, + { "GtkToggleAction", sizeof( GtkToggleAction ) }, + { "GtkProgressBarClass", sizeof( GtkProgressBarClass ) }, + { "GtkProgressBar", sizeof( GtkProgressBar ) }, + { "GtkProgressClass", sizeof( GtkProgressClass ) }, + { "GtkProgress", sizeof( GtkProgress ) }, + { "GtkPrintOperation", sizeof( GtkPrintOperation ) }, + { "GtkPrintOperationClass", sizeof( GtkPrintOperationClass ) }, + { "GtkPrintOperationPreviewIface", sizeof( GtkPrintOperationPreviewIface ) }, + { "GtkPageRange", sizeof( GtkPageRange ) }, + { "GtkPreviewClass", sizeof( GtkPreviewClass ) }, + { "GtkDitherInfo", sizeof( GtkDitherInfo ) }, + { "GtkPreviewInfo", sizeof( GtkPreviewInfo ) }, + { "GtkPreview", sizeof( GtkPreview ) }, + { "GtkPlugClass", sizeof( GtkPlugClass ) }, + { "GtkPlug", sizeof( GtkPlug ) }, + { "GtkSocketClass", sizeof( GtkSocketClass ) }, + { "GtkSocket", sizeof( GtkSocket ) }, + { "GtkPixmapClass", sizeof( GtkPixmapClass ) }, + { "GtkPixmap", sizeof( GtkPixmap ) }, + { "GtkOptionMenuClass", sizeof( GtkOptionMenuClass ) }, + { "GtkOptionMenu", sizeof( GtkOptionMenu ) }, + { "GtkOldEditableClass", sizeof( GtkOldEditableClass ) }, + { "GtkOldEditable", sizeof( GtkOldEditable ) }, + { "GtkNotebookClass", sizeof( GtkNotebookClass ) }, + { "GtkNotebook", sizeof( GtkNotebook ) }, + { "GtkMessageDialogClass", sizeof( GtkMessageDialogClass ) }, + { "GtkMessageDialog", sizeof( GtkMessageDialog ) }, + { "GtkMenuToolButton", sizeof( GtkMenuToolButton ) }, + { "GtkMenuToolButtonClass", sizeof( GtkMenuToolButtonClass ) }, + { "GtkToolButtonClass", sizeof( GtkToolButtonClass ) }, + { "GtkToolButton", sizeof( GtkToolButton ) }, + { "GtkToolItemClass", sizeof( GtkToolItemClass ) }, + { "GtkToolItem", sizeof( GtkToolItem ) }, + { "GtkTooltipsData", sizeof( GtkTooltipsData ) }, + { "GtkTooltipsClass", sizeof( GtkTooltipsClass ) }, + { "GtkTooltips", sizeof( GtkTooltips ) }, + { "GtkMenuBarClass", sizeof( GtkMenuBarClass ) }, + { "GtkMenuBar", sizeof( GtkMenuBar ) }, + { "GtkListClass", sizeof( GtkListClass ) }, + { "GtkList", sizeof( GtkList ) }, + { "GtkListItemClass", sizeof( GtkListItemClass ) }, + { "GtkListItem", sizeof( GtkListItem ) }, + { "GtkLinkButtonClass", sizeof( GtkLinkButtonClass ) }, + { "GtkLinkButton", sizeof( GtkLinkButton ) }, + { "GtkLayoutClass", sizeof( GtkLayoutClass ) }, + { "GtkLayout", sizeof( GtkLayout ) }, + { "GtkInvisibleClass", sizeof( GtkInvisibleClass ) }, + { "GtkInvisible", sizeof( GtkInvisible ) }, + { "GtkInputDialogClass", sizeof( GtkInputDialogClass ) }, + { "GtkInputDialog", sizeof( GtkInputDialog ) }, + { "GtkIMMulticontextClass", sizeof( GtkIMMulticontextClass ) }, + { "GtkIMMulticontext", sizeof( GtkIMMulticontext ) }, + { "GtkIMContextSimpleClass", sizeof( GtkIMContextSimpleClass ) }, + { "GtkIMContextSimple", sizeof( GtkIMContextSimple ) }, + { "GtkImageMenuItemClass", sizeof( GtkImageMenuItemClass ) }, + { "GtkImageMenuItem", sizeof( GtkImageMenuItem ) }, + { "GtkIconViewClass", sizeof( GtkIconViewClass ) }, + { "GtkIconView", sizeof( GtkIconView ) }, + { "GtkIconThemeClass", sizeof( GtkIconThemeClass ) }, + { "GtkIconTheme", sizeof( GtkIconTheme ) }, + { "GtkIconFactoryClass", sizeof( GtkIconFactoryClass ) }, + { "GtkHSeparatorClass", sizeof( GtkHSeparatorClass ) }, + { "GtkHSeparator", sizeof( GtkHSeparator ) }, + { "GtkSeparatorClass", sizeof( GtkSeparatorClass ) }, + { "GtkSeparator", sizeof( GtkSeparator ) }, + { "GtkHScaleClass", sizeof( GtkHScaleClass ) }, + { "GtkHScale", sizeof( GtkHScale ) }, + { "GtkScaleClass", sizeof( GtkScaleClass ) }, + { "GtkScale", sizeof( GtkScale ) }, + { "GtkHRulerClass", sizeof( GtkHRulerClass ) }, + { "GtkHRuler", sizeof( GtkHRuler ) }, + { "GtkRulerMetric", sizeof( GtkRulerMetric ) }, + { "GtkRulerClass", sizeof( GtkRulerClass ) }, + { "GtkRuler", sizeof( GtkRuler ) }, + { "GtkHPanedClass", sizeof( GtkHPanedClass ) }, + { "GtkHPaned", sizeof( GtkHPaned ) }, + { "GtkPanedClass", sizeof( GtkPanedClass ) }, + { "GtkPaned", sizeof( GtkPaned ) }, + { "GtkHButtonBoxClass", sizeof( GtkHButtonBoxClass ) }, + { "GtkHButtonBox", sizeof( GtkHButtonBox ) }, + { "GtkHandleBoxClass", sizeof( GtkHandleBoxClass ) }, + { "GtkHandleBox", sizeof( GtkHandleBox ) }, + { "GtkGammaCurveClass", sizeof( GtkGammaCurveClass ) }, + { "GtkGammaCurve", sizeof( GtkGammaCurve ) }, + { "GtkFontSelectionDialogClass", sizeof( GtkFontSelectionDialogClass ) }, + { "GtkFontSelectionDialog", sizeof( GtkFontSelectionDialog ) }, + { "GtkFontSelectionClass", sizeof( GtkFontSelectionClass ) }, + { "GtkFontSelection", sizeof( GtkFontSelection ) }, + { "GtkFontButtonClass", sizeof( GtkFontButtonClass ) }, + { "GtkFontButton", sizeof( GtkFontButton ) }, + { "GtkFileChooserWidgetClass", sizeof( GtkFileChooserWidgetClass ) }, + { "GtkFileChooserWidget", sizeof( GtkFileChooserWidget ) }, + { "GtkFileChooserDialogClass", sizeof( GtkFileChooserDialogClass ) }, + { "GtkFileChooserDialog", sizeof( GtkFileChooserDialog ) }, + { "GtkFileChooserButtonClass", sizeof( GtkFileChooserButtonClass ) }, + { "GtkFileChooserButton", sizeof( GtkFileChooserButton ) }, + { "GtkFileFilterInfo", sizeof( GtkFileFilterInfo ) }, + { "GtkFixedChild", sizeof( GtkFixedChild ) }, + { "GtkFixedClass", sizeof( GtkFixedClass ) }, + { "GtkFixed", sizeof( GtkFixed ) }, + { "GtkFileSelectionClass", sizeof( GtkFileSelectionClass ) }, + { "GtkFileSelection", sizeof( GtkFileSelection ) }, + { "GtkExpanderClass", sizeof( GtkExpanderClass ) }, + { "GtkExpander", sizeof( GtkExpander ) }, + { "GtkEventBoxClass", sizeof( GtkEventBoxClass ) }, + { "GtkEventBox", sizeof( GtkEventBox ) }, + { "GtkCurveClass", sizeof( GtkCurveClass ) }, + { "GtkCurve", sizeof( GtkCurve ) }, + { "GtkDrawingAreaClass", sizeof( GtkDrawingAreaClass ) }, + { "GtkDrawingArea", sizeof( GtkDrawingArea ) }, + { "GtkCTreeNode", sizeof( GtkCTreeNode ) }, + { "GtkCTreeRow", sizeof( GtkCTreeRow ) }, + { "GtkCTreeClass", sizeof( GtkCTreeClass ) }, + { "GtkCTree", sizeof( GtkCTree ) }, + { "GtkComboBoxEntryClass", sizeof( GtkComboBoxEntryClass ) }, + { "GtkComboBoxEntry", sizeof( GtkComboBoxEntry ) }, + { "GtkComboBoxClass", sizeof( GtkComboBoxClass ) }, + { "GtkComboBox", sizeof( GtkComboBox ) }, + { "GtkTreeSelectionClass", sizeof( GtkTreeSelectionClass ) }, + { "GtkTreeSelection", sizeof( GtkTreeSelection ) }, + { "GtkTreeViewClass", sizeof( GtkTreeViewClass ) }, + { "GtkTreeView", sizeof( GtkTreeView ) }, + { "GtkEntryClass", sizeof( GtkEntryClass ) }, + { "GtkEntry", sizeof( GtkEntry ) }, + { "GtkEntryCompletionClass", sizeof( GtkEntryCompletionClass ) }, + { "GtkEntryCompletion", sizeof( GtkEntryCompletion ) }, + { "GtkTreeModelFilterClass", sizeof( GtkTreeModelFilterClass ) }, + { "GtkTreeModelFilter", sizeof( GtkTreeModelFilter ) }, + { "GtkListStoreClass", sizeof( GtkListStoreClass ) }, + { "GtkListStore", sizeof( GtkListStore ) }, + { "GtkIMContextClass", sizeof( GtkIMContextClass ) }, + { "GtkIMContext", sizeof( GtkIMContext ) }, + { "GtkEditableClass", sizeof( GtkEditableClass ) }, + { "GtkComboClass", sizeof( GtkComboClass ) }, + { "GtkCombo", sizeof( GtkCombo ) }, + { "GtkHBoxClass", sizeof( GtkHBoxClass ) }, + { "GtkHBox", sizeof( GtkHBox ) }, + { "GtkColorSelectionDialogClass", sizeof( GtkColorSelectionDialogClass ) }, + { "GtkColorSelectionDialog", sizeof( GtkColorSelectionDialog ) }, + { "GtkColorSelectionClass", sizeof( GtkColorSelectionClass ) }, + { "GtkColorSelection", sizeof( GtkColorSelection ) }, + { "GtkVBoxClass", sizeof( GtkVBoxClass ) }, + { "GtkVBox", sizeof( GtkVBox ) }, + { "GtkColorButtonClass", sizeof( GtkColorButtonClass ) }, + { "GtkColorButton", sizeof( GtkColorButton ) }, + { "GtkCListDestInfo", sizeof( GtkCListDestInfo ) }, + { "GtkCListCellInfo", sizeof( GtkCListCellInfo ) }, + { "GtkCellWidget", sizeof( GtkCellWidget ) }, + { "GtkCellPixText", sizeof( GtkCellPixText ) }, + { "GtkCellPixmap", sizeof( GtkCellPixmap ) }, + { "GtkCellText", sizeof( GtkCellText ) }, + { "GtkCell", sizeof( GtkCell ) }, + { "GtkCListRow", sizeof( GtkCListRow ) }, + { "GtkCListColumn", sizeof( GtkCListColumn ) }, + { "GtkCListClass", sizeof( GtkCListClass ) }, + { "GtkCList", sizeof( GtkCList ) }, + { "GtkVScrollbarClass", sizeof( GtkVScrollbarClass ) }, + { "GtkVScrollbar", sizeof( GtkVScrollbar ) }, + { "GtkHScrollbarClass", sizeof( GtkHScrollbarClass ) }, + { "GtkHScrollbar", sizeof( GtkHScrollbar ) }, + { "GtkScrollbarClass", sizeof( GtkScrollbarClass ) }, + { "GtkScrollbar", sizeof( GtkScrollbar ) }, + { "GtkRangeClass", sizeof( GtkRangeClass ) }, + { "GtkRange", sizeof( GtkRange ) }, + { "GtkTargetPair", sizeof( GtkTargetPair ) }, + { "GtkTargetEntry", sizeof( GtkTargetEntry ) }, + { "GtkTargetList", sizeof( GtkTargetList ) }, + { "GtkTextBuffer", sizeof( GtkTextBuffer ) }, + { "GtkTextChildAnchorClass", sizeof( GtkTextChildAnchorClass ) }, + { "GtkTextChildAnchor", sizeof( GtkTextChildAnchor ) }, + { "GtkTextAppearance", sizeof( GtkTextAppearance ) }, + { "GtkTextTagClass", sizeof( GtkTextTagClass ) }, + { "GtkTextTag", sizeof( GtkTextTag ) }, + { "GtkTextAttributes", sizeof( GtkTextAttributes ) }, + { "GtkTextTagTable", sizeof( GtkTextTagTable ) }, + { "GtkTextIter", sizeof( GtkTextIter ) }, + { "GtkCheckMenuItemClass", sizeof( GtkCheckMenuItemClass ) }, + { "GtkCheckMenuItem", sizeof( GtkCheckMenuItem ) }, + { "GtkMenuItemClass", sizeof( GtkMenuItemClass ) }, + { "GtkMenuItem", sizeof( GtkMenuItem ) }, + { "GtkItemClass", sizeof( GtkItemClass ) }, + { "GtkItem", sizeof( GtkItem ) }, + { "GtkCheckButtonClass", sizeof( GtkCheckButtonClass ) }, + { "GtkCheckButton", sizeof( GtkCheckButton ) }, + { "GtkToggleButtonClass", sizeof( GtkToggleButtonClass ) }, + { "GtkToggleButton", sizeof( GtkToggleButton ) }, + { "GtkCellViewClass", sizeof( GtkCellViewClass ) }, + { "GtkCellView", sizeof( GtkCellView ) }, + { "GtkCellRendererToggleClass", sizeof( GtkCellRendererToggleClass ) }, + { "GtkCellRendererToggle", sizeof( GtkCellRendererToggle ) }, + { "GtkCellRendererSpinClass", sizeof( GtkCellRendererSpinClass ) }, + { "GtkCellRendererSpin", sizeof( GtkCellRendererSpin ) }, + { "GtkCellRendererProgressClass", sizeof( GtkCellRendererProgressClass ) }, + { "GtkCellRendererProgress", sizeof( GtkCellRendererProgress ) }, + { "GtkCellRendererPixbufClass", sizeof( GtkCellRendererPixbufClass ) }, + { "GtkCellRendererPixbuf", sizeof( GtkCellRendererPixbuf ) }, + { "GtkCellRendererComboClass", sizeof( GtkCellRendererComboClass ) }, + { "GtkCellRendererCombo", sizeof( GtkCellRendererCombo ) }, + { "GtkCellRendererAccelClass", sizeof( GtkCellRendererAccelClass ) }, + { "GtkCellRendererAccel", sizeof( GtkCellRendererAccel ) }, + { "GtkCellRendererTextClass", sizeof( GtkCellRendererTextClass ) }, + { "GtkCellRendererText", sizeof( GtkCellRendererText ) }, + { "GtkCellLayoutIface", sizeof( GtkCellLayoutIface ) }, + { "GtkTreeViewColumnClass", sizeof( GtkTreeViewColumnClass ) }, + { "GtkTreeViewColumn", sizeof( GtkTreeViewColumn ) }, + { "GtkTreeSortableIface", sizeof( GtkTreeSortableIface ) }, + { "GtkTreeModelIface", sizeof( GtkTreeModelIface ) }, + { "GtkTreeIter", sizeof( GtkTreeIter ) }, + { "GtkCellRendererClass", sizeof( GtkCellRendererClass ) }, + { "GtkCellRenderer", sizeof( GtkCellRenderer ) }, + { "GtkCellEditableIface", sizeof( GtkCellEditableIface ) }, + { "GtkCalendarClass", sizeof( GtkCalendarClass ) }, + { "GtkCalendar", sizeof( GtkCalendar ) }, + { "GtkButtonClass", sizeof( GtkButtonClass ) }, + { "GtkButton", sizeof( GtkButton ) }, + { "GtkImageIconNameData", sizeof( GtkImageIconNameData ) }, + { "GtkImageAnimationData", sizeof( GtkImageAnimationData ) }, + { "GtkImageIconSetData", sizeof( GtkImageIconSetData ) }, + { "GtkImageStockData", sizeof( GtkImageStockData ) }, + { "GtkImagePixbufData", sizeof( GtkImagePixbufData ) }, + { "GtkImageImageData", sizeof( GtkImageImageData ) }, + { "GtkImagePixmapData", sizeof( GtkImagePixmapData ) }, + { "GtkImageClass", sizeof( GtkImageClass ) }, + { "GtkImage", sizeof( GtkImage ) }, + { "GtkBuildableIface", sizeof( GtkBuildableIface ) }, + { "GtkBuilderClass", sizeof( GtkBuilderClass ) }, + { "GtkBuilder", sizeof( GtkBuilder ) }, + { "GtkBindingArg", sizeof( GtkBindingArg ) }, + { "GtkBindingSignal", sizeof( GtkBindingSignal ) }, + { "GtkBindingEntry", sizeof( GtkBindingEntry ) }, + { "GtkBindingSet", sizeof( GtkBindingSet ) }, + { "GtkButtonBoxClass", sizeof( GtkButtonBoxClass ) }, + { "GtkButtonBox", sizeof( GtkButtonBox ) }, + { "GtkBoxChild", sizeof( GtkBoxChild ) }, + { "GtkBoxClass", sizeof( GtkBoxClass ) }, + { "GtkBox", sizeof( GtkBox ) }, + { "GtkAssistantClass", sizeof( GtkAssistantClass ) }, + { "GtkAssistant", sizeof( GtkAssistant ) }, + { "GtkAspectFrameClass", sizeof( GtkAspectFrameClass ) }, + { "GtkAspectFrame", sizeof( GtkAspectFrame ) }, + { "GtkFrameClass", sizeof( GtkFrameClass ) }, + { "GtkFrame", sizeof( GtkFrame ) }, + { "GtkArrowClass", sizeof( GtkArrowClass ) }, + { "GtkArrow", sizeof( GtkArrow ) }, + { "GtkAlignmentClass", sizeof( GtkAlignmentClass ) }, + { "GtkAlignment", sizeof( GtkAlignment ) }, + { "GtkRadioActionEntry", sizeof( GtkRadioActionEntry ) }, + { "GtkToggleActionEntry", sizeof( GtkToggleActionEntry ) }, + { "GtkActionEntry", sizeof( GtkActionEntry ) }, + { "GtkActionGroupClass", sizeof( GtkActionGroupClass ) }, + { "GtkActionGroup", sizeof( GtkActionGroup ) }, + { "GtkMenuEntry", sizeof( GtkMenuEntry ) }, + { "GtkItemFactoryItem", sizeof( GtkItemFactoryItem ) }, + { "GtkItemFactoryEntry", sizeof( GtkItemFactoryEntry ) }, + { "GtkItemFactoryClass", sizeof( GtkItemFactoryClass ) }, + { "GtkItemFactory", sizeof( GtkItemFactory ) }, + { "GtkActionClass", sizeof( GtkActionClass ) }, + { "GtkAction", sizeof( GtkAction ) }, + { "GtkAccessibleClass", sizeof( GtkAccessibleClass ) }, + { "GtkAccessible", sizeof( GtkAccessible ) }, + { "GtkAccelLabelClass", sizeof( GtkAccelLabelClass ) }, + { "GtkAccelLabel", sizeof( GtkAccelLabel ) }, + { "GtkLabelClass", sizeof( GtkLabelClass ) }, + { "GtkLabel", sizeof( GtkLabel ) }, + { "GtkMenuClass", sizeof( GtkMenuClass ) }, + { "GtkMenu", sizeof( GtkMenu ) }, + { "GtkMenuShellClass", sizeof( GtkMenuShellClass ) }, + { "GtkMenuShell", sizeof( GtkMenuShell ) }, + { "GtkMiscClass", sizeof( GtkMiscClass ) }, + { "GtkMisc", sizeof( GtkMisc ) }, + { "GtkAboutDialogClass", sizeof( GtkAboutDialogClass ) }, + { "GtkAboutDialog", sizeof( GtkAboutDialog ) }, + { "GtkDialogClass", sizeof( GtkDialogClass ) }, + { "GtkDialog", sizeof( GtkDialog ) }, + { "GtkWindowGroupClass", sizeof( GtkWindowGroupClass ) }, + { "GtkWindowGroup", sizeof( GtkWindowGroup ) }, + { "GtkWindowClass", sizeof( GtkWindowClass ) }, + { "GtkBinClass", sizeof( GtkBinClass ) }, + { "GtkBin", sizeof( GtkBin ) }, + { "GtkContainerClass", sizeof( GtkContainerClass ) }, + { "GtkContainer", sizeof( GtkContainer ) }, + { "GtkWindow", sizeof( GtkWindow ) }, + { "GtkWidgetShapeInfo", sizeof( GtkWidgetShapeInfo ) }, + { "GtkWidgetAuxInfo", sizeof( GtkWidgetAuxInfo ) }, + { "GtkWidgetClass", sizeof( GtkWidgetClass ) }, + { "GtkSelectionData", sizeof( GtkSelectionData ) }, + { "GtkRequisition", sizeof( GtkRequisition ) }, + { "GtkSettingsValue", sizeof( GtkSettingsValue ) }, + { "GtkSettingsClass", sizeof( GtkSettingsClass ) }, + { "GtkRcStyleClass", sizeof( GtkRcStyleClass ) }, + { "GtkIconFactory", sizeof( GtkIconFactory ) }, + { "GtkWidget", sizeof( GtkWidget ) }, + { "GtkSettings", sizeof( GtkSettings ) }, + { "GtkRcProperty", sizeof( GtkRcProperty ) }, + { "GtkRcStyle", sizeof( GtkRcStyle ) }, + { "GtkStyleClass", sizeof( GtkStyleClass ) }, + { "GtkStyle", sizeof( GtkStyle ) }, + { "GtkBorder", sizeof( GtkBorder ) }, + { "GtkAdjustmentClass", sizeof( GtkAdjustmentClass ) }, + { "GtkAdjustment", sizeof( GtkAdjustment ) }, + { "GtkObjectClass", sizeof( GtkObjectClass ) }, + { "GtkTypeInfo", sizeof( GtkTypeInfo ) }, + { "GtkObject", sizeof( GtkObject ) }, + { "GtkArg", sizeof( GtkArg ) }, + { "GtkAccelGroupEntry", sizeof( GtkAccelGroupEntry ) }, + { "GtkAccelKey", sizeof( GtkAccelKey ) }, + { "GtkAccelGroupClass", sizeof( GtkAccelGroupClass ) }, + { "GtkAccelGroup", sizeof( GtkAccelGroup ) }, + { "GtkPrintUnixDialogClass", sizeof( GtkPrintUnixDialogClass ) }, + { "GtkPrintUnixDialog", sizeof( GtkPrintUnixDialog ) }, + { "GtkPrintJobClass", sizeof( GtkPrintJobClass ) }, + { "GtkPrintJob", sizeof( GtkPrintJob ) }, + { "GtkPrinterClass", sizeof( GtkPrinterClass ) }, + { "GtkPrinter", sizeof( GtkPrinter ) }, + { "GtkPageSetupUnixDialogClass", sizeof( GtkPageSetupUnixDialogClass ) }, + { "GtkPageSetupUnixDialog", sizeof( GtkPageSetupUnixDialog ) }, + { "PangoRendererClass", sizeof( PangoRendererClass ) }, + { "PangoRenderer", sizeof( PangoRenderer ) }, + { "PangoLayoutLine", sizeof( PangoLayoutLine ) }, + { "PangoGlyphItem", sizeof( PangoGlyphItem ) }, + { "PangoGlyphString", sizeof( PangoGlyphString ) }, + { "PangoGlyphInfo", sizeof( PangoGlyphInfo ) }, + { "PangoGlyphVisAttr", sizeof( PangoGlyphVisAttr ) }, + { "PangoGlyphGeometry", sizeof( PangoGlyphGeometry ) }, + { "PangoItem", sizeof( PangoItem ) }, + { "PangoAnalysis", sizeof( PangoAnalysis ) }, + { "PangoAttrShape", sizeof( PangoAttrShape ) }, + { "PangoAttrFontDesc", sizeof( PangoAttrFontDesc ) }, + { "PangoAttrColor", sizeof( PangoAttrColor ) }, + { "PangoAttrFloat", sizeof( PangoAttrFloat ) }, + { "PangoAttrSize", sizeof( PangoAttrSize ) }, + { "PangoAttrInt", sizeof( PangoAttrInt ) }, + { "PangoAttrLanguage", sizeof( PangoAttrLanguage ) }, + { "PangoAttrString", sizeof( PangoAttrString ) }, + { "PangoAttrClass", sizeof( PangoAttrClass ) }, + { "PangoAttribute", sizeof( PangoAttribute ) }, + { "PangoColor", sizeof( PangoColor ) }, + { "PangoMatrix", sizeof( PangoMatrix ) }, + { "PangoRectangle", sizeof( PangoRectangle ) }, + { "PangoLogAttr", sizeof( PangoLogAttr ) }, + { "XExtensionVersion", sizeof( XExtensionVersion ) }, + { "XButtonState", sizeof( XButtonState ) }, + { "XKeyState", sizeof( XKeyState ) }, + { "XValuatorState", sizeof( XValuatorState ) }, + { "XDeviceState", sizeof( XDeviceState ) }, + { "XDeviceTimeCoord", sizeof( XDeviceTimeCoord ) }, + { "XEventList", sizeof( XEventList ) }, + { "XDevice", sizeof( XDevice ) }, + { "XInputClassInfo", sizeof( XInputClassInfo ) }, + { "XValuatorInfo", sizeof( XValuatorInfo ) }, + { "XAxisInfo", sizeof( XAxisInfo ) }, + { "XButtonInfo", sizeof( XButtonInfo ) }, + { "XKeyInfo", sizeof( XKeyInfo ) }, + { "XDeviceInfo", sizeof( XDeviceInfo ) }, + { "XDeviceEnableControl", sizeof( XDeviceEnableControl ) }, + { "XDeviceCoreState", sizeof( XDeviceCoreState ) }, + { "XDeviceCoreControl", sizeof( XDeviceCoreControl ) }, + { "XDeviceAbsAreaControl", sizeof( XDeviceAbsAreaControl ) }, + { "XDeviceAbsCalibControl", sizeof( XDeviceAbsCalibControl ) }, + { "XDeviceResolutionState", sizeof( XDeviceResolutionState ) }, + { "XDeviceResolutionControl", sizeof( XDeviceResolutionControl ) }, + { "XDeviceControl", sizeof( XDeviceControl ) }, + { "XLedFeedbackControl", sizeof( XLedFeedbackControl ) }, + { "XBellFeedbackControl", sizeof( XBellFeedbackControl ) }, + { "XIntegerFeedbackControl", sizeof( XIntegerFeedbackControl ) }, + { "XStringFeedbackControl", sizeof( XStringFeedbackControl ) }, + { "XKbdFeedbackControl", sizeof( XKbdFeedbackControl ) }, + { "XPtrFeedbackControl", sizeof( XPtrFeedbackControl ) }, + { "XFeedbackControl", sizeof( XFeedbackControl ) }, + { "XLedFeedbackState", sizeof( XLedFeedbackState ) }, + { "XBellFeedbackState", sizeof( XBellFeedbackState ) }, + { "XStringFeedbackState", sizeof( XStringFeedbackState ) }, + { "XIntegerFeedbackState", sizeof( XIntegerFeedbackState ) }, + { "XPtrFeedbackState", sizeof( XPtrFeedbackState ) }, + { "XKbdFeedbackState", sizeof( XKbdFeedbackState ) }, + { "XFeedbackState", sizeof( XFeedbackState ) }, + { "XDevicePresenceNotifyEvent", sizeof( XDevicePresenceNotifyEvent ) }, + { "XChangeDeviceNotifyEvent", sizeof( XChangeDeviceNotifyEvent ) }, + { "XDeviceMappingEvent", sizeof( XDeviceMappingEvent ) }, + { "XButtonStatus", sizeof( XButtonStatus ) }, + { "XKeyStatus", sizeof( XKeyStatus ) }, + { "XValuatorStatus", sizeof( XValuatorStatus ) }, + { "XDeviceStateNotifyEvent", sizeof( XDeviceStateNotifyEvent ) }, + { "XInputClass", sizeof( XInputClass ) }, + { "XProximityNotifyEvent", sizeof( XProximityNotifyEvent ) }, + { "XDeviceFocusChangeEvent", sizeof( XDeviceFocusChangeEvent ) }, + { "XDeviceMotionEvent", sizeof( XDeviceMotionEvent ) }, + { "XDeviceButtonEvent", sizeof( XDeviceButtonEvent ) }, + { "XDeviceKeyEvent", sizeof( XDeviceKeyEvent ) }, + { "XIMValuesList", sizeof( XIMValuesList ) }, + { "XIMHotKeyTriggers", sizeof( XIMHotKeyTriggers ) }, + { "XIMHotKeyTrigger", sizeof( XIMHotKeyTrigger ) }, + { "XIMStatusDrawCallbackStruct", sizeof( XIMStatusDrawCallbackStruct ) }, + { "XIMPreeditCaretCallbackStruct", sizeof( XIMPreeditCaretCallbackStruct ) }, + { "XIMPreeditDrawCallbackStruct", sizeof( XIMPreeditDrawCallbackStruct ) }, + { "XIMStringConversionCallbackStruct", sizeof( XIMStringConversionCallbackStruct ) }, + { "XIMStringConversionText", sizeof( XIMStringConversionText ) }, + { "XIMPreeditStateNotifyCallbackStruct", sizeof( XIMPreeditStateNotifyCallbackStruct ) }, + { "XIMText", sizeof( XIMText ) }, + { "XICCallback", sizeof( XICCallback ) }, + { "XIMCallback", sizeof( XIMCallback ) }, + { "XIMStyles", sizeof( XIMStyles ) }, + { "XOMFontInfo", sizeof( XOMFontInfo ) }, + { "XOMOrientation", sizeof( XOMOrientation ) }, + { "XOMCharSetList", sizeof( XOMCharSetList ) }, + { "XwcTextItem", sizeof( XwcTextItem ) }, + { "XmbTextItem", sizeof( XmbTextItem ) }, + { "XFontSetExtents", sizeof( XFontSetExtents ) }, + { "XEDataObject", sizeof( XEDataObject ) }, + { "XTextItem16", sizeof( XTextItem16 ) }, + { "XChar2b", sizeof( XChar2b ) }, + { "XTextItem", sizeof( XTextItem ) }, + { "XFontStruct", sizeof( XFontStruct ) }, + { "XFontProp", sizeof( XFontProp ) }, + { "XCharStruct", sizeof( XCharStruct ) }, + { "XEvent", sizeof( XEvent ) }, + { "XAnyEvent", sizeof( XAnyEvent ) }, + { "XErrorEvent", sizeof( XErrorEvent ) }, + { "XMappingEvent", sizeof( XMappingEvent ) }, + { "XClientMessageEvent", sizeof( XClientMessageEvent ) }, + { "XColormapEvent", sizeof( XColormapEvent ) }, + { "XSelectionEvent", sizeof( XSelectionEvent ) }, + { "XSelectionRequestEvent", sizeof( XSelectionRequestEvent ) }, + { "XSelectionClearEvent", sizeof( XSelectionClearEvent ) }, + { "XPropertyEvent", sizeof( XPropertyEvent ) }, + { "XCirculateRequestEvent", sizeof( XCirculateRequestEvent ) }, + { "XCirculateEvent", sizeof( XCirculateEvent ) }, + { "XConfigureRequestEvent", sizeof( XConfigureRequestEvent ) }, + { "XResizeRequestEvent", sizeof( XResizeRequestEvent ) }, + { "XGravityEvent", sizeof( XGravityEvent ) }, + { "XConfigureEvent", sizeof( XConfigureEvent ) }, + { "XReparentEvent", sizeof( XReparentEvent ) }, + { "XMapRequestEvent", sizeof( XMapRequestEvent ) }, + { "XMapEvent", sizeof( XMapEvent ) }, + { "XUnmapEvent", sizeof( XUnmapEvent ) }, + { "XDestroyWindowEvent", sizeof( XDestroyWindowEvent ) }, + { "XCreateWindowEvent", sizeof( XCreateWindowEvent ) }, + { "XVisibilityEvent", sizeof( XVisibilityEvent ) }, + { "XNoExposeEvent", sizeof( XNoExposeEvent ) }, + { "XGraphicsExposeEvent", sizeof( XGraphicsExposeEvent ) }, + { "XExposeEvent", sizeof( XExposeEvent ) }, + { "XKeymapEvent", sizeof( XKeymapEvent ) }, + { "XFocusChangeEvent", sizeof( XFocusChangeEvent ) }, + { "XCrossingEvent", sizeof( XCrossingEvent ) }, + { "XMotionEvent", sizeof( XMotionEvent ) }, + { "XButtonEvent", sizeof( XButtonEvent ) }, + { "XKeyEvent", sizeof( XKeyEvent ) }, + { "XModifierKeymap", sizeof( XModifierKeymap ) }, + { "XTimeCoord", sizeof( XTimeCoord ) }, + { "XKeyboardState", sizeof( XKeyboardState ) }, + { "XKeyboardControl", sizeof( XKeyboardControl ) }, + { "XArc", sizeof( XArc ) }, + { "XRectangle", sizeof( XRectangle ) }, + { "XPoint", sizeof( XPoint ) }, + { "XSegment", sizeof( XSegment ) }, + { "XColor", sizeof( XColor ) }, + { "XWindowChanges", sizeof( XWindowChanges ) }, + { "XImage", sizeof( XImage ) }, + { "XServerInterpretedAddress", sizeof( XServerInterpretedAddress ) }, + { "XHostAddress", sizeof( XHostAddress ) }, + { "XWindowAttributes", sizeof( XWindowAttributes ) }, + { "XSetWindowAttributes", sizeof( XSetWindowAttributes ) }, + { "ScreenFormat", sizeof( ScreenFormat ) }, + { "Screen", sizeof( Screen ) }, + { "Depth", sizeof( Depth ) }, + { "Visual", sizeof( Visual ) }, + { "XGCValues", sizeof( XGCValues ) }, + { "XPixmapFormatValues", sizeof( XPixmapFormatValues ) }, + { "XExtCodes", sizeof( XExtCodes ) }, + { "XExtData", sizeof( XExtData ) }, + { "XConicalGradient", sizeof( XConicalGradient ) }, + { "XRadialGradient", sizeof( XRadialGradient ) }, + { "XLinearGradient", sizeof( XLinearGradient ) }, + { "XTrap", sizeof( XTrap ) }, + { "XSpanFix", sizeof( XSpanFix ) }, + { "XAnimCursor", sizeof( XAnimCursor ) }, + { "XIndexValue", sizeof( XIndexValue ) }, + { "XFilters", sizeof( XFilters ) }, + { "XTransform", sizeof( XTransform ) }, + { "XTrapezoid", sizeof( XTrapezoid ) }, + { "XCircle", sizeof( XCircle ) }, + { "XTriangle", sizeof( XTriangle ) }, + { "XLineFixed", sizeof( XLineFixed ) }, + { "XPointFixed", sizeof( XPointFixed ) }, + { "XPointDouble", sizeof( XPointDouble ) }, + { "XGlyphElt32", sizeof( XGlyphElt32 ) }, + { "XGlyphElt16", sizeof( XGlyphElt16 ) }, + { "XGlyphElt8", sizeof( XGlyphElt8 ) }, + { "XGlyphInfo", sizeof( XGlyphInfo ) }, + { "XRenderColor", sizeof( XRenderColor ) }, + { "XRenderPictureAttributes", sizeof( XRenderPictureAttributes ) }, + { "XRenderPictFormat", sizeof( XRenderPictFormat ) }, + { "XRenderDirectFormat", sizeof( XRenderDirectFormat ) }, + { "XStandardColormap", sizeof( XStandardColormap ) }, + { "XVisualInfo", sizeof( XVisualInfo ) }, + { "XComposeStatus", sizeof( XComposeStatus ) }, + { "XClassHint", sizeof( XClassHint ) }, + { "XIconSize", sizeof( XIconSize ) }, + { "XTextProperty", sizeof( XTextProperty ) }, + { "XWMHints", sizeof( XWMHints ) }, + { "XSizeHints", sizeof( XSizeHints ) }, +}; + +int main( int n, char** args ){ + int i = 0; + for( i = 0; i < sizeof( size_values )/sizeof( size_values[0] ); i++ ){ + printf( "%s\t%d\n", size_values[i].name, size_values[i].size ); + } + return 0; +} + + + diff -r 00f135d0337d -r c39d1446f191 devhelpers/structslinux/structs.d --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/devhelpers/structslinux/structs.d Mon Jul 21 22:54:04 2008 +0200 @@ -0,0 +1,829 @@ +// Author: Frank Benoit +// This prints the sizes of some C struct how they are defined in the c-bindings + +import dwt.internal.c.gtk; +import dwt.internal.c.gdk; +import dwt.internal.c.glib_object; +import dwt.internal.c.gmodule; +import dwt.internal.c.pango; +import dwt.internal.c.cairo; +import dwt.internal.c.gl; +import dwt.internal.c.glx; +import dwt.internal.c.gtk_unix_print_2_0; +import dwt.internal.c.Xlib; +import dwt.internal.c.XTest; +import dwt.internal.c.Xrender; + +extern(C) int printf( char*, ... ); + +struct TSizeValue { + char[] name; + int size; +} ; + +const TSizeValue[] size_values = [ + { "AtkValueIface", AtkValueIface.sizeof }, + { "AtkMiscClass", AtkMiscClass.sizeof }, + { "AtkMisc", AtkMisc.sizeof }, + { "AtkTableIface", AtkTableIface.sizeof }, + { "AtkStreamableContentIface", AtkStreamableContentIface.sizeof }, + { "AtkStateSetClass", AtkStateSetClass.sizeof }, + { "AtkSelectionIface", AtkSelectionIface.sizeof }, + { "AtkRelationSetClass", AtkRelationSetClass.sizeof }, + { "AtkRelationClass", AtkRelationClass.sizeof }, + { "AtkRelation", AtkRelation.sizeof }, + { "AtkRegistryClass", AtkRegistryClass.sizeof }, + { "AtkRegistry", AtkRegistry.sizeof }, + { "AtkNoOpObjectFactoryClass", AtkNoOpObjectFactoryClass.sizeof }, + { "AtkNoOpObjectFactory", AtkNoOpObjectFactory.sizeof }, + { "AtkObjectFactoryClass", AtkObjectFactoryClass.sizeof }, + { "AtkObjectFactory", AtkObjectFactory.sizeof }, + { "AtkNoOpObjectClass", AtkNoOpObjectClass.sizeof }, + { "AtkNoOpObject", AtkNoOpObject.sizeof }, + { "AtkImageIface", AtkImageIface.sizeof }, + { "AtkHypertextIface", AtkHypertextIface.sizeof }, + { "AtkHyperlinkImplIface", AtkHyperlinkImplIface.sizeof }, + { "AtkHyperlinkClass", AtkHyperlinkClass.sizeof }, + { "AtkHyperlink", AtkHyperlink.sizeof }, + { "AtkGObjectAccessibleClass", AtkGObjectAccessibleClass.sizeof }, + { "AtkGObjectAccessible", AtkGObjectAccessible.sizeof }, + { "AtkEditableTextIface", AtkEditableTextIface.sizeof }, + { "AtkTextRange", AtkTextRange.sizeof }, + { "AtkTextRectangle", AtkTextRectangle.sizeof }, + { "AtkTextIface", AtkTextIface.sizeof }, + { "AtkDocumentIface", AtkDocumentIface.sizeof }, + { "AtkRectangle", AtkRectangle.sizeof }, + { "AtkComponentIface", AtkComponentIface.sizeof }, + { "AtkKeyEventStruct", AtkKeyEventStruct.sizeof }, + { "AtkUtilClass", AtkUtilClass.sizeof }, + { "AtkUtil", AtkUtil.sizeof }, + { "AtkActionIface", AtkActionIface.sizeof }, + { "AtkPropertyValues", AtkPropertyValues.sizeof }, + { "AtkStateSet", AtkStateSet.sizeof }, + { "AtkRelationSet", AtkRelationSet.sizeof }, + { "AtkObjectClass", AtkObjectClass.sizeof }, + { "AtkObject", AtkObject.sizeof }, + { "AtkImplementorIface", AtkImplementorIface.sizeof }, + { "AtkAttribute", AtkAttribute.sizeof }, + { "cairo_path_t", cairo_path_t.sizeof }, + { "cairo_path_data_t", cairo_path_data_t.sizeof }, + { "cairo_font_extents_t", cairo_font_extents_t.sizeof }, + { "cairo_text_extents_t", cairo_text_extents_t.sizeof }, + { "cairo_glyph_t", cairo_glyph_t.sizeof }, + { "cairo_rectangle_list_t", cairo_rectangle_list_t.sizeof }, + { "cairo_rectangle_t", cairo_rectangle_t.sizeof }, + { "cairo_user_data_key_t", cairo_user_data_key_t.sizeof }, + { "cairo_matrix_t", cairo_matrix_t.sizeof }, + { "GdkWindowObjectClass", GdkWindowObjectClass.sizeof }, + { "GdkWindowObject", GdkWindowObject.sizeof }, + { "GdkPointerHooks", GdkPointerHooks.sizeof }, + { "GdkWindowAttr", GdkWindowAttr.sizeof }, + { "GdkGeometry", GdkGeometry.sizeof }, + { "GdkScreenClass", GdkScreenClass.sizeof }, + { "GdkPixmapObjectClass", GdkPixmapObjectClass.sizeof }, + { "GdkPixmapObject", GdkPixmapObject.sizeof }, + { "GdkPangoAttrEmbossColor", GdkPangoAttrEmbossColor.sizeof }, + { "GdkPangoAttrEmbossed", GdkPangoAttrEmbossed.sizeof }, + { "GdkPangoAttrStipple", GdkPangoAttrStipple.sizeof }, + { "GdkPangoRendererClass", GdkPangoRendererClass.sizeof }, + { "GdkPangoRenderer", GdkPangoRenderer.sizeof }, + { "GdkDisplayManagerClass", GdkDisplayManagerClass.sizeof }, + { "GdkKeymapClass", GdkKeymapClass.sizeof }, + { "GdkKeymap", GdkKeymap.sizeof }, + { "GdkKeymapKey", GdkKeymapKey.sizeof }, + { "GdkImageClass", GdkImageClass.sizeof }, + { "GdkTrapezoid", GdkTrapezoid.sizeof }, + { "GdkDrawableClass", GdkDrawableClass.sizeof }, + { "GdkGCClass", GdkGCClass.sizeof }, + { "GdkGCValues", GdkGCValues.sizeof }, + { "GdkDisplayPointerHooks", GdkDisplayPointerHooks.sizeof }, + { "GdkDisplayClass", GdkDisplayClass.sizeof }, + { "GdkEvent", GdkEvent.sizeof }, + { "GdkEventGrabBroken", GdkEventGrabBroken.sizeof }, + { "GdkEventSetting", GdkEventSetting.sizeof }, + { "GdkEventWindowState", GdkEventWindowState.sizeof }, + { "GdkEventDND", GdkEventDND.sizeof }, + { "GdkEventClient", GdkEventClient.sizeof }, + { "GdkEventProximity", GdkEventProximity.sizeof }, + { "GdkEventOwnerChange", GdkEventOwnerChange.sizeof }, + { "GdkEventSelection", GdkEventSelection.sizeof }, + { "GdkEventProperty", GdkEventProperty.sizeof }, + { "GdkEventConfigure", GdkEventConfigure.sizeof }, + { "GdkEventCrossing", GdkEventCrossing.sizeof }, + { "GdkEventFocus", GdkEventFocus.sizeof }, + { "GdkEventKey", GdkEventKey.sizeof }, + { "GdkEventScroll", GdkEventScroll.sizeof }, + { "GdkEventButton", GdkEventButton.sizeof }, + { "GdkEventMotion", GdkEventMotion.sizeof }, + { "GdkEventVisibility", GdkEventVisibility.sizeof }, + { "GdkEventNoExpose", GdkEventNoExpose.sizeof }, + { "GdkEventExpose", GdkEventExpose.sizeof }, + { "GdkEventAny", GdkEventAny.sizeof }, + { "GdkTimeCoord", GdkTimeCoord.sizeof }, + { "GdkDevice", GdkDevice.sizeof }, + { "GdkDeviceAxis", GdkDeviceAxis.sizeof }, + { "GdkDeviceKey", GdkDeviceKey.sizeof }, + { "GdkDragContextClass", GdkDragContextClass.sizeof }, + { "GdkDragContext", GdkDragContext.sizeof }, + { "GdkPixbufLoaderClass", GdkPixbufLoaderClass.sizeof }, + { "GdkPixbufLoader", GdkPixbufLoader.sizeof }, + { "GdkRgbCmap", GdkRgbCmap.sizeof }, + { "GdkColormapClass", GdkColormapClass.sizeof }, + { "GdkScreen", GdkScreen.sizeof }, + { "GdkDisplay", GdkDisplay.sizeof }, + { "GdkDrawable", GdkDrawable.sizeof }, + { "GdkVisual", GdkVisual.sizeof }, + { "GdkImage", GdkImage.sizeof }, + { "GdkGC", GdkGC.sizeof }, + { "GdkFont", GdkFont.sizeof }, + { "GdkCursor", GdkCursor.sizeof }, + { "GdkColormap", GdkColormap.sizeof }, + { "GdkColor", GdkColor.sizeof }, + { "GdkSpan", GdkSpan.sizeof }, + { "GdkSegment", GdkSegment.sizeof }, + { "GdkRectangle", GdkRectangle.sizeof }, + { "GdkPoint", GdkPoint.sizeof }, + { "GStaticMutex", _GStaticMutex.sizeof }, + { "GSystemThread", _GSystemThread.sizeof }, + { "GValueArray", GValueArray.sizeof }, + { "GTypePluginClass", GTypePluginClass.sizeof }, + { "GTypeModuleClass", GTypeModuleClass.sizeof }, + { "GTypeModule", GTypeModule.sizeof }, + { "GParamSpecGType", GParamSpecGType.sizeof }, + { "GParamSpecOverride", GParamSpecOverride.sizeof }, + { "GParamSpecObject", GParamSpecObject.sizeof }, + { "GParamSpecValueArray", GParamSpecValueArray.sizeof }, + { "GParamSpecPointer", GParamSpecPointer.sizeof }, + { "GParamSpecBoxed", GParamSpecBoxed.sizeof }, + { "GParamSpecParam", GParamSpecParam.sizeof }, + { "GParamSpecString", GParamSpecString.sizeof }, + { "GParamSpecDouble", GParamSpecDouble.sizeof }, + { "GParamSpecFloat", GParamSpecFloat.sizeof }, + { "GParamSpecFlags", GParamSpecFlags.sizeof }, + { "GParamSpecEnum", GParamSpecEnum.sizeof }, + { "GParamSpecUnichar", GParamSpecUnichar.sizeof }, + { "GParamSpecUInt64", GParamSpecUInt64.sizeof }, + { "GParamSpecInt64", GParamSpecInt64.sizeof }, + { "GParamSpecULong", GParamSpecULong.sizeof }, + { "GParamSpecLong", GParamSpecLong.sizeof }, + { "GParamSpecUInt", GParamSpecUInt.sizeof }, + { "GParamSpecInt", GParamSpecInt.sizeof }, + { "GParamSpecBoolean", GParamSpecBoolean.sizeof }, + { "GParamSpecUChar", GParamSpecUChar.sizeof }, + { "GParamSpecChar", GParamSpecChar.sizeof }, + { "GObjectConstructParam", GObjectConstructParam.sizeof }, + { "GObjectClass", GObjectClass.sizeof }, + { "GObject", GObject.sizeof }, + { "GSignalInvocationHint", GSignalInvocationHint.sizeof }, + { "GSignalQuery", GSignalQuery.sizeof }, + { "GCClosure", GCClosure.sizeof }, + { "GClosureNotifyData", GClosureNotifyData.sizeof }, + { "GClosure", GClosure.sizeof }, + { "GParamSpecTypeInfo", GParamSpecTypeInfo.sizeof }, + { "GParameter", GParameter.sizeof }, + { "GParamSpecClass", GParamSpecClass.sizeof }, + { "GParamSpec", GParamSpec.sizeof }, + { "GFlagsValue", GFlagsValue.sizeof }, + { "GEnumValue", GEnumValue.sizeof }, + { "GFlagsClass", GFlagsClass.sizeof }, + { "GEnumClass", GEnumClass.sizeof }, + { "GTypeQuery", GTypeQuery.sizeof }, + { "GTypeValueTable", GTypeValueTable.sizeof }, + { "GInterfaceInfo", GInterfaceInfo.sizeof }, + { "GTypeFundamentalInfo", GTypeFundamentalInfo.sizeof }, + { "GTypeInfo", GTypeInfo.sizeof }, + { "GTypeInstance", GTypeInstance.sizeof }, + { "GTypeInterface", GTypeInterface.sizeof }, + { "GTypeClass", GTypeClass.sizeof }, + { "GValue", GValue.sizeof }, + { "GThreadPool", GThreadPool.sizeof }, + { "GTokenValue", GTokenValue.sizeof }, + { "GScannerConfig", GScannerConfig.sizeof }, + { "GScanner", GScanner.sizeof }, + { "GTuples", GTuples.sizeof }, + { "GQueue", GQueue.sizeof }, + { "GOptionEntry", GOptionEntry.sizeof }, + { "GNode", GNode.sizeof }, + { "GMarkupParser", GMarkupParser.sizeof }, + { "GIOFuncs", GIOFuncs.sizeof }, + { "GIOChannel", GIOChannel.sizeof }, + { "GString", GString.sizeof }, + { "GPollFD", GPollFD.sizeof }, + { "GSourceFuncs", GSourceFuncs.sizeof }, + { "GSourceCallbackFuncs", GSourceCallbackFuncs.sizeof }, + { "GSource", GSource.sizeof }, + { "GSList", GSList.sizeof }, + { "GHookList", GHookList.sizeof }, + { "GHook", GHook.sizeof }, + { "GDate", GDate.sizeof }, + { "GCompletion", GCompletion.sizeof }, + { "GList", GList.sizeof }, + { "GMemVTable", GMemVTable.sizeof }, + { "GOnce", GOnce.sizeof }, + { "GStaticRWLock", GStaticRWLock.sizeof }, + { "GStaticRecMutex", GStaticRecMutex.sizeof }, + { "GThreadFunctions", GThreadFunctions.sizeof }, + { "GStaticPrivate", GStaticPrivate.sizeof }, + { "GThread", GThread.sizeof }, + { "GTrashStack", GTrashStack.sizeof }, + { "GDebugKey", GDebugKey.sizeof }, + { "GError", GError.sizeof }, + { "GPtrArray", GPtrArray.sizeof }, + { "GByteArray", GByteArray.sizeof }, + { "GArray", GArray.sizeof }, + { "GTimeVal", GTimeVal.sizeof }, + { "GFloatIEEE754", GFloatIEEE754.sizeof }, + { "GDoubleIEEE754", GDoubleIEEE754.sizeof }, + { "GLXEvent", GLXEvent.sizeof }, + { "GLXPbufferClobberEvent", GLXPbufferClobberEvent.sizeof }, + { "GtkVSeparatorClass", GtkVSeparatorClass.sizeof }, + { "GtkVSeparator", GtkVSeparator.sizeof }, + { "GtkVScaleClass", GtkVScaleClass.sizeof }, + { "GtkVScale", GtkVScale.sizeof }, + { "GtkVRulerClass", GtkVRulerClass.sizeof }, + { "GtkVRuler", GtkVRuler.sizeof }, + { "GtkVPanedClass", GtkVPanedClass.sizeof }, + { "GtkVPaned", GtkVPaned.sizeof }, + { "GtkVolumeButtonClass", GtkVolumeButtonClass.sizeof }, + { "GtkVButtonBoxClass", GtkVButtonBoxClass.sizeof }, + { "GtkVButtonBox", GtkVButtonBox.sizeof }, + { "GtkUIManagerClass", GtkUIManagerClass.sizeof }, + { "GtkUIManager", GtkUIManager.sizeof }, + { "GtkTreeStoreClass", GtkTreeStoreClass.sizeof }, + { "GtkTreeStore", GtkTreeStore.sizeof }, + { "GtkTreeModelSortClass", GtkTreeModelSortClass.sizeof }, + { "GtkTreeModelSort", GtkTreeModelSort.sizeof }, + { "GtkTreeDragDestIface", GtkTreeDragDestIface.sizeof }, + { "GtkTreeDragSourceIface", GtkTreeDragSourceIface.sizeof }, + { "GtkToolbarClass", GtkToolbarClass.sizeof }, + { "GtkToolbar", GtkToolbar.sizeof }, + { "GtkToolbarChild", GtkToolbarChild.sizeof }, + { "GtkTipsQueryClass", GtkTipsQueryClass.sizeof }, + { "GtkTipsQuery", GtkTipsQuery.sizeof }, + { "GtkTextViewClass", GtkTextViewClass.sizeof }, + { "GtkTextView", GtkTextView.sizeof }, + { "GtkTextBufferClass", GtkTextBufferClass.sizeof }, + { "GtkTextMarkClass", GtkTextMarkClass.sizeof }, + { "GtkTextMark", GtkTextMark.sizeof }, + { "GtkTextTagTableClass", GtkTextTagTableClass.sizeof }, + { "GtkTearoffMenuItemClass", GtkTearoffMenuItemClass.sizeof }, + { "GtkTearoffMenuItem", GtkTearoffMenuItem.sizeof }, + { "GtkTableRowCol", GtkTableRowCol.sizeof }, + { "GtkTableChild", GtkTableChild.sizeof }, + { "GtkTableClass", GtkTableClass.sizeof }, + { "GtkTable", GtkTable.sizeof }, + { "GtkStockItem", GtkStockItem.sizeof }, + { "GtkStatusIconClass", GtkStatusIconClass.sizeof }, + { "GtkStatusIcon", GtkStatusIcon.sizeof }, + { "GtkStatusbarClass", GtkStatusbarClass.sizeof }, + { "GtkStatusbar", GtkStatusbar.sizeof }, + { "GtkSpinButtonClass", GtkSpinButtonClass.sizeof }, + { "GtkSpinButton", GtkSpinButton.sizeof }, + { "GtkSizeGroupClass", GtkSizeGroupClass.sizeof }, + { "GtkSizeGroup", GtkSizeGroup.sizeof }, + { "GtkSeparatorToolItemClass", GtkSeparatorToolItemClass.sizeof }, + { "GtkSeparatorToolItem", GtkSeparatorToolItem.sizeof }, + { "GtkSeparatorMenuItemClass", GtkSeparatorMenuItemClass.sizeof }, + { "GtkSeparatorMenuItem", GtkSeparatorMenuItem.sizeof }, + { "GtkScrolledWindowClass", GtkScrolledWindowClass.sizeof }, + { "GtkScrolledWindow", GtkScrolledWindow.sizeof }, + { "GtkViewportClass", GtkViewportClass.sizeof }, + { "GtkViewport", GtkViewport.sizeof }, + { "GtkScaleButtonClass", GtkScaleButtonClass.sizeof }, + { "GtkScaleButton", GtkScaleButton.sizeof }, + { "GtkRecentChooserWidgetClass", GtkRecentChooserWidgetClass.sizeof }, + { "GtkRecentChooserWidget", GtkRecentChooserWidget.sizeof }, + { "GtkRecentChooserMenuClass", GtkRecentChooserMenuClass.sizeof }, + { "GtkRecentChooserMenu", GtkRecentChooserMenu.sizeof }, + { "GtkRecentChooserDialogClass", GtkRecentChooserDialogClass.sizeof }, + { "GtkRecentChooserDialog", GtkRecentChooserDialog.sizeof }, + { "GtkRecentChooserIface", GtkRecentChooserIface.sizeof }, + { "GtkRecentFilterInfo", GtkRecentFilterInfo.sizeof }, + { "GtkRecentActionClass", GtkRecentActionClass.sizeof }, + { "GtkRecentAction", GtkRecentAction.sizeof }, + { "GtkRecentManagerClass", GtkRecentManagerClass.sizeof }, + { "GtkRecentManager", GtkRecentManager.sizeof }, + { "GtkRecentData", GtkRecentData.sizeof }, + { "GtkRadioToolButtonClass", GtkRadioToolButtonClass.sizeof }, + { "GtkRadioToolButton", GtkRadioToolButton.sizeof }, + { "GtkToggleToolButtonClass", GtkToggleToolButtonClass.sizeof }, + { "GtkToggleToolButton", GtkToggleToolButton.sizeof }, + { "GtkRadioMenuItemClass", GtkRadioMenuItemClass.sizeof }, + { "GtkRadioMenuItem", GtkRadioMenuItem.sizeof }, + { "GtkRadioButtonClass", GtkRadioButtonClass.sizeof }, + { "GtkRadioButton", GtkRadioButton.sizeof }, + { "GtkRadioActionClass", GtkRadioActionClass.sizeof }, + { "GtkRadioAction", GtkRadioAction.sizeof }, + { "GtkToggleActionClass", GtkToggleActionClass.sizeof }, + { "GtkToggleAction", GtkToggleAction.sizeof }, + { "GtkProgressBarClass", GtkProgressBarClass.sizeof }, + { "GtkProgressBar", GtkProgressBar.sizeof }, + { "GtkProgressClass", GtkProgressClass.sizeof }, + { "GtkProgress", GtkProgress.sizeof }, + { "GtkPrintOperation", GtkPrintOperation.sizeof }, + { "GtkPrintOperationClass", GtkPrintOperationClass.sizeof }, + { "GtkPrintOperationPreviewIface", GtkPrintOperationPreviewIface.sizeof }, + { "GtkPageRange", GtkPageRange.sizeof }, + { "GtkPreviewClass", GtkPreviewClass.sizeof }, + { "GtkDitherInfo", GtkDitherInfo.sizeof }, + { "GtkPreviewInfo", GtkPreviewInfo.sizeof }, + { "GtkPreview", GtkPreview.sizeof }, + { "GtkPlugClass", GtkPlugClass.sizeof }, + { "GtkPlug", GtkPlug.sizeof }, + { "GtkSocketClass", GtkSocketClass.sizeof }, + { "GtkSocket", GtkSocket.sizeof }, + { "GtkPixmapClass", GtkPixmapClass.sizeof }, + { "GtkPixmap", GtkPixmap.sizeof }, + { "GtkOptionMenuClass", GtkOptionMenuClass.sizeof }, + { "GtkOptionMenu", GtkOptionMenu.sizeof }, + { "GtkOldEditableClass", GtkOldEditableClass.sizeof }, + { "GtkOldEditable", GtkOldEditable.sizeof }, + { "GtkNotebookClass", GtkNotebookClass.sizeof }, + { "GtkNotebook", GtkNotebook.sizeof }, + { "GtkMessageDialogClass", GtkMessageDialogClass.sizeof }, + { "GtkMessageDialog", GtkMessageDialog.sizeof }, + { "GtkMenuToolButton", GtkMenuToolButton.sizeof }, + { "GtkMenuToolButtonClass", GtkMenuToolButtonClass.sizeof }, + { "GtkToolButtonClass", GtkToolButtonClass.sizeof }, + { "GtkToolButton", GtkToolButton.sizeof }, + { "GtkToolItemClass", GtkToolItemClass.sizeof }, + { "GtkToolItem", GtkToolItem.sizeof }, + { "GtkTooltipsData", GtkTooltipsData.sizeof }, + { "GtkTooltipsClass", GtkTooltipsClass.sizeof }, + { "GtkTooltips", GtkTooltips.sizeof }, + { "GtkMenuBarClass", GtkMenuBarClass.sizeof }, + { "GtkMenuBar", GtkMenuBar.sizeof }, + { "GtkListClass", GtkListClass.sizeof }, + { "GtkList", GtkList.sizeof }, + { "GtkListItemClass", GtkListItemClass.sizeof }, + { "GtkListItem", GtkListItem.sizeof }, + { "GtkLinkButtonClass", GtkLinkButtonClass.sizeof }, + { "GtkLinkButton", GtkLinkButton.sizeof }, + { "GtkLayoutClass", GtkLayoutClass.sizeof }, + { "GtkLayout", GtkLayout.sizeof }, + { "GtkInvisibleClass", GtkInvisibleClass.sizeof }, + { "GtkInvisible", GtkInvisible.sizeof }, + { "GtkInputDialogClass", GtkInputDialogClass.sizeof }, + { "GtkInputDialog", GtkInputDialog.sizeof }, + { "GtkIMMulticontextClass", GtkIMMulticontextClass.sizeof }, + { "GtkIMMulticontext", GtkIMMulticontext.sizeof }, + { "GtkIMContextSimpleClass", GtkIMContextSimpleClass.sizeof }, + { "GtkIMContextSimple", GtkIMContextSimple.sizeof }, + { "GtkImageMenuItemClass", GtkImageMenuItemClass.sizeof }, + { "GtkImageMenuItem", GtkImageMenuItem.sizeof }, + { "GtkIconViewClass", GtkIconViewClass.sizeof }, + { "GtkIconView", GtkIconView.sizeof }, + { "GtkIconThemeClass", GtkIconThemeClass.sizeof }, + { "GtkIconTheme", GtkIconTheme.sizeof }, + { "GtkIconFactoryClass", GtkIconFactoryClass.sizeof }, + { "GtkHSeparatorClass", GtkHSeparatorClass.sizeof }, + { "GtkHSeparator", GtkHSeparator.sizeof }, + { "GtkSeparatorClass", GtkSeparatorClass.sizeof }, + { "GtkSeparator", GtkSeparator.sizeof }, + { "GtkHScaleClass", GtkHScaleClass.sizeof }, + { "GtkHScale", GtkHScale.sizeof }, + { "GtkScaleClass", GtkScaleClass.sizeof }, + { "GtkScale", GtkScale.sizeof }, + { "GtkHRulerClass", GtkHRulerClass.sizeof }, + { "GtkHRuler", GtkHRuler.sizeof }, + { "GtkRulerMetric", GtkRulerMetric.sizeof }, + { "GtkRulerClass", GtkRulerClass.sizeof }, + { "GtkRuler", GtkRuler.sizeof }, + { "GtkHPanedClass", GtkHPanedClass.sizeof }, + { "GtkHPaned", GtkHPaned.sizeof }, + { "GtkPanedClass", GtkPanedClass.sizeof }, + { "GtkPaned", GtkPaned.sizeof }, + { "GtkHButtonBoxClass", GtkHButtonBoxClass.sizeof }, + { "GtkHButtonBox", GtkHButtonBox.sizeof }, + { "GtkHandleBoxClass", GtkHandleBoxClass.sizeof }, + { "GtkHandleBox", GtkHandleBox.sizeof }, + { "GtkGammaCurveClass", GtkGammaCurveClass.sizeof }, + { "GtkGammaCurve", GtkGammaCurve.sizeof }, + { "GtkFontSelectionDialogClass", GtkFontSelectionDialogClass.sizeof }, + { "GtkFontSelectionDialog", GtkFontSelectionDialog.sizeof }, + { "GtkFontSelectionClass", GtkFontSelectionClass.sizeof }, + { "GtkFontSelection", GtkFontSelection.sizeof }, + { "GtkFontButtonClass", GtkFontButtonClass.sizeof }, + { "GtkFontButton", GtkFontButton.sizeof }, + { "GtkFileChooserWidgetClass", GtkFileChooserWidgetClass.sizeof }, + { "GtkFileChooserWidget", GtkFileChooserWidget.sizeof }, + { "GtkFileChooserDialogClass", GtkFileChooserDialogClass.sizeof }, + { "GtkFileChooserDialog", GtkFileChooserDialog.sizeof }, + { "GtkFileChooserButtonClass", GtkFileChooserButtonClass.sizeof }, + { "GtkFileChooserButton", GtkFileChooserButton.sizeof }, + { "GtkFileFilterInfo", GtkFileFilterInfo.sizeof }, + { "GtkFixedChild", GtkFixedChild.sizeof }, + { "GtkFixedClass", GtkFixedClass.sizeof }, + { "GtkFixed", GtkFixed.sizeof }, + { "GtkFileSelectionClass", GtkFileSelectionClass.sizeof }, + { "GtkFileSelection", GtkFileSelection.sizeof }, + { "GtkExpanderClass", GtkExpanderClass.sizeof }, + { "GtkExpander", GtkExpander.sizeof }, + { "GtkEventBoxClass", GtkEventBoxClass.sizeof }, + { "GtkEventBox", GtkEventBox.sizeof }, + { "GtkCurveClass", GtkCurveClass.sizeof }, + { "GtkCurve", GtkCurve.sizeof }, + { "GtkDrawingAreaClass", GtkDrawingAreaClass.sizeof }, + { "GtkDrawingArea", GtkDrawingArea.sizeof }, + { "GtkCTreeNode", GtkCTreeNode.sizeof }, + { "GtkCTreeRow", GtkCTreeRow.sizeof }, + { "GtkCTreeClass", GtkCTreeClass.sizeof }, + { "GtkCTree", GtkCTree.sizeof }, + { "GtkComboBoxEntryClass", GtkComboBoxEntryClass.sizeof }, + { "GtkComboBoxEntry", GtkComboBoxEntry.sizeof }, + { "GtkComboBoxClass", GtkComboBoxClass.sizeof }, + { "GtkComboBox", GtkComboBox.sizeof }, + { "GtkTreeSelectionClass", GtkTreeSelectionClass.sizeof }, + { "GtkTreeSelection", GtkTreeSelection.sizeof }, + { "GtkTreeViewClass", GtkTreeViewClass.sizeof }, + { "GtkTreeView", GtkTreeView.sizeof }, + { "GtkEntryClass", GtkEntryClass.sizeof }, + { "GtkEntry", GtkEntry.sizeof }, + { "GtkEntryCompletionClass", GtkEntryCompletionClass.sizeof }, + { "GtkEntryCompletion", GtkEntryCompletion.sizeof }, + { "GtkTreeModelFilterClass", GtkTreeModelFilterClass.sizeof }, + { "GtkTreeModelFilter", GtkTreeModelFilter.sizeof }, + { "GtkListStoreClass", GtkListStoreClass.sizeof }, + { "GtkListStore", GtkListStore.sizeof }, + { "GtkIMContextClass", GtkIMContextClass.sizeof }, + { "GtkIMContext", GtkIMContext.sizeof }, + { "GtkEditableClass", GtkEditableClass.sizeof }, + { "GtkComboClass", GtkComboClass.sizeof }, + { "GtkCombo", GtkCombo.sizeof }, + { "GtkHBoxClass", GtkHBoxClass.sizeof }, + { "GtkHBox", GtkHBox.sizeof }, + { "GtkColorSelectionDialogClass", GtkColorSelectionDialogClass.sizeof }, + { "GtkColorSelectionDialog", GtkColorSelectionDialog.sizeof }, + { "GtkColorSelectionClass", GtkColorSelectionClass.sizeof }, + { "GtkColorSelection", GtkColorSelection.sizeof }, + { "GtkVBoxClass", GtkVBoxClass.sizeof }, + { "GtkVBox", GtkVBox.sizeof }, + { "GtkColorButtonClass", GtkColorButtonClass.sizeof }, + { "GtkColorButton", GtkColorButton.sizeof }, + { "GtkCListDestInfo", GtkCListDestInfo.sizeof }, + { "GtkCListCellInfo", GtkCListCellInfo.sizeof }, + { "GtkCellWidget", GtkCellWidget.sizeof }, + { "GtkCellPixText", GtkCellPixText.sizeof }, + { "GtkCellPixmap", GtkCellPixmap.sizeof }, + { "GtkCellText", GtkCellText.sizeof }, + { "GtkCell", GtkCell.sizeof }, + { "GtkCListRow", GtkCListRow.sizeof }, + { "GtkCListColumn", GtkCListColumn.sizeof }, + { "GtkCListClass", GtkCListClass.sizeof }, + { "GtkCList", GtkCList.sizeof }, + { "GtkVScrollbarClass", GtkVScrollbarClass.sizeof }, + { "GtkVScrollbar", GtkVScrollbar.sizeof }, + { "GtkHScrollbarClass", GtkHScrollbarClass.sizeof }, + { "GtkHScrollbar", GtkHScrollbar.sizeof }, + { "GtkScrollbarClass", GtkScrollbarClass.sizeof }, + { "GtkScrollbar", GtkScrollbar.sizeof }, + { "GtkRangeClass", GtkRangeClass.sizeof }, + { "GtkRange", GtkRange.sizeof }, + { "GtkTargetPair", GtkTargetPair.sizeof }, + { "GtkTargetEntry", GtkTargetEntry.sizeof }, + { "GtkTargetList", GtkTargetList.sizeof }, + { "GtkTextBuffer", GtkTextBuffer.sizeof }, + { "GtkTextChildAnchorClass", GtkTextChildAnchorClass.sizeof }, + { "GtkTextChildAnchor", GtkTextChildAnchor.sizeof }, + { "GtkTextAppearance", GtkTextAppearance.sizeof }, + { "GtkTextTagClass", GtkTextTagClass.sizeof }, + { "GtkTextTag", GtkTextTag.sizeof }, + { "GtkTextAttributes", GtkTextAttributes.sizeof }, + { "GtkTextTagTable", GtkTextTagTable.sizeof }, + { "GtkTextIter", GtkTextIter.sizeof }, + { "GtkCheckMenuItemClass", GtkCheckMenuItemClass.sizeof }, + { "GtkCheckMenuItem", GtkCheckMenuItem.sizeof }, + { "GtkMenuItemClass", GtkMenuItemClass.sizeof }, + { "GtkMenuItem", GtkMenuItem.sizeof }, + { "GtkItemClass", GtkItemClass.sizeof }, + { "GtkItem", GtkItem.sizeof }, + { "GtkCheckButtonClass", GtkCheckButtonClass.sizeof }, + { "GtkCheckButton", GtkCheckButton.sizeof }, + { "GtkToggleButtonClass", GtkToggleButtonClass.sizeof }, + { "GtkToggleButton", GtkToggleButton.sizeof }, + { "GtkCellViewClass", GtkCellViewClass.sizeof }, + { "GtkCellView", GtkCellView.sizeof }, + { "GtkCellRendererToggleClass", GtkCellRendererToggleClass.sizeof }, + { "GtkCellRendererToggle", GtkCellRendererToggle.sizeof }, + { "GtkCellRendererSpinClass", GtkCellRendererSpinClass.sizeof }, + { "GtkCellRendererSpin", GtkCellRendererSpin.sizeof }, + { "GtkCellRendererProgressClass", GtkCellRendererProgressClass.sizeof }, + { "GtkCellRendererProgress", GtkCellRendererProgress.sizeof }, + { "GtkCellRendererPixbufClass", GtkCellRendererPixbufClass.sizeof }, + { "GtkCellRendererPixbuf", GtkCellRendererPixbuf.sizeof }, + { "GtkCellRendererComboClass", GtkCellRendererComboClass.sizeof }, + { "GtkCellRendererCombo", GtkCellRendererCombo.sizeof }, + { "GtkCellRendererAccelClass", GtkCellRendererAccelClass.sizeof }, + { "GtkCellRendererAccel", GtkCellRendererAccel.sizeof }, + { "GtkCellRendererTextClass", GtkCellRendererTextClass.sizeof }, + { "GtkCellRendererText", GtkCellRendererText.sizeof }, + { "GtkCellLayoutIface", GtkCellLayoutIface.sizeof }, + { "GtkTreeViewColumnClass", GtkTreeViewColumnClass.sizeof }, + { "GtkTreeViewColumn", GtkTreeViewColumn.sizeof }, + { "GtkTreeSortableIface", GtkTreeSortableIface.sizeof }, + { "GtkTreeModelIface", GtkTreeModelIface.sizeof }, + { "GtkTreeIter", GtkTreeIter.sizeof }, + { "GtkCellRendererClass", GtkCellRendererClass.sizeof }, + { "GtkCellRenderer", GtkCellRenderer.sizeof }, + { "GtkCellEditableIface", GtkCellEditableIface.sizeof }, + { "GtkCalendarClass", GtkCalendarClass.sizeof }, + { "GtkCalendar", GtkCalendar.sizeof }, + { "GtkButtonClass", GtkButtonClass.sizeof }, + { "GtkButton", GtkButton.sizeof }, + { "GtkImageIconNameData", GtkImageIconNameData.sizeof }, + { "GtkImageAnimationData", GtkImageAnimationData.sizeof }, + { "GtkImageIconSetData", GtkImageIconSetData.sizeof }, + { "GtkImageStockData", GtkImageStockData.sizeof }, + { "GtkImagePixbufData", GtkImagePixbufData.sizeof }, + { "GtkImageImageData", GtkImageImageData.sizeof }, + { "GtkImagePixmapData", GtkImagePixmapData.sizeof }, + { "GtkImageClass", GtkImageClass.sizeof }, + { "GtkImage", GtkImage.sizeof }, + { "GtkBuildableIface", GtkBuildableIface.sizeof }, + { "GtkBuilderClass", GtkBuilderClass.sizeof }, + { "GtkBuilder", GtkBuilder.sizeof }, + { "GtkBindingArg", GtkBindingArg.sizeof }, + { "GtkBindingSignal", GtkBindingSignal.sizeof }, + { "GtkBindingEntry", GtkBindingEntry.sizeof }, + { "GtkBindingSet", GtkBindingSet.sizeof }, + { "GtkButtonBoxClass", GtkButtonBoxClass.sizeof }, + { "GtkButtonBox", GtkButtonBox.sizeof }, + { "GtkBoxChild", GtkBoxChild.sizeof }, + { "GtkBoxClass", GtkBoxClass.sizeof }, + { "GtkBox", GtkBox.sizeof }, + { "GtkAssistantClass", GtkAssistantClass.sizeof }, + { "GtkAssistant", GtkAssistant.sizeof }, + { "GtkAspectFrameClass", GtkAspectFrameClass.sizeof }, + { "GtkAspectFrame", GtkAspectFrame.sizeof }, + { "GtkFrameClass", GtkFrameClass.sizeof }, + { "GtkFrame", GtkFrame.sizeof }, + { "GtkArrowClass", GtkArrowClass.sizeof }, + { "GtkArrow", GtkArrow.sizeof }, + { "GtkAlignmentClass", GtkAlignmentClass.sizeof }, + { "GtkAlignment", GtkAlignment.sizeof }, + { "GtkRadioActionEntry", GtkRadioActionEntry.sizeof }, + { "GtkToggleActionEntry", GtkToggleActionEntry.sizeof }, + { "GtkActionEntry", GtkActionEntry.sizeof }, + { "GtkActionGroupClass", GtkActionGroupClass.sizeof }, + { "GtkActionGroup", GtkActionGroup.sizeof }, + { "GtkMenuEntry", GtkMenuEntry.sizeof }, + { "GtkItemFactoryItem", GtkItemFactoryItem.sizeof }, + { "GtkItemFactoryEntry", GtkItemFactoryEntry.sizeof }, + { "GtkItemFactoryClass", GtkItemFactoryClass.sizeof }, + { "GtkItemFactory", GtkItemFactory.sizeof }, + { "GtkActionClass", GtkActionClass.sizeof }, + { "GtkAction", GtkAction.sizeof }, + { "GtkAccessibleClass", GtkAccessibleClass.sizeof }, + { "GtkAccessible", GtkAccessible.sizeof }, + { "GtkAccelLabelClass", GtkAccelLabelClass.sizeof }, + { "GtkAccelLabel", GtkAccelLabel.sizeof }, + { "GtkLabelClass", GtkLabelClass.sizeof }, + { "GtkLabel", GtkLabel.sizeof }, + { "GtkMenuClass", GtkMenuClass.sizeof }, + { "GtkMenu", GtkMenu.sizeof }, + { "GtkMenuShellClass", GtkMenuShellClass.sizeof }, + { "GtkMenuShell", GtkMenuShell.sizeof }, + { "GtkMiscClass", GtkMiscClass.sizeof }, + { "GtkMisc", GtkMisc.sizeof }, + { "GtkAboutDialogClass", GtkAboutDialogClass.sizeof }, + { "GtkAboutDialog", GtkAboutDialog.sizeof }, + { "GtkDialogClass", GtkDialogClass.sizeof }, + { "GtkDialog", GtkDialog.sizeof }, + { "GtkWindowGroupClass", GtkWindowGroupClass.sizeof }, + { "GtkWindowGroup", GtkWindowGroup.sizeof }, + { "GtkWindowClass", GtkWindowClass.sizeof }, + { "GtkBinClass", GtkBinClass.sizeof }, + { "GtkBin", GtkBin.sizeof }, + { "GtkContainerClass", GtkContainerClass.sizeof }, + { "GtkContainer", GtkContainer.sizeof }, + { "GtkWindow", GtkWindow.sizeof }, + { "GtkWidgetShapeInfo", GtkWidgetShapeInfo.sizeof }, + { "GtkWidgetAuxInfo", GtkWidgetAuxInfo.sizeof }, + { "GtkWidgetClass", GtkWidgetClass.sizeof }, + { "GtkSelectionData", GtkSelectionData.sizeof }, + { "GtkRequisition", GtkRequisition.sizeof }, + { "GtkSettingsValue", GtkSettingsValue.sizeof }, + { "GtkSettingsClass", GtkSettingsClass.sizeof }, + { "GtkRcStyleClass", GtkRcStyleClass.sizeof }, + { "GtkIconFactory", GtkIconFactory.sizeof }, + { "GtkWidget", GtkWidget.sizeof }, + { "GtkSettings", GtkSettings.sizeof }, + { "GtkRcProperty", GtkRcProperty.sizeof }, + { "GtkRcStyle", GtkRcStyle.sizeof }, + { "GtkStyleClass", GtkStyleClass.sizeof }, + { "GtkStyle", GtkStyle.sizeof }, + { "GtkBorder", GtkBorder.sizeof }, + { "GtkAdjustmentClass", GtkAdjustmentClass.sizeof }, + { "GtkAdjustment", GtkAdjustment.sizeof }, + { "GtkObjectClass", GtkObjectClass.sizeof }, + { "GtkTypeInfo", GtkTypeInfo.sizeof }, + { "GtkObject", GtkObject.sizeof }, + { "GtkArg", GtkArg.sizeof }, + { "GtkAccelGroupEntry", GtkAccelGroupEntry.sizeof }, + { "GtkAccelKey", GtkAccelKey.sizeof }, + { "GtkAccelGroupClass", GtkAccelGroupClass.sizeof }, + { "GtkAccelGroup", GtkAccelGroup.sizeof }, + { "GtkPrintUnixDialogClass", GtkPrintUnixDialogClass.sizeof }, + { "GtkPrintUnixDialog", GtkPrintUnixDialog.sizeof }, + { "GtkPrintJobClass", GtkPrintJobClass.sizeof }, + { "GtkPrintJob", GtkPrintJob.sizeof }, + { "GtkPrinterClass", GtkPrinterClass.sizeof }, + { "GtkPrinter", GtkPrinter.sizeof }, + { "GtkPageSetupUnixDialogClass", GtkPageSetupUnixDialogClass.sizeof }, + { "GtkPageSetupUnixDialog", GtkPageSetupUnixDialog.sizeof }, + { "PangoRendererClass", PangoRendererClass.sizeof }, + { "PangoRenderer", PangoRenderer.sizeof }, + { "PangoLayoutLine", PangoLayoutLine.sizeof }, + { "PangoGlyphItem", PangoGlyphItem.sizeof }, + { "PangoGlyphString", PangoGlyphString.sizeof }, + { "PangoGlyphInfo", PangoGlyphInfo.sizeof }, + { "PangoGlyphVisAttr", PangoGlyphVisAttr.sizeof }, + { "PangoGlyphGeometry", PangoGlyphGeometry.sizeof }, + { "PangoItem", PangoItem.sizeof }, + { "PangoAnalysis", PangoAnalysis.sizeof }, + { "PangoAttrShape", PangoAttrShape.sizeof }, + { "PangoAttrFontDesc", PangoAttrFontDesc.sizeof }, + { "PangoAttrColor", PangoAttrColor.sizeof }, + { "PangoAttrFloat", PangoAttrFloat.sizeof }, + { "PangoAttrSize", PangoAttrSize.sizeof }, + { "PangoAttrInt", PangoAttrInt.sizeof }, + { "PangoAttrLanguage", PangoAttrLanguage.sizeof }, + { "PangoAttrString", PangoAttrString.sizeof }, + { "PangoAttrClass", PangoAttrClass.sizeof }, + { "PangoAttribute", PangoAttribute.sizeof }, + { "PangoColor", PangoColor.sizeof }, + { "PangoMatrix", PangoMatrix.sizeof }, + { "PangoRectangle", PangoRectangle.sizeof }, + { "PangoLogAttr", PangoLogAttr.sizeof }, + { "XExtensionVersion", XExtensionVersion.sizeof }, + { "XButtonState", XButtonState.sizeof }, + { "XKeyState", XKeyState.sizeof }, + { "XValuatorState", XValuatorState.sizeof }, + { "XDeviceState", XDeviceState.sizeof }, + { "XDeviceTimeCoord", XDeviceTimeCoord.sizeof }, + { "XEventList", XEventList.sizeof }, + { "XDevice", XDevice.sizeof }, + { "XInputClassInfo", XInputClassInfo.sizeof }, + { "XValuatorInfo", XValuatorInfo.sizeof }, + { "XAxisInfo", XAxisInfo.sizeof }, + { "XButtonInfo", XButtonInfo.sizeof }, + { "XKeyInfo", XKeyInfo.sizeof }, + { "XDeviceInfo", XDeviceInfo.sizeof }, + { "XDeviceEnableControl", XDeviceEnableControl.sizeof }, + { "XDeviceCoreState", XDeviceCoreState.sizeof }, + { "XDeviceCoreControl", XDeviceCoreControl.sizeof }, + { "XDeviceAbsAreaControl", XDeviceAbsAreaControl.sizeof }, + { "XDeviceAbsCalibControl", XDeviceAbsCalibControl.sizeof }, + { "XDeviceResolutionState", XDeviceResolutionState.sizeof }, + { "XDeviceResolutionControl", XDeviceResolutionControl.sizeof }, + { "XDeviceControl", XDeviceControl.sizeof }, + { "XLedFeedbackControl", XLedFeedbackControl.sizeof }, + { "XBellFeedbackControl", XBellFeedbackControl.sizeof }, + { "XIntegerFeedbackControl", XIntegerFeedbackControl.sizeof }, + { "XStringFeedbackControl", XStringFeedbackControl.sizeof }, + { "XKbdFeedbackControl", XKbdFeedbackControl.sizeof }, + { "XPtrFeedbackControl", XPtrFeedbackControl.sizeof }, + { "XFeedbackControl", XFeedbackControl.sizeof }, + { "XLedFeedbackState", XLedFeedbackState.sizeof }, + { "XBellFeedbackState", XBellFeedbackState.sizeof }, + { "XStringFeedbackState", XStringFeedbackState.sizeof }, + { "XIntegerFeedbackState", XIntegerFeedbackState.sizeof }, + { "XPtrFeedbackState", XPtrFeedbackState.sizeof }, + { "XKbdFeedbackState", XKbdFeedbackState.sizeof }, + { "XFeedbackState", XFeedbackState.sizeof }, + { "XDevicePresenceNotifyEvent", XDevicePresenceNotifyEvent.sizeof }, + { "XChangeDeviceNotifyEvent", XChangeDeviceNotifyEvent.sizeof }, + { "XDeviceMappingEvent", XDeviceMappingEvent.sizeof }, + { "XButtonStatus", XButtonStatus.sizeof }, + { "XKeyStatus", XKeyStatus.sizeof }, + { "XValuatorStatus", XValuatorStatus.sizeof }, + { "XDeviceStateNotifyEvent", XDeviceStateNotifyEvent.sizeof }, + { "XInputClass", XInputClass.sizeof }, + { "XProximityNotifyEvent", XProximityNotifyEvent.sizeof }, + { "XDeviceFocusChangeEvent", XDeviceFocusChangeEvent.sizeof }, + { "XDeviceMotionEvent", XDeviceMotionEvent.sizeof }, + { "XDeviceButtonEvent", XDeviceButtonEvent.sizeof }, + { "XDeviceKeyEvent", XDeviceKeyEvent.sizeof }, + { "XIMValuesList", XIMValuesList.sizeof }, + { "XIMHotKeyTriggers", XIMHotKeyTriggers.sizeof }, + { "XIMHotKeyTrigger", XIMHotKeyTrigger.sizeof }, + { "XIMStatusDrawCallbackStruct", XIMStatusDrawCallbackStruct.sizeof }, + { "XIMPreeditCaretCallbackStruct", XIMPreeditCaretCallbackStruct.sizeof }, + { "XIMPreeditDrawCallbackStruct", XIMPreeditDrawCallbackStruct.sizeof }, + { "XIMStringConversionCallbackStruct", XIMStringConversionCallbackStruct.sizeof }, + { "XIMStringConversionText", XIMStringConversionText.sizeof }, + { "XIMPreeditStateNotifyCallbackStruct", XIMPreeditStateNotifyCallbackStruct.sizeof }, + { "XIMText", XIMText.sizeof }, + { "XICCallback", XICCallback.sizeof }, + { "XIMCallback", XIMCallback.sizeof }, + { "XIMStyles", XIMStyles.sizeof }, + { "XOMFontInfo", XOMFontInfo.sizeof }, + { "XOMOrientation", XOMOrientation.sizeof }, + { "XOMCharSetList", XOMCharSetList.sizeof }, + { "XwcTextItem", XwcTextItem.sizeof }, + { "XmbTextItem", XmbTextItem.sizeof }, + { "XFontSetExtents", XFontSetExtents.sizeof }, + { "XEDataObject", XEDataObject.sizeof }, + { "XTextItem16", XTextItem16.sizeof }, + { "XChar2b", XChar2b.sizeof }, + { "XTextItem", XTextItem.sizeof }, + { "XFontStruct", XFontStruct.sizeof }, + { "XFontProp", XFontProp.sizeof }, + { "XCharStruct", XCharStruct.sizeof }, + { "XEvent", XEvent.sizeof }, + { "XAnyEvent", XAnyEvent.sizeof }, + { "XErrorEvent", XErrorEvent.sizeof }, + { "XMappingEvent", XMappingEvent.sizeof }, + { "XClientMessageEvent", XClientMessageEvent.sizeof }, + { "XColormapEvent", XColormapEvent.sizeof }, + { "XSelectionEvent", XSelectionEvent.sizeof }, + { "XSelectionRequestEvent", XSelectionRequestEvent.sizeof }, + { "XSelectionClearEvent", XSelectionClearEvent.sizeof }, + { "XPropertyEvent", XPropertyEvent.sizeof }, + { "XCirculateRequestEvent", XCirculateRequestEvent.sizeof }, + { "XCirculateEvent", XCirculateEvent.sizeof }, + { "XConfigureRequestEvent", XConfigureRequestEvent.sizeof }, + { "XResizeRequestEvent", XResizeRequestEvent.sizeof }, + { "XGravityEvent", XGravityEvent.sizeof }, + { "XConfigureEvent", XConfigureEvent.sizeof }, + { "XReparentEvent", XReparentEvent.sizeof }, + { "XMapRequestEvent", XMapRequestEvent.sizeof }, + { "XMapEvent", XMapEvent.sizeof }, + { "XUnmapEvent", XUnmapEvent.sizeof }, + { "XDestroyWindowEvent", XDestroyWindowEvent.sizeof }, + { "XCreateWindowEvent", XCreateWindowEvent.sizeof }, + { "XVisibilityEvent", XVisibilityEvent.sizeof }, + { "XNoExposeEvent", XNoExposeEvent.sizeof }, + { "XGraphicsExposeEvent", XGraphicsExposeEvent.sizeof }, + { "XExposeEvent", XExposeEvent.sizeof }, + { "XKeymapEvent", XKeymapEvent.sizeof }, + { "XFocusChangeEvent", XFocusChangeEvent.sizeof }, + { "XCrossingEvent", XCrossingEvent.sizeof }, + { "XMotionEvent", XMotionEvent.sizeof }, + { "XButtonEvent", XButtonEvent.sizeof }, + { "XKeyEvent", XKeyEvent.sizeof }, + { "XModifierKeymap", XModifierKeymap.sizeof }, + { "XTimeCoord", XTimeCoord.sizeof }, + { "XKeyboardState", XKeyboardState.sizeof }, + { "XKeyboardControl", XKeyboardControl.sizeof }, + { "XArc", XArc.sizeof }, + { "XRectangle", XRectangle.sizeof }, + { "XPoint", XPoint.sizeof }, + { "XSegment", XSegment.sizeof }, + { "XColor", XColor.sizeof }, + { "XWindowChanges", XWindowChanges.sizeof }, + { "XImage", XImage.sizeof }, + { "XServerInterpretedAddress", XServerInterpretedAddress.sizeof }, + { "XHostAddress", XHostAddress.sizeof }, + { "XWindowAttributes", XWindowAttributes.sizeof }, + { "XSetWindowAttributes", XSetWindowAttributes.sizeof }, + { "ScreenFormat", ScreenFormat.sizeof }, + { "Screen", Screen.sizeof }, + { "Depth", Depth.sizeof }, + { "Visual", Visual.sizeof }, + { "XGCValues", XGCValues.sizeof }, + { "XPixmapFormatValues", XPixmapFormatValues.sizeof }, + { "XExtCodes", XExtCodes.sizeof }, + { "XExtData", XExtData.sizeof }, + { "XConicalGradient", XConicalGradient.sizeof }, + { "XRadialGradient", XRadialGradient.sizeof }, + { "XLinearGradient", XLinearGradient.sizeof }, + { "XTrap", XTrap.sizeof }, + { "XSpanFix", XSpanFix.sizeof }, + { "XAnimCursor", XAnimCursor.sizeof }, + { "XIndexValue", XIndexValue.sizeof }, + { "XFilters", XFilters.sizeof }, + { "XTransform", XTransform.sizeof }, + { "XTrapezoid", XTrapezoid.sizeof }, + { "XCircle", XCircle.sizeof }, + { "XTriangle", XTriangle.sizeof }, + { "XLineFixed", XLineFixed.sizeof }, + { "XPointFixed", XPointFixed.sizeof }, + { "XPointDouble", XPointDouble.sizeof }, + { "XGlyphElt32", XGlyphElt32.sizeof }, + { "XGlyphElt16", XGlyphElt16.sizeof }, + { "XGlyphElt8", XGlyphElt8.sizeof }, + { "XGlyphInfo", XGlyphInfo.sizeof }, + { "XRenderColor", XRenderColor.sizeof }, + { "XRenderPictureAttributes", XRenderPictureAttributes.sizeof }, + { "XRenderPictFormat", XRenderPictFormat.sizeof }, + { "XRenderDirectFormat", XRenderDirectFormat.sizeof }, + { "XStandardColormap", XStandardColormap.sizeof }, + { "XVisualInfo", XVisualInfo.sizeof }, + { "XComposeStatus", XComposeStatus.sizeof }, + { "XClassHint", XClassHint.sizeof }, + { "XIconSize", XIconSize.sizeof }, + { "XTextProperty", XTextProperty.sizeof }, + { "XWMHints", XWMHints.sizeof }, + { "XSizeHints", XSizeHints.sizeof } +]; + +int main( char[][] args ){ + foreach( v; size_values ){ + printf( "%.*s\t%d\n", v.name, v.size ); + } + return 0; +} + + + diff -r 00f135d0337d -r c39d1446f191 devhelpers/structswin/structs.d --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/devhelpers/structswin/structs.d Mon Jul 21 22:54:04 2008 +0200 @@ -0,0 +1,623 @@ +// Author: Frank Benoit +// This prints the sizes of some C struct how they are defined in the c-bindings + +import dwt.internal.win32.WINTYPES; + +extern(C) int printf( char*, ... ); + +struct TSizeValue { + char[] name; + int size; +} ; + +const TSizeValue[] size_values = [ + { "ABC", ABC.sizeof } + { "ABCFLOAT", ABCFLOAT.sizeof } + { "ACCEL", ACCEL.sizeof } + { "ACCESS_ALLOWED_ACE", ACCESS_ALLOWED_ACE.sizeof } + { "ACCESS_DENIED_ACE", ACCESS_DENIED_ACE.sizeof } + { "ACCESSTIMEOUT", ACCESSTIMEOUT.sizeof } + { "ACE_HEADER", ACE_HEADER.sizeof } + { "ACL", ACL.sizeof } + { "ACL_REVISION_INFORMATION", ACL_REVISION_INFORMATION.sizeof } + { "ACL_SIZE_INFORMATION", ACL_SIZE_INFORMATION.sizeof } + { "ACTCTXA", ACTCTXA.sizeof } + { "ACTCTXW", ACTCTXW.sizeof } + { "ACTION_HEADER", ACTION_HEADER.sizeof } + { "ADAPTER_STATUS", ADAPTER_STATUS.sizeof } + { "ADDJOB_INFO_1", ADDJOB_INFO_1.sizeof } + { "ANIMATIONINFO", ANIMATIONINFO.sizeof } + { "APPBARDATA", APPBARDATA.sizeof } + { "BITMAP", BITMAP.sizeof } + { "BITMAPCOREHEADER", BITMAPCOREHEADER.sizeof } + { "BITMAPCOREINFO", BITMAPCOREINFO.sizeof } + { "BITMAPFILEHEADER", BITMAPFILEHEADER.sizeof } + { "BITMAPINFO", BITMAPINFO.sizeof } + { "BITMAPINFOHEADER", BITMAPINFOHEADER.sizeof } + { "BITMAPV4HEADER", BITMAPV4HEADER.sizeof } + { "_BLENDFUNCTION", _BLENDFUNCTION.sizeof } + { "BLOB", BLOB.sizeof } + { "BROWSEINFOA", BROWSEINFOA.sizeof } + { "BROWSEINFOW", BROWSEINFOW.sizeof } + { "BUTTON_IMAGELIST", BUTTON_IMAGELIST.sizeof } + { "BY_HANDLE_FILE_INFORMATION", BY_HANDLE_FILE_INFORMATION.sizeof } + { "CANDIDATEFORM", CANDIDATEFORM.sizeof } + { "CANDIDATELIST", CANDIDATELIST.sizeof } + { "CBTACTIVATESTRUCT", CBTACTIVATESTRUCT.sizeof } + { "CBT_CREATEWND", CBT_CREATEWND.sizeof } + { "CHARFORMAT", CHARFORMAT.sizeof } + { "CHAR_INFO", CHAR_INFO.sizeof } + { "CHARRANGE", CHARRANGE.sizeof } + { "CHARSET", CHARSET.sizeof } + { "CHARSETINFO", CHARSETINFO.sizeof } + { "CHOOSECOLORA", CHOOSECOLORA.sizeof } + { "CHOOSECOLORW", CHOOSECOLORW.sizeof } + { "CHOOSEFONTA", CHOOSEFONTA.sizeof } + { "CHOOSEFONTW", CHOOSEFONTW.sizeof } + { "CIDA", CIDA.sizeof } + { "CIEXYZ", CIEXYZ.sizeof } + { "CIEXYZTRIPLE", CIEXYZTRIPLE.sizeof } + { "CLIENTCREATESTRUCT", CLIENTCREATESTRUCT.sizeof } + { "CMINVOKECOMMANDINFO", CMINVOKECOMMANDINFO.sizeof } + { "COLORADJUSTMENT", COLORADJUSTMENT.sizeof } + { "COLORMAP", COLORMAP.sizeof } + { "COMBOBOXINFO", COMBOBOXINFO.sizeof } + { "COMMCONFIG", COMMCONFIG.sizeof } + { "COMMPROP", COMMPROP.sizeof } + { "COMMTIMEOUTS", COMMTIMEOUTS.sizeof } + { "COMPAREITEMSTRUCT", COMPAREITEMSTRUCT.sizeof } + { "COMPCOLOR", COMPCOLOR.sizeof } + { "COMPOSITIONFORM", COMPOSITIONFORM.sizeof } + { "COMSTAT", COMSTAT.sizeof } + { "CONNECTDLGSTRUCT", CONNECTDLGSTRUCT.sizeof } + { "CONSOLE_CURSOR_INFO", CONSOLE_CURSOR_INFO.sizeof } + { "CONSOLE_SCREEN_BUFFER_INFO", CONSOLE_SCREEN_BUFFER_INFO.sizeof } + { "CONTEXT", CONTEXT.sizeof } + { "CONVCONTEXT", CONVCONTEXT.sizeof } + { "CONVINFO", CONVINFO.sizeof } + { "COORD", COORD.sizeof } + { "COPYDATASTRUCT", COPYDATASTRUCT.sizeof } + { "CPINFO", CPINFO.sizeof } + { "CPLINFO", CPLINFO.sizeof } + { "CREATE_PROCESS_DEBUG_INFO", CREATE_PROCESS_DEBUG_INFO.sizeof } + { "CREATESTRUCT", CREATESTRUCT.sizeof } + { "CREATE_THREAD_DEBUG_INFO", CREATE_THREAD_DEBUG_INFO.sizeof } + { "CRITICAL_SECTION", CRITICAL_SECTION.sizeof } + { "CRITICAL_SECTION_DEBUG", CRITICAL_SECTION_DEBUG.sizeof } + { "CURRENCYFMT", CURRENCYFMT.sizeof } + { "CURSORSHAPE", CURSORSHAPE.sizeof } + { "CWPRETSTRUCT", CWPRETSTRUCT.sizeof } + { "CWPSTRUCT", CWPSTRUCT.sizeof } + { "DATATYPES_INFO_1", DATATYPES_INFO_1.sizeof } + { "DCB", DCB.sizeof } + { "DDEACK", DDEACK.sizeof } + { "DDEADVISE", DDEADVISE.sizeof } + { "DDEDATA", DDEDATA.sizeof } + { "DDELN", DDELN.sizeof } + { "DDEML_MSG_HOOK_DATA", DDEML_MSG_HOOK_DATA.sizeof } + { "DDEPOKE", DDEPOKE.sizeof } + { "DDEUP", DDEUP.sizeof } + { "DEBUG_EVENT", DEBUG_EVENT.sizeof } + { "DEBUGHOOKINFO", DEBUGHOOKINFO.sizeof } + { "DELETEITEMSTRUCT", DELETEITEMSTRUCT.sizeof } + { "DEV_BROADCAST_HDR", DEV_BROADCAST_HDR.sizeof } + { "DEV_BROADCAST_OEM", DEV_BROADCAST_OEM.sizeof } + { "DEV_BROADCAST_PORT", DEV_BROADCAST_PORT.sizeof } + { "_DEV_BROADCAST_USERDEFINED", _DEV_BROADCAST_USERDEFINED.sizeof } + { "DEV_BROADCAST_VOLUME", DEV_BROADCAST_VOLUME.sizeof } + { "DEVMODE", DEVMODE.sizeof } + { "DEVMODEA dvmd", DEVMODEA dvmd.sizeof } + { "DEVMODEW dvmd", DEVMODEW dvmd.sizeof } + { "DEVNAMES", DEVNAMES.sizeof } + { "DIBSECTION", DIBSECTION.sizeof } + { "DISCDLGSTRUCT", DISCDLGSTRUCT.sizeof } + { "DISK_GEOMETRY", DISK_GEOMETRY.sizeof } + { "DISK_PERFORMANCE", DISK_PERFORMANCE.sizeof } + { "DLGITEMTEMPLATE", DLGITEMTEMPLATE.sizeof } + { "DLGTEMPLATE", DLGTEMPLATE.sizeof } + { "DLLVERSIONINFO", DLLVERSIONINFO.sizeof } + { "DOC_INFO_1", DOC_INFO_1.sizeof } + { "DOC_INFO_2", DOC_INFO_2.sizeof } + { "DOCINFOA", DOCINFOA.sizeof } + { "DOCINFOW", DOCINFOW.sizeof } + { "DRAGLISTINFO", DRAGLISTINFO.sizeof } + { "DRAWITEMSTRUCT", DRAWITEMSTRUCT.sizeof } + { "DRAWTEXTPARAMS", DRAWTEXTPARAMS.sizeof } + { "DRIVE_LAYOUT_INFORMATION", DRIVE_LAYOUT_INFORMATION.sizeof } + { "DRIVER_INFO_1", DRIVER_INFO_1.sizeof } + { "DRIVER_INFO_2", DRIVER_INFO_2.sizeof } + { "DRIVER_INFO_3", DRIVER_INFO_3.sizeof } + { "DROPFILES", DROPFILES.sizeof } + { "EDITSTREAM", EDITSTREAM.sizeof } + { "EMPTYRECORD", EMPTYRECORD.sizeof } + { "EMR", EMR.sizeof } + { "EMRABORTPATH", EMRABORTPATH.sizeof } + { "EMRANGLEARC", EMRANGLEARC.sizeof } + { "EMRARC", EMRARC.sizeof } + { "EMRBITBLT", EMRBITBLT.sizeof } + { "EMRCREATEBRUSHINDIRECT", EMRCREATEBRUSHINDIRECT.sizeof } + { "EMRCREATECOLORSPACE", EMRCREATECOLORSPACE.sizeof } + { "EMRCREATEDIBPATTERNBRUSHPT", EMRCREATEDIBPATTERNBRUSHPT.sizeof } + { "EMRCREATEMONOBRUSH", EMRCREATEMONOBRUSH.sizeof } + { "EMRCREATEPALETTE", EMRCREATEPALETTE.sizeof } + { "EMRCREATEPEN", EMRCREATEPEN.sizeof } + { "EMRELLIPSE", EMRELLIPSE.sizeof } + { "EMREOF", EMREOF.sizeof } + { "EMREXCLUDECLIPRECT", EMREXCLUDECLIPRECT.sizeof } + { "EMREXTCREATEFONTINDIRECTW", EMREXTCREATEFONTINDIRECTW.sizeof } + { "EMREXTCREATEPEN", EMREXTCREATEPEN.sizeof } + { "EMREXTFLOODFILL", EMREXTFLOODFILL.sizeof } + { "EMREXTSELECTCLIPRGN", EMREXTSELECTCLIPRGN.sizeof } + { "EMREXTTEXTOUTA", EMREXTTEXTOUTA.sizeof } + { "EMRFILLPATH", EMRFILLPATH.sizeof } + { "EMRFILLRGN", EMRFILLRGN.sizeof } + { "EMRFORMAT", EMRFORMAT.sizeof } + { "EMRFRAMERGN", EMRFRAMERGN.sizeof } + { "EMRGDICOMMENT", EMRGDICOMMENT.sizeof } + { "EMRINVERTRGN", EMRINVERTRGN.sizeof } + { "EMRLINETO", EMRLINETO.sizeof } + { "EMRMASKBLT", EMRMASKBLT.sizeof } + { "EMRMODIFYWORLDTRANSFORM", EMRMODIFYWORLDTRANSFORM.sizeof } + { "EMROFFSETCLIPRGN", EMROFFSETCLIPRGN.sizeof } + { "EMRPLGBLT", EMRPLGBLT.sizeof } + { "EMRPOLYDRAW", EMRPOLYDRAW.sizeof } + { "EMRPOLYDRAW16", EMRPOLYDRAW16.sizeof } + { "EMRPOLYLINE", EMRPOLYLINE.sizeof } + { "EMRPOLYLINE16", EMRPOLYLINE16.sizeof } + { "EMRPOLYPOLYLINE", EMRPOLYPOLYLINE.sizeof } + { "EMRPOLYPOLYLINE16", EMRPOLYPOLYLINE16.sizeof } + { "EMRPOLYTEXTOUTA", EMRPOLYTEXTOUTA.sizeof } + { "EMRRESIZEPALETTE", EMRRESIZEPALETTE.sizeof } + { "EMRRESTOREDC", EMRRESTOREDC.sizeof } + { "EMRROUNDRECT", EMRROUNDRECT.sizeof } + { "EMRSCALEVIEWPORTEXTEX", EMRSCALEVIEWPORTEXTEX.sizeof } + { "EMRSELECTCLIPPATH", EMRSELECTCLIPPATH.sizeof } + { "EMRSELECTCOLORSPACE", EMRSELECTCOLORSPACE.sizeof } + { "EMRSELECTOBJECT", EMRSELECTOBJECT.sizeof } + { "EMRSELECTPALETTE", EMRSELECTPALETTE.sizeof } + { "EMRSETARCDIRECTION", EMRSETARCDIRECTION.sizeof } + { "EMRSETBKCOLOR", EMRSETBKCOLOR.sizeof } + { "EMRSETCOLORADJUSTMENT", EMRSETCOLORADJUSTMENT.sizeof } + { "EMRSETDIBITSTODEVICE", EMRSETDIBITSTODEVICE.sizeof } + { "EMRSETMAPPERFLAGS", EMRSETMAPPERFLAGS.sizeof } + { "EMRSETMITERLIMIT", EMRSETMITERLIMIT.sizeof } + { "EMRSETPALETTEENTRIES", EMRSETPALETTEENTRIES.sizeof } + { "EMRSETPIXELV", EMRSETPIXELV.sizeof } + { "EMRSETVIEWPORTEXTEX", EMRSETVIEWPORTEXTEX.sizeof } + { "EMRSETVIEWPORTORGEX", EMRSETVIEWPORTORGEX.sizeof } + { "EMRSETWORLDTRANSFORM", EMRSETWORLDTRANSFORM.sizeof } + { "EMRSTRETCHBLT", EMRSTRETCHBLT.sizeof } + { "EMRSTRETCHDIBITS", EMRSTRETCHDIBITS.sizeof } + { "EMRTEXT", EMRTEXT.sizeof } + { "ENCORRECTTEXT", ENCORRECTTEXT.sizeof } + { "ENDROPFILES", ENDROPFILES.sizeof } + { "ENHMETAHEADER", ENHMETAHEADER.sizeof } + { "ENHMETARECORD", ENHMETARECORD.sizeof } + { "ENOLEOPFAILED", ENOLEOPFAILED.sizeof } + { "ENPROTECTED", ENPROTECTED.sizeof } + { "ENSAVECLIPBOARD", ENSAVECLIPBOARD.sizeof } + { "ENUMLOGFONTA", ENUMLOGFONTA.sizeof } + { "ENUMLOGFONTEXA", ENUMLOGFONTEXA.sizeof } + { "ENUMLOGFONTEXW", ENUMLOGFONTEXW.sizeof } + { "ENUMLOGFONTW", ENUMLOGFONTW.sizeof } + { "ENUM_SERVICE_STATUS", ENUM_SERVICE_STATUS.sizeof } + { "EVENTLOGRECORD", EVENTLOGRECORD.sizeof } + { "EVENTMSG", EVENTMSG.sizeof } + { "EXCEPTION_DEBUG_INFO", EXCEPTION_DEBUG_INFO.sizeof } + { "EXCEPTION_POINTERS", EXCEPTION_POINTERS.sizeof } + { "EXCEPTION_RECORD", EXCEPTION_RECORD.sizeof } + { "EXIT_PROCESS_DEBUG_INFO", EXIT_PROCESS_DEBUG_INFO.sizeof } + { "EXIT_THREAD_DEBUG_INFO", EXIT_THREAD_DEBUG_INFO.sizeof } + { "EXT_BUTTON", EXT_BUTTON.sizeof } + { "EXTLOGFONT", EXTLOGFONT.sizeof } + { "EXTLOGPEN", EXTLOGPEN.sizeof } + { "FILETIME", FILETIME.sizeof } + { "FILTERKEYS", FILTERKEYS.sizeof } + { "FIND_NAME_BUFFER", FIND_NAME_BUFFER.sizeof } + { "FIND_NAME_HEADER", FIND_NAME_HEADER.sizeof } + { "FINDREPLACE", FINDREPLACE.sizeof } + { "FINDTEXTEX", FINDTEXTEX.sizeof } + { "FIXED", FIXED.sizeof } + { "FLOATING_SAVE_AREA", FLOATING_SAVE_AREA.sizeof } + { "FMS_GETDRIVEINFO", FMS_GETDRIVEINFO.sizeof } + { "FMS_GETFILESEL", FMS_GETFILESEL.sizeof } + { "FMS_LOAD", FMS_LOAD.sizeof } + { "FMS_TOOLBARLOAD", FMS_TOOLBARLOAD.sizeof } + { "FOCUS_EVENT_RECORD", FOCUS_EVENT_RECORD.sizeof } + { "FONTSIGNATURE", FONTSIGNATURE.sizeof } + { "FORMAT_PARAMETERS", FORMAT_PARAMETERS.sizeof } + { "FORMATRANGE", FORMATRANGE.sizeof } + { "FORM_INFO_1", FORM_INFO_1.sizeof } + { "GCP_RESULTSA", GCP_RESULTSA.sizeof } + { "GCP_RESULTSW", GCP_RESULTSW.sizeof } + { "GENERIC_MAPPING", GENERIC_MAPPING.sizeof } + { "GLYPHMETRICS", GLYPHMETRICS.sizeof } + { "GLYPHMETRICSFLOAT", GLYPHMETRICSFLOAT.sizeof } + { "GOFFSET", GOFFSET.sizeof } + { "GRADIENT_RECT", GRADIENT_RECT.sizeof } + { "GROUP_INFO_2", GROUP_INFO_2.sizeof } + { "__GUID", __GUID.sizeof } + { "GUITHREADINFO", GUITHREADINFO.sizeof } + { "HANDLETABLE", HANDLETABLE.sizeof } + { "HD_HITTESTINFO", HD_HITTESTINFO.sizeof } + { "HD_ITEM", HD_ITEM.sizeof } + { "HDITEMA", HDITEMA.sizeof } + { "HDITEMW", HDITEMW.sizeof } + { "HD_LAYOUT", HD_LAYOUT.sizeof } + { "HD_NOTIFY", HD_NOTIFY.sizeof } + { "HELPINFO", HELPINFO.sizeof } + { "HELPWININFO", HELPWININFO.sizeof } + { "HIGHCONTRASTA", HIGHCONTRASTA.sizeof } + { "HIGHCONTRASTW", HIGHCONTRASTW.sizeof } + { "HSZPAIR", HSZPAIR.sizeof } + { "ICONINFO", ICONINFO.sizeof } + { "ICONMETRICS", ICONMETRICS.sizeof } + { "IMAGE_DOS_HEADER", IMAGE_DOS_HEADER.sizeof } + { "IMAGEINFO", IMAGEINFO.sizeof } + { "INITCOMMONCONTROLSEX", INITCOMMONCONTROLSEX.sizeof } + { "INPUT", INPUT.sizeof } + { "INPUT_RECORD", INPUT_RECORD.sizeof } + { "ITEMIDLIST", ITEMIDLIST.sizeof } + { "JOB_INFO_1", JOB_INFO_1.sizeof } + { "JOB_INFO_2", JOB_INFO_2.sizeof } + { "KERNINGPAIR", KERNINGPAIR.sizeof } + { "KEYBDINPUT", KEYBDINPUT.sizeof } + { "KEY_EVENT_RECORD", KEY_EVENT_RECORD.sizeof } + { "LANA_ENUM", LANA_ENUM.sizeof } + { "LAYERPLANEDESCRIPTOR", LAYERPLANEDESCRIPTOR.sizeof } + { "LDT_ENTRY", LDT_ENTRY.sizeof } + { "LIST_ENTRY", LIST_ENTRY.sizeof } + { "LITEM", LITEM.sizeof } + { "LOAD_DLL_DEBUG_INFO", LOAD_DLL_DEBUG_INFO.sizeof } + { "LOCALESIGNATURE", LOCALESIGNATURE.sizeof } + { "LOCALGROUP_INFO_0", LOCALGROUP_INFO_0.sizeof } + { "LOCALGROUP_MEMBERS_INFO_0", LOCALGROUP_MEMBERS_INFO_0.sizeof } + { "LOCALGROUP_MEMBERS_INFO_3", LOCALGROUP_MEMBERS_INFO_3.sizeof } + { "LOGBRUSH", LOGBRUSH.sizeof } + { "LOGCOLORSPACE", LOGCOLORSPACE.sizeof } + { "LOGFONTA", LOGFONTA.sizeof } + { "LOGFONTW", LOGFONTW.sizeof } + { "LOGPALETTE", LOGPALETTE.sizeof } + { "LOGPEN", LOGPEN.sizeof } + { "LUID_AND_ATTRIBUTES", LUID_AND_ATTRIBUTES.sizeof } + { "LV_COLUMN", LV_COLUMN.sizeof } + { "LVCOLUMNA", LVCOLUMNA.sizeof } + { "LVCOLUMNW", LVCOLUMNW.sizeof } + { "LV_DISPINFO", LV_DISPINFO.sizeof } + { "LV_FINDINFO", LV_FINDINFO.sizeof } + { "LVFINDINFOA", LVFINDINFOA.sizeof } + { "LVFINDINFOW", LVFINDINFOW.sizeof } + { "LVHITTESTINFO", LVHITTESTINFO.sizeof } + { "LV_HITTESTINFO", LV_HITTESTINFO.sizeof } + { "LV_ITEM", LV_ITEM.sizeof } + { "LVITEMA", LVITEMA.sizeof } + { "LVITEMW", LVITEMW.sizeof } + { "LV_KEYDOWN", LV_KEYDOWN.sizeof } + { "MARGINS", MARGINS.sizeof } + { "MAT2", MAT2.sizeof } + { "MDICREATESTRUCT", MDICREATESTRUCT.sizeof } + { "MEASUREITEMSTRUCT", MEASUREITEMSTRUCT.sizeof } + { "MEMORY_BASIC_INFORMATION", MEMORY_BASIC_INFORMATION.sizeof } + { "MEMORYSTATUS", MEMORYSTATUS.sizeof } + { "MENUBARINFO", MENUBARINFO.sizeof } + { "MENU_EVENT_RECORD", MENU_EVENT_RECORD.sizeof } + { "MENUEX_TEMPLATE_HEADER", MENUEX_TEMPLATE_HEADER.sizeof } + { "MENUEX_TEMPLATE_ITEM", MENUEX_TEMPLATE_ITEM.sizeof } + { "MENUINFO", MENUINFO.sizeof } + { "MENUITEMINFOA", MENUITEMINFOA.sizeof } + { "MENUITEMINFOW", MENUITEMINFOW.sizeof } + { "MENUITEMTEMPLATE", MENUITEMTEMPLATE.sizeof } + { "MENUITEMTEMPLATEHEADER", MENUITEMTEMPLATEHEADER.sizeof } + { "MENUTEMPLATE", MENUTEMPLATE.sizeof } + { "METAFILEPICT", METAFILEPICT.sizeof } + { "METAHEADER", METAHEADER.sizeof } + { "METARECORD", METARECORD.sizeof } + { "MINIMIZEDMETRICS", MINIMIZEDMETRICS.sizeof } + { "MINMAXINFO", MINMAXINFO.sizeof } + { "MODEMDEVCAPS", MODEMDEVCAPS.sizeof } + { "MODEMSETTINGS", MODEMSETTINGS.sizeof } + { "MONCBSTRUCT", MONCBSTRUCT.sizeof } + { "MONCONVSTRUCT", MONCONVSTRUCT.sizeof } + { "MONERRSTRUCT", MONERRSTRUCT.sizeof } + { "MONHSZSTRUCT", MONHSZSTRUCT.sizeof } + { "MONITORINFO", MONITORINFO.sizeof } + { "MONITOR_INFO_1", MONITOR_INFO_1.sizeof } + { "MONITOR_INFO_2", MONITOR_INFO_2.sizeof } + { "MONLINKSTRUCT", MONLINKSTRUCT.sizeof } + { "MONMSGSTRUCT", MONMSGSTRUCT.sizeof } + { "MOUSE_EVENT_RECORD", MOUSE_EVENT_RECORD.sizeof } + { "MOUSEHOOKSTRUCT", MOUSEHOOKSTRUCT.sizeof } + { "MOUSEINPUT", MOUSEINPUT.sizeof } + { "MOUSEKEYS", MOUSEKEYS.sizeof } + { "MSG", MSG.sizeof } + { "MSGBOXPARAMS", MSGBOXPARAMS.sizeof } + { "MSGFILTER", MSGFILTER.sizeof } + { "MULTIKEYHELP", MULTIKEYHELP.sizeof } + { "NAME_BUFFER", NAME_BUFFER.sizeof } + { "NCB", NCB.sizeof } + { "NCCALCSIZE_PARAMS", NCCALCSIZE_PARAMS.sizeof } + { "NDDESHAREINFO", NDDESHAREINFO.sizeof } + { "NETCONNECTINFOSTRUCT", NETCONNECTINFOSTRUCT.sizeof } + { "NETINFOSTRUCT", NETINFOSTRUCT.sizeof } + { "NETRESOURCE", NETRESOURCE.sizeof } + { "NEWCPLINFO", NEWCPLINFO.sizeof } + { "NEWTEXTMETRICA", NEWTEXTMETRICA.sizeof } + { "NEWTEXTMETRICA ntm", NEWTEXTMETRICA ntm.sizeof } + { "NEWTEXTMETRICEXA", NEWTEXTMETRICEXA.sizeof } + { "NEWTEXTMETRICEXW", NEWTEXTMETRICEXW.sizeof } + { "NEWTEXTMETRICW", NEWTEXTMETRICW.sizeof } + { "NEWTEXTMETRICW ntm", NEWTEXTMETRICW ntm.sizeof } + { "NMCUSTOMDRAW", NMCUSTOMDRAW.sizeof } + { "NMHDR", NMHDR.sizeof } + { "NMHEADER", NMHEADER.sizeof } + { "NMLINK", NMLINK.sizeof } + { "NMLISTVIEW", NMLISTVIEW.sizeof } + { "NM_LISTVIEW", NM_LISTVIEW.sizeof } + { "NMLVCUSTOMDRAW", NMLVCUSTOMDRAW.sizeof } + { "NMLVDISPINFOA", NMLVDISPINFOA.sizeof } + { "NMLVDISPINFOW", NMLVDISPINFOW.sizeof } + { "NMLVFINDITEMA", NMLVFINDITEMA.sizeof } + { "NMLVFINDITEMW", NMLVFINDITEMW.sizeof } + { "NMLVODSTATECHANGE", NMLVODSTATECHANGE.sizeof } + { "NMREBARCHEVRON", NMREBARCHEVRON.sizeof } + { "NMREBARCHILDSIZE", NMREBARCHILDSIZE.sizeof } + { "NMRGINFO", NMRGINFO.sizeof } + { "NMTBHOTITEM", NMTBHOTITEM.sizeof } + { "NMTOOLBARA", NMTOOLBARA.sizeof } + { "NMTOOLBARW", NMTOOLBARW.sizeof } + { "NMTREEVIEW", NMTREEVIEW.sizeof } + { "NMTTCUSTOMDRAW", NMTTCUSTOMDRAW.sizeof } + { "NMTTDISPINFOA", NMTTDISPINFOA.sizeof } + { "NMTTDISPINFOW", NMTTDISPINFOW.sizeof } + { "NMTVCUSTOMDRAW", NMTVCUSTOMDRAW.sizeof } + { "NMTVDISPINFO", NMTVDISPINFO.sizeof } + { "NMTVITEMCHANGE", NMTVITEMCHANGE.sizeof } + { "NM_UPDOWNW", NM_UPDOWNW.sizeof } + { "NONCLIENTMETRICSA", NONCLIENTMETRICSA.sizeof } + { "NONCLIENTMETRICSW", NONCLIENTMETRICSW.sizeof } + { "NOTIFYICONDATAA", NOTIFYICONDATAA.sizeof } + { "NOTIFYICONDATAW", NOTIFYICONDATAW.sizeof } + { "NS_SERVICE_INFO", NS_SERVICE_INFO.sizeof } + { "NUMBERFMT", NUMBERFMT.sizeof } + { "_OBJECT_TYPE_LIST", _OBJECT_TYPE_LIST.sizeof } + { "OFNOTIFY", OFNOTIFY.sizeof } + { "OFSTRUCT", OFSTRUCT.sizeof } + { "OPENFILENAME", OPENFILENAME.sizeof } + { "OPENFILENAMEA", OPENFILENAMEA.sizeof } + { "OPENFILENAMEW", OPENFILENAMEW.sizeof } + { "OSVERSIONINFOA", OSVERSIONINFOA.sizeof } + { "OSVERSIONINFOEX", OSVERSIONINFOEX.sizeof } + { "OSVERSIONINFOW", OSVERSIONINFOW.sizeof } + { "OUTLINETEXTMETRICA", OUTLINETEXTMETRICA.sizeof } + { "OUTLINETEXTMETRICW", OUTLINETEXTMETRICW.sizeof } + { "OUTPUT_DEBUG_STRING_INFO", OUTPUT_DEBUG_STRING_INFO.sizeof } + { "OVERLAPPED", OVERLAPPED.sizeof } + { "PAINTSTRUCT", PAINTSTRUCT.sizeof } + { "PALETTEENTRY", PALETTEENTRY.sizeof } + { "PANOSE", PANOSE.sizeof } + { "PARAFORMAT", PARAFORMAT.sizeof } + { "PARTITION_INFORMATION", PARTITION_INFORMATION.sizeof } + { "PERF_COUNTER_BLOCK", PERF_COUNTER_BLOCK.sizeof } + { "PERF_COUNTER_DEFINITION", PERF_COUNTER_DEFINITION.sizeof } + { "PERF_DATA_BLOCK", PERF_DATA_BLOCK.sizeof } + { "PERF_INSTANCE_DEFINITION", PERF_INSTANCE_DEFINITION.sizeof } + { "PERF_OBJECT_TYPE", PERF_OBJECT_TYPE.sizeof } + { "PIXELFORMATDESCRIPTOR", PIXELFORMATDESCRIPTOR.sizeof } + { "POINT", POINT.sizeof } + { "POINTFLOAT", POINTFLOAT.sizeof } + { "POINTFX", POINTFX.sizeof } + { "POINTL", POINTL.sizeof } + { "POINTS", POINTS.sizeof } + { "POLYTEXT", POLYTEXT.sizeof } + { "PORT_INFO_1", PORT_INFO_1.sizeof } + { "PORT_INFO_2", PORT_INFO_2.sizeof } + { "PREVENT_MEDIA_REMOVAL", PREVENT_MEDIA_REMOVAL.sizeof } + { "PRINTDLGA pd", PRINTDLGA pd.sizeof } + { "PRINTDLGW pd", PRINTDLGW pd.sizeof } + { "PRINTER_DEFAULTS", PRINTER_DEFAULTS.sizeof } + { "PRINTER_INFO_1", PRINTER_INFO_1.sizeof } + { "PRINTER_INFO_2", PRINTER_INFO_2.sizeof } + { "PRINTER_INFO_3", PRINTER_INFO_3.sizeof } + { "PRINTER_INFO_4", PRINTER_INFO_4.sizeof } + { "PRINTER_INFO_5", PRINTER_INFO_5.sizeof } + { "PRINTER_NOTIFY_INFO", PRINTER_NOTIFY_INFO.sizeof } + { "PRINTER_NOTIFY_INFO_DATA", PRINTER_NOTIFY_INFO_DATA.sizeof } + { "PRINTER_NOTIFY_OPTIONS", PRINTER_NOTIFY_OPTIONS.sizeof } + { "PRINTER_NOTIFY_OPTIONS_TYPE", PRINTER_NOTIFY_OPTIONS_TYPE.sizeof } + { "PRINTPROCESSOR_INFO_1", PRINTPROCESSOR_INFO_1.sizeof } + { "PRIVILEGE_SET", PRIVILEGE_SET.sizeof } + { "PROCESS_HEAPENTRY", PROCESS_HEAPENTRY.sizeof } + { "PROCESS_INFORMATION", PROCESS_INFORMATION.sizeof } + { "PROPSHEETHEADER", PROPSHEETHEADER.sizeof } + { "PROPSHEETHEADER_U1", PROPSHEETHEADER_U1.sizeof } + { "PROPSHEETHEADER_U2", PROPSHEETHEADER_U2.sizeof } + { "PROPSHEETHEADER_U3", PROPSHEETHEADER_U3.sizeof } + { "PROPSHEETPAGE", PROPSHEETPAGE.sizeof } + { "PROPSHEETPAGE_U1", PROPSHEETPAGE_U1.sizeof } + { "PROPSHEETPAGE_U2", PROPSHEETPAGE_U2.sizeof } + { "PROTOCOL_INFO", PROTOCOL_INFO.sizeof } + { "PROVIDOR_INFO_1", PROVIDOR_INFO_1.sizeof } + { "PSHNOTIFY", PSHNOTIFY.sizeof } + { "PUNCTUATION", PUNCTUATION.sizeof } + { "QUERY_SERVICE_CONFIG", QUERY_SERVICE_CONFIG.sizeof } + { "QUERY_SERVICE_LOCK_STATUS", QUERY_SERVICE_LOCK_STATUS.sizeof } + { "RASAMB", RASAMB.sizeof } + { "RASCONN", RASCONN.sizeof } + { "RASCONNSTATUS", RASCONNSTATUS.sizeof } + { "RASDIALEXTENSIONS", RASDIALEXTENSIONS.sizeof } + { "RASDIALPARAMS", RASDIALPARAMS.sizeof } + { "RASENTRYNAME", RASENTRYNAME.sizeof } + { "RASPPPIP", RASPPPIP.sizeof } + { "RASPPPIPX", RASPPPIPX.sizeof } + { "RASPPPNBF", RASPPPNBF.sizeof } + { "RASTERIZER_STATUS", RASTERIZER_STATUS.sizeof } + { "REASSIGN_BLOCKS", REASSIGN_BLOCKS.sizeof } + { "REBARBANDINFOA", REBARBANDINFOA.sizeof } + { "REBARBANDINFOW", REBARBANDINFOW.sizeof } + { "RECT", RECT.sizeof } + { "RECTL", RECTL.sizeof } + { "REMOTE_NAME_INFO", REMOTE_NAME_INFO.sizeof } + { "REPASTESPECIAL", REPASTESPECIAL.sizeof } + { "REQRESIZE", REQRESIZE.sizeof } + { "RGBQUAD", RGBQUAD.sizeof } + { "RGBQUAD rgbq", RGBQUAD rgbq.sizeof } + { "RGBTRIPLE", RGBTRIPLE.sizeof } + { "RGNDATA", RGNDATA.sizeof } + { "RGNDATAHEADER", RGNDATAHEADER.sizeof } + { "RIP_INFO", RIP_INFO.sizeof } + { "SCRIPT_ANALYSIS", SCRIPT_ANALYSIS.sizeof } + { "SCRIPT_CONTROL", SCRIPT_CONTROL.sizeof } + { "SCRIPT_DIGITSUBSTITUTE", SCRIPT_DIGITSUBSTITUTE.sizeof } + { "SCRIPT_FONTPROPERTIES", SCRIPT_FONTPROPERTIES.sizeof } + { "SCRIPT_ITEM", SCRIPT_ITEM.sizeof } + { "SCRIPT_LOGATTR", SCRIPT_LOGATTR.sizeof } + { "SCRIPT_PROPERTIES", SCRIPT_PROPERTIES.sizeof } + { "SCRIPT_STATE", SCRIPT_STATE.sizeof } + { "SCRIPT_TABDEF", SCRIPT_TABDEF.sizeof } + { "SCRIPT_VISATTR", SCRIPT_VISATTR.sizeof } + { "SCROLLBARINFO", SCROLLBARINFO.sizeof } + { "SCROLLINFO", SCROLLINFO.sizeof } + { "SECURITY_ATTRIBUTES", SECURITY_ATTRIBUTES.sizeof } + { "SECURITY_DESCRIPTOR", SECURITY_DESCRIPTOR.sizeof } + { "SECURITY_QUALITY_OF_SERVICE", SECURITY_QUALITY_OF_SERVICE.sizeof } + { "SELCHANGE", SELCHANGE.sizeof } + { "SERIALKEYS", SERIALKEYS.sizeof } + { "SERVICE_ADDRESS", SERVICE_ADDRESS.sizeof } + { "SERVICE_ADDRESSES", SERVICE_ADDRESSES.sizeof } + { "SERVICE_INFO", SERVICE_INFO.sizeof } + { "SERVICE_STATUS", SERVICE_STATUS.sizeof } + { "SERVICE_TABLE_ENTRY", SERVICE_TABLE_ENTRY.sizeof } + { "SERVICE_TYPE_INFO_ABS", SERVICE_TYPE_INFO_ABS.sizeof } + { "SERVICE_TYPE_VALUE_ABS", SERVICE_TYPE_VALUE_ABS.sizeof } + { "SESSION_BUFFER", SESSION_BUFFER.sizeof } + { "SESSION_HEADER", SESSION_HEADER.sizeof } + { "SET_PARTITION_INFORMATION", SET_PARTITION_INFORMATION.sizeof } + { "SHACTIVATEINFO", SHACTIVATEINFO.sizeof } + { "SHDRAGIMAGE", SHDRAGIMAGE.sizeof } + { "SHELLEXECUTEINFOA", SHELLEXECUTEINFOA.sizeof } + { "SHELLEXECUTEINFOW", SHELLEXECUTEINFOW.sizeof } + { "SHFILEINFOA", SHFILEINFOA.sizeof } + { "SHFILEINFOW", SHFILEINFOW.sizeof } + { "SHFILEOPSTRUCT", SHFILEOPSTRUCT.sizeof } + { "SHITEMID", SHITEMID.sizeof } + { "SHMENUBARINFO", SHMENUBARINFO.sizeof } + { "SHNAMEMAPPING", SHNAMEMAPPING.sizeof } + { "SHRGINFO", SHRGINFO.sizeof } + { "SID", SID.sizeof } + { "SID_AND_ATTRIBUTES", SID_AND_ATTRIBUTES.sizeof } + { "SID_IDENTIFIER_AUTHORITY", SID_IDENTIFIER_AUTHORITY.sizeof } + { "SINGLE_LIST_ENTRY", SINGLE_LIST_ENTRY.sizeof } + { "SIPINFO", SIPINFO.sizeof } + { "SIZE", SIZE.sizeof } + { "SMALL_RECT", SMALL_RECT.sizeof } + { "SOUNDSENTRY", SOUNDSENTRY.sizeof } + { "STARTUPINFO", STARTUPINFO.sizeof } + { "STICKYKEYS", STICKYKEYS.sizeof } + { "STRRET", STRRET.sizeof } + { "STYLEBUF", STYLEBUF.sizeof } + { "STYLESTRUCT", STYLESTRUCT.sizeof } + { "SYSTEM_AUDIT_ACE", SYSTEM_AUDIT_ACE.sizeof } + { "SYSTEM_INFO", SYSTEM_INFO.sizeof } + { "SYSTEM_INFO_U", SYSTEM_INFO_U.sizeof } + { "SYSTEM_POWER_STATUS", SYSTEM_POWER_STATUS.sizeof } + { "SYSTEMTIME", SYSTEMTIME.sizeof } + { "tagMONITORINFO", tagMONITORINFO.sizeof } + { "tagMONITORINFOEX", tagMONITORINFOEX.sizeof } + { "TAPE_ERASE", TAPE_ERASE.sizeof } + { "TAPE_GET_DRIVE_PARAMETERS", TAPE_GET_DRIVE_PARAMETERS.sizeof } + { "TAPE_GET_MEDIA_PARAMETERS", TAPE_GET_MEDIA_PARAMETERS.sizeof } + { "TAPE_GET_POSITION", TAPE_GET_POSITION.sizeof } + { "TAPE_PREPARE", TAPE_PREPARE.sizeof } + { "TAPE_SET_DRIVE_PARAMETERS", TAPE_SET_DRIVE_PARAMETERS.sizeof } + { "TAPE_SET_MEDIA_PARAMETERS", TAPE_SET_MEDIA_PARAMETERS.sizeof } + { "TAPE_SET_POSITION", TAPE_SET_POSITION.sizeof } + { "TAPE_WRITE_MARKS", TAPE_WRITE_MARKS.sizeof } + { "TBADDBITMAP", TBADDBITMAP.sizeof } + { "TBBUTTON", TBBUTTON.sizeof } + { "TBBUTTONINFOA", TBBUTTONINFOA.sizeof } + { "TBBUTTONINFOW", TBBUTTONINFOW.sizeof } + { "TBNOTIFY", TBNOTIFY.sizeof } + { "TBSAVEPARAMS", TBSAVEPARAMS.sizeof } + { "TC_HITTESTINFO", TC_HITTESTINFO.sizeof } + { "TC_ITEM", TC_ITEM.sizeof } + { "TCITEMA", TCITEMA.sizeof } + { "TC_ITEMHEADER", TC_ITEMHEADER.sizeof } + { "TCITEMW", TCITEMW.sizeof } + { "TC_KEYDOWN", TC_KEYDOWN.sizeof } + { "TEXTMETRICA", TEXTMETRICA.sizeof } + { "TEXTMETRICW", TEXTMETRICW.sizeof } + { "TEXTRANGE", TEXTRANGE.sizeof } + { "TF_DA_COLOR", TF_DA_COLOR.sizeof } + { "TF_DISPLAYATTRIBUTE", TF_DISPLAYATTRIBUTE.sizeof } + { "TFINDTEXT", TFINDTEXT.sizeof } + { "TIME_ZONE_INFORMATION", TIME_ZONE_INFORMATION.sizeof } + { "TOGGLEKEYS", TOGGLEKEYS.sizeof } + { "TOKEN_CONTROL", TOKEN_CONTROL.sizeof } + { "TOKEN_DEFAULT_DACL", TOKEN_DEFAULT_DACL.sizeof } + { "TOKEN_GROUPS", TOKEN_GROUPS.sizeof } + { "TOKEN_OWNER", TOKEN_OWNER.sizeof } + { "TOKEN_PRIMARY_GROUP", TOKEN_PRIMARY_GROUP.sizeof } + { "TOKEN_PRIVILEGES", TOKEN_PRIVILEGES.sizeof } + { "TOKEN_SOURCE", TOKEN_SOURCE.sizeof } + { "TOKEN_STATISTICS", TOKEN_STATISTICS.sizeof } + { "TOKEN_USER", TOKEN_USER.sizeof } + { "TOOLINFOA", TOOLINFOA.sizeof } + { "TOOLINFOW", TOOLINFOW.sizeof } + { "TOOLTIPTEXTA", TOOLTIPTEXTA.sizeof } + { "TOOLTIPTEXTW", TOOLTIPTEXTW.sizeof } + { "TPAGESETUPDLG", TPAGESETUPDLG.sizeof } + { "TPMPARAMS", TPMPARAMS.sizeof } + { "TRACKMOUSEEVENT", TRACKMOUSEEVENT.sizeof } + { "TRANSMIT_FILE_BUFFERS", TRANSMIT_FILE_BUFFERS.sizeof } + { "TREEITEM", TREEITEM.sizeof } + { "TRIVERTEX", TRIVERTEX.sizeof } + { "TSMALLPOINT", TSMALLPOINT.sizeof } + { "TTHITTESTINFO", TTHITTESTINFO.sizeof } + { "TTPOLYCURVE", TTPOLYCURVE.sizeof } + { "TTPOLYGONHEADER", TTPOLYGONHEADER.sizeof } + { "TVARIANT", TVARIANT.sizeof } + { "TV_DISPINFO", TV_DISPINFO.sizeof } + { "TVHITTESTINFO", TVHITTESTINFO.sizeof } + { "TV_HITTESTINFO", TV_HITTESTINFO.sizeof } + { "TVINSERTSTRUCTA", TVINSERTSTRUCTA.sizeof } + { "TVINSERTSTRUCTW", TVINSERTSTRUCTW.sizeof } + { "TVITEMA", TVITEMA.sizeof } + { "TVITEMW", TVITEMW.sizeof } + { "TV_KEYDOWN", TV_KEYDOWN.sizeof } + { "TVSORTCB", TVSORTCB.sizeof } + { "TV_SORTCB", TV_SORTCB.sizeof } + { "TWAVEFORMATEX", TWAVEFORMATEX.sizeof } + { "UDACCEL", UDACCEL.sizeof } + { "UNIVERSAL_NAME_INFO", UNIVERSAL_NAME_INFO.sizeof } + { "UNLOAD_DLL_DEBUG_INFO", UNLOAD_DLL_DEBUG_INFO.sizeof } + { "USER_INFO_0", USER_INFO_0.sizeof } + { "USER_INFO_2", USER_INFO_2.sizeof } + { "USER_INFO_3", USER_INFO_3.sizeof } + { "USEROBJECTFLAGS", USEROBJECTFLAGS.sizeof } + { "VALENT", VALENT.sizeof } + { "VA_LIST", VA_LIST.sizeof } + { "VERIFY_INFORMATION", VERIFY_INFORMATION.sizeof } + { "VS_FIXEDFILEINFO", VS_FIXEDFILEINFO.sizeof } + { "WIN32_FILE_ATTRIBUTE_DATA", WIN32_FILE_ATTRIBUTE_DATA.sizeof } + { "WIN32_FIND_DATA", WIN32_FIND_DATA.sizeof } + { "WIN32_FIND_DATAW", WIN32_FIND_DATAW.sizeof } + { "WIN32_STREAM_ID", WIN32_STREAM_ID.sizeof } + { "WINDOW_BUFFER_SIZE_RECORD", WINDOW_BUFFER_SIZE_RECORD.sizeof } + { "WINDOWINFO", WINDOWINFO.sizeof } + { "WINDOWPLACEMENT", WINDOWPLACEMENT.sizeof } + { "WINDOWPOS", WINDOWPOS.sizeof } + { "WNDCLASSA", WNDCLASSA.sizeof } + { "WNDCLASSEX", WNDCLASSEX.sizeof } + { "WNDCLASSW", WNDCLASSW.sizeof } + { "XFORM", XFORM.sizeof } +]; + +int main( char[][] args ){ + foreach( v; size_values ){ + printf( "%.*s\t%d\n", v.name, v.size ); + } + return 0; +} + + +