R/gdkFuncs.R

Defines functions gdkScreenGetPrimaryMonitor gdkKeymapMapVirtualModifiers gdkKeymapAddVirtualModifiers gdkPixbufSimpleAnimGetLoop gdkPixbufSimpleAnimSetLoop gdkWindowGetRootCoords gdkWindowIsDestroyed gdkWindowRestack gdkWindowGetCursor gdkWindowGeometryChanged gdkWindowFlush gdkWindowEnsureNative gdkRegionRectEqual gdkOffscreenWindowGetEmbedder gdkOffscreenWindowSetEmbedder gdkOffscreenWindowGetPixmap gdkCairoResetClip gdkKeymapGetCapsLockState gdkPixbufSaveToStream gdkTestSimulateButton gdkTestSimulateKey gdkTestRenderSync gdkPixbufNewFromStreamAtScale gdkPixbufNewFromStream gdkWindowRemoveRedirection gdkWindowRedirectToDrawable gdkScreenGetMonitorPlugName gdkScreenGetMonitorHeightMm gdkScreenGetMonitorWidthMm gdkAppLaunchContextSetIconName gdkAppLaunchContextSetIcon gdkAppLaunchContextSetTimestamp gdkAppLaunchContextSetDesktop gdkAppLaunchContextSetScreen gdkAppLaunchContextSetDisplay gdkAppLaunchContextNew gdkAppLaunchContextGetType gdkPixbufApplyEmbeddedOrientation gdkNotifyStartupCompleteWithId gdkWindowSetOpacity gdkWindowBeep gdkWindowSetStartupId gdkWindowSetComposited gdkPangoAttrEmbossColorNew gdkKeymapHaveBidiLayouts gdkEventRequestMotions gdkDisplaySupportsComposite gdkColorToString gdkWindowGetTypeHint gdkWindowMergeChildInputShapes gdkWindowSetChildInputShapes gdkWindowInputShapeCombineRegion gdkWindowInputShapeCombineMask gdkScreenGetWindowStack gdkScreenGetActiveWindow gdkScreenGetResolution gdkScreenSetResolution gdkScreenGetFontOptions gdkScreenSetFontOptions gdkScreenIsComposited gdkAtomInternStaticString gdkDisplaySupportsInputShapes gdkDisplaySupportsShapes gdkCairoSetSourcePixmap gdkRegionSpansIntersectForeach gdkRegionXor gdkRegionSubtract gdkRegionUnion gdkRegionIntersect gdkRegionUnionWithRect gdkRegionShrink gdkRegionOffset gdkRegionRectIn gdkRegionPointIn gdkRegionEqual gdkRegionEmpty gdkRegionGetRectangles gdkRegionGetClipbox gdkRegionRectangle gdkRegionCopy gdkRegionPolygon gdkRegionNew gdkRectangleUnion gdkRectangleIntersect gdkPixbufLoaderGetFormat gdkPixbufLoaderSetSize gdkPixbufLoaderClose gdkPixbufLoaderGetAnimation gdkPixbufLoaderGetPixbuf gdkPixbufLoaderWrite gdkPixbufLoaderNewWithMimeType gdkPixbufLoaderNewWithType gdkPixbufLoaderNew gdkPixbufLoaderGetType gdkPixbufFormatIsWritable gdkPixbufFormatGetExtensions gdkPixbufFormatGetMimeTypes gdkPixbufFormatGetDescription gdkPixbufFormatGetLicense gdkPixbufFormatSetDisabled gdkPixbufFormatIsDisabled gdkPixbufFormatIsScalable gdkPixbufFormatGetName gdkPixbufGetFileInfo gdkPixbufGetFormats gdkPixbufSetOption gdkPixbufGetOption gdkPixbufSimpleAnimAddFrame gdkPixbufSimpleAnimNew gdkPixbufAnimationIterAdvance gdkPixbufAnimationIterOnCurrentlyLoadingFrame gdkPixbufAnimationIterGetPixbuf gdkPixbufAnimationIterGetDelayTime gdkPixbufAnimationIterGetType gdkPixbufAnimationGetIter gdkPixbufAnimationGetStaticImage gdkPixbufAnimationIsStaticImage gdkPixbufAnimationGetHeight gdkPixbufAnimationGetWidth gdkPixbufAnimationNewFromFile gdkPixbufAnimationGetType gdkPixbufCompositeColorSimple gdkPixbufScaleSimple gdkPixbufFlip gdkPixbufRotateSimple gdkPixbufCompositeColor gdkPixbufComposite gdkPixbufScale gdkPixbufSaturateAndPixelate gdkPixbufCopyArea gdkPixbufAddAlpha gdkPixbufSaveToBufferv gdkPixbufSaveToCallbackv gdkPixbufSavev gdkPixbufFill gdkPixbufNewSubpixbuf gdkPixbufNewFromXpmData gdkPixbufNewFromFileAtScale gdkPixbufNewFromFileAtSize gdkPixbufNewFromFile gdkPixbufCopy gdkPixbufNew gdkPixbufGetRowstride gdkPixbufGetHeight gdkPixbufGetWidth gdkPixbufGetPixels gdkPixbufGetBitsPerSample gdkPixbufGetHasAlpha gdkPixbufGetNChannels gdkPixbufGetColorspace gtkDragSetIconDefault gtkDragSetIconStock gtkDragSetIconPixbuf gtkDragSetIconPixmap gtkDragSetIconWidget gtkDragSetIconName gtkDragFinish gdkWindowConfigureFinished gdkWindowEnableSynchronizedConfigure gdkWindowSetFocusOnMap gdkWindowSetAcceptFocus gdkGetDefaultRootWindow gdkWindowGetInternalPaintInfo gdkWindowSetDebugUpdates gdkWindowProcessUpdates gdkWindowProcessAllUpdates gdkWindowThawUpdates gdkWindowFreezeUpdates gdkWindowGetUpdateArea gdkWindowAtPointer gdkWindowGetWindowType gdkWindowDestroy gdkWindowSetKeepBelow gdkWindowSetKeepAbove gdkWindowObjectGetType gdkVisualGetScreen gdkListVisuals gdkQueryVisualTypes gdkQueryDepths gdkVisualGetBestWithBoth gdkVisualGetBestWithType gdkVisualGetBestWithDepth gdkVisualGetBest gdkVisualGetSystem gdkVisualGetBestType gdkVisualGetBestDepth gdkSelectionPropertyGet gdkSelectionOwnerGetForDisplay gdkSelectionOwnerGet gtkAlternativeDialogButtonOrder gdkSpawnCommandLineOnScreen gdkScreenGetSetting gdkScreenGetDefault gdkScreenBroadcastClientMessage gdkScreenGetMonitorAtWindow gdkScreenGetMonitorAtPoint gdkScreenGetMonitorGeometry gdkScreenGetNMonitors gdkScreenMakeDisplayName gdkScreenGetToplevelWindows gdkScreenListVisuals gdkScreenGetHeightMm gdkScreenGetWidthMm gdkScreenGetHeight gdkScreenGetWidth gdkScreenGetNumber gdkScreenGetDisplay gdkScreenGetRootWindow gdkScreenGetRgbaVisual gdkScreenGetRgbVisual gdkScreenGetRgbaColormap gdkScreenGetRgbColormap gdkScreenGetSystemVisual gdkScreenGetSystemColormap gdkScreenSetDefaultColormap gdkScreenGetDefaultColormap gdkScreenGetType gdkRgbGetVisual gdkRgbGetCmap gdkRgbGetColormap gdkRgbSetMinColors gdkRgbSetInstall gdkRgbSetVerbose gdkRgbDitherable gdkDrawIndexedImage gdkRgbCmapNew gdkDrawGrayImage gdkRgbColormapDitherable gdkRgbFindColor gdkDrawRgb32ImageDithalign gdkDrawRgb32Image gdkDrawRgbImageDithalign gdkRgbGcSetBackground gdkRgbGcSetForeground gdkRgbXpixelFromRgb gdkPropertyDelete gdkPropertyChange gdkPropertyGet gdkAtomIntern gdkAtomName gdkPixmapColormapCreateFromXpmD gdkPixmapCreateFromXpmD gdkPixmapColormapCreateFromXpm gdkPixmapCreateFromXpm gdkPixmapCreateFromData gdkPixmapNew gdkPixmapGetType gdkPixbufGetFromImage gdkPixbufGetFromDrawable gdkPixbufRenderPixmapAndMaskForColormap gdkPixbufRenderPixmapAndMask gdkPixbufRenderToDrawableAlpha gdkPixbufRenderToDrawable gdkPixbufRenderThresholdAlpha gdkPangoAttrEmbossedNew gdkPangoAttrStippleNew gdkPangoLayoutGetClipRegion gdkPangoLayoutLineGetClipRegion gdkPangoContextSetColormap gdkPangoContextGet gdkPangoContextGetForScreen gdkPangoRendererSetOverrideColor gdkPangoRendererSetStipple gdkPangoRendererSetGc gdkPangoRendererSetDrawable gdkPangoRendererGetDefault gdkPangoRendererNew gdkPangoRendererGetType gdkUnicodeToKeyval gdkKeyvalToUnicode gdkKeyvalIsLower gdkKeyvalIsUpper gdkKeyvalToLower gdkKeyvalToUpper gdkKeyvalConvertCase gdkKeyvalFromName gdkKeyvalName gdkKeymapGetDirection gdkKeymapGetEntriesForKeycode gdkKeymapGetEntriesForKeyval gdkKeymapTranslateKeyboardState gdkKeymapLookupKey gdkKeymapGetForDisplay gdkKeymapGetDefault gdkKeymapGetType gdkDeviceGetCorePointer gdkInputSetExtensionEvents gdkDeviceGetAxis gdkDeviceGetHistory gdkDeviceGetState gdkDeviceSetAxisUse gdkDeviceSetKey gdkDeviceSetMode gdkDeviceSetSource gdkDevicesList gdkDeviceGetType gdkImageGetColormap gdkImageSetColormap gdkImageGetPixel gdkImagePutPixel gdkImageGet gdkImageNew gdkImageGetType gdkGCGetScreen gdkGCSetRgbBgColor gdkGCSetRgbFgColor gdkGCGetColormap gdkGCSetColormap gdkGCCopy gdkGCOffset gdkGCSetDashes gdkGCSetLineAttributes gdkGCSetExposures gdkGCSetSubwindow gdkGCSetClipRegion gdkGCSetClipRectangle gdkGCSetClipMask gdkGCSetClipOrigin gdkGCSetTsOrigin gdkGCSetStipple gdkGCSetTile gdkGCSetFill gdkGCSetFunction gdkGCSetFont gdkGCSetBackground gdkGCSetForeground gdkGCSetValues gdkGCGetValues gdkGCNewWithValues gdkGCNew gdkGCGetType gdkFontGetDisplay gdkStringExtents gdkTextExtentsWc gdkCharHeight gdkTextHeight gdkStringHeight gdkCharMeasure gdkTextMeasure gdkStringMeasure gdkCharWidthWc gdkCharWidth gdkTextWidthWc gdkTextWidth gdkStringWidth gdkFontFromDescription gdkFontsetLoad gdkFontLoad gdkFontFromDescriptionForDisplay gdkFontsetLoadForDisplay gdkFontLoadForDisplay gdkFontId gdkSettingGet gdkAddClientMessageFilter gdkGetShowEvents gdkSetShowEvents gdkEventGetScreen gdkEventSetScreen gdkEventHandlerSet gdkEventGetAxis gdkDrawableGetDepth gdkDrawableGetVisual gdkDrawableGetColormap gdkDrawableSetColormap gdkDrawableGetSize gdkDrawableGetData gdkDrawableSetData gdkDrawableGetType gdkDragDropSucceeded gdkDragAbort gdkDragDrop gdkDragMotion gdkDragFindWindowForScreen gdkDragGetProtocolForDisplay gdkDragFindWindow gdkDragGetProtocol gdkDragBegin gdkDragGetSelection gdkDropFinish gdkDropReply gdkDragStatus gdkDragContextNew gdkDragContextGetType gdkDisplayGetDefaultGroup gdkDisplayGetMaximalCursorSize gdkDisplayGetDefaultCursorSize gdkDisplaySupportsCursorColor gdkDisplaySupportsCursorAlpha gdkDisplaySetDoubleClickDistance gdkDisplayFlush gdkDisplayManagerListDisplays gdkDisplayManagerSetDefaultDisplay gdkDisplayManagerGetDefaultDisplay gdkDisplayManagerGet gdkDisplayManagerGetType gdkDisplaySupportsClipboardPersistence gdkDisplayRequestSelectionNotification gdkDisplaySupportsSelectionNotification gdkDisplayStoreClipboard gdkDisplayWarpPointer gdkDisplayGetWindowAtPointer gdkDisplayGetPointer gdkDisplayGetCorePointer gdkDisplayGetDefault gdkDisplaySetDoubleClickTime gdkDisplayAddClientMessageFilter gdkDisplayPutEvent gdkDisplayPeekEvent gdkDisplayGetEvent gdkDisplayListDevices gdkDisplayClose gdkDisplaySync gdkDisplayBeep gdkDisplayPointerIsGrabbed gdkDisplayKeyboardUngrab gdkDisplayPointerUngrab gdkDisplayGetDefaultScreen gdkDisplayGetScreen gdkDisplayGetNScreens gdkDisplayGetName gdkDisplayOpen gdkDisplayGetType gdkWindowInvalidateRegion gdkWindowInvalidateRect gdkWindowBeginMoveDrag gdkWindowBeginResizeDrag gdkWindowRegisterDnd gdkWindowUnfullscreen gdkWindowFullscreen gdkWindowUnmaximize gdkWindowMaximize gdkWindowUnstick gdkWindowStick gdkWindowDeiconify gdkWindowIconify gdkWindowGetToplevels gdkWindowSetFunctions gdkWindowGetDecorations gdkWindowSetDecorations gdkWindowGetGroup gdkWindowSetGroup gdkWindowSetIconName gdkWindowSetIcon gdkWindowSetIconList gdkWindowSetEvents gdkWindowGetEvents gdkWindowPeekChildren gdkWindowGetChildren gdkWindowGetToplevel gdkWindowGetParent gdkWindowGetPointer gdkWindowGetFrameExtents gdkWindowGetRootOrigin gdkWindowGetDeskrelativeOrigin gdkWindowGetOrigin gdkWindowGetPosition gdkWindowGetGeometry gdkWindowSetCursor gdkWindowSetBackPixmap gdkWindowSetBackground gdkWindowSetTransientFor gdkWindowSetRole gdkWindowSetTitle gdkWindowEndPaint gdkWindowBeginPaintRegion gdkWindowBeginPaintRect gdkWindowSetGeometryHints gdkWindowSetUrgencyHint gdkWindowSetSkipPagerHint gdkWindowSetSkipTaskbarHint gdkWindowSetModalHint gdkWindowSetTypeHint gdkWindowSetHints gdkWindowSetStaticGravities gdkWindowGetState gdkWindowIsViewable gdkWindowIsVisible gdkWindowMergeChildShapes gdkWindowSetChildShapes gdkWindowShapeCombineRegion gdkWindowShapeCombineMask gdkWindowScroll gdkWindowRemoveFilter gdkWindowAddFilter gdkWindowSetOverrideRedirect gdkWindowGetUserData gdkWindowSetUserData gdkWindowFocus gdkWindowLower gdkWindowRaise gdkWindowClearAreaE gdkWindowClearArea gdkWindowClear gdkWindowReparent gdkWindowMoveRegion gdkWindowMoveResize gdkWindowResize gdkWindowMove gdkWindowWithdraw gdkWindowHide gdkWindowShowUnraised gdkWindowShow gdkEventGetRootCoords gdkEventGetCoords gdkEventGetState gdkEventGetTime gdkEventCopy gdkEventNew gdkEventPut gdkEventGetGraphicsExpose gdkEventPeek gdkEventGet gdkEventsPending gdkEventGetType gdkDrawableGetVisibleRegion gdkDrawableGetClipRegion gdkDrawableCopyToImage gdkDrawableGetImage gdkDrawTrapezoids gdkDrawGlyphsTransformed gdkDrawLayoutWithColors gdkDrawLayoutLineWithColors gdkDrawLayout gdkDrawLayoutLine gdkDrawGlyphs gdkDrawPixbuf gdkDrawLines gdkDrawSegments gdkDrawPoints gdkDrawImage gdkDrawDrawable gdkDrawTextWc gdkDrawText gdkDrawString gdkDrawPolygon gdkDrawArc gdkDrawRectangle gdkDrawLine gdkDrawPoint gdkDrawableGetDisplay gdkDrawableGetScreen gdkCursorGetImage gdkCursorGetDisplay gdkCursorNewFromPixbuf gdkCursorNewFromPixmap gdkCursorNewForDisplay gdkCursorNewFromName gdkCursorNew gdkColorChange gdkColorAlloc gdkColorBlack gdkColorWhite gdkColorParse gdkColormapGetScreen gdkColormapGetVisual gdkColormapQueryColor gdkColormapFreeColors gdkColormapAllocColor gdkColormapGetSystemSize gdkColormapGetSystem gdkColormapNew gdkColormapGetType gdkCairoRegion gdkCairoRectangle gdkCairoSetSourcePixbuf gdkCairoSetSourceColor gdkCairoCreate gdkSetDoubleClickTime gdkBeep gdkFlush gdkScreenHeightMm gdkScreenWidthMm gdkScreenHeight gdkScreenWidth gdkPointerIsGrabbed gdkKeyboardUngrab gdkKeyboardGrab gdkPointerUngrab gdkPointerGrab gdkGetDisplay gdkSetProgramClass gdkGetProgramClass gdkNotifyStartupComplete

Documented in gdkAddClientMessageFilter gdkAppLaunchContextGetType gdkAppLaunchContextNew gdkAppLaunchContextSetDesktop gdkAppLaunchContextSetDisplay gdkAppLaunchContextSetIcon gdkAppLaunchContextSetIconName gdkAppLaunchContextSetScreen gdkAppLaunchContextSetTimestamp gdkAtomIntern gdkAtomInternStaticString gdkAtomName gdkBeep gdkCairoCreate gdkCairoRectangle gdkCairoRegion gdkCairoResetClip gdkCairoSetSourceColor gdkCairoSetSourcePixbuf gdkCairoSetSourcePixmap gdkCharHeight gdkCharMeasure gdkCharWidth gdkCharWidthWc gdkColorAlloc gdkColorBlack gdkColorChange gdkColormapAllocColor gdkColormapFreeColors gdkColormapGetScreen gdkColormapGetSystem gdkColormapGetSystemSize gdkColormapGetType gdkColormapGetVisual gdkColormapNew gdkColormapQueryColor gdkColorParse gdkColorToString gdkColorWhite gdkCursorGetDisplay gdkCursorGetImage gdkCursorNew gdkCursorNewForDisplay gdkCursorNewFromName gdkCursorNewFromPixbuf gdkCursorNewFromPixmap gdkDeviceGetAxis gdkDeviceGetCorePointer gdkDeviceGetHistory gdkDeviceGetState gdkDeviceGetType gdkDeviceSetAxisUse gdkDeviceSetKey gdkDeviceSetMode gdkDeviceSetSource gdkDevicesList gdkDisplayAddClientMessageFilter gdkDisplayBeep gdkDisplayClose gdkDisplayFlush gdkDisplayGetCorePointer gdkDisplayGetDefault gdkDisplayGetDefaultCursorSize gdkDisplayGetDefaultGroup gdkDisplayGetDefaultScreen gdkDisplayGetEvent gdkDisplayGetMaximalCursorSize gdkDisplayGetName gdkDisplayGetNScreens gdkDisplayGetPointer gdkDisplayGetScreen gdkDisplayGetType gdkDisplayGetWindowAtPointer gdkDisplayKeyboardUngrab gdkDisplayListDevices gdkDisplayManagerGet gdkDisplayManagerGetDefaultDisplay gdkDisplayManagerGetType gdkDisplayManagerListDisplays gdkDisplayManagerSetDefaultDisplay gdkDisplayOpen gdkDisplayPeekEvent gdkDisplayPointerIsGrabbed gdkDisplayPointerUngrab gdkDisplayPutEvent gdkDisplayRequestSelectionNotification gdkDisplaySetDoubleClickDistance gdkDisplaySetDoubleClickTime gdkDisplayStoreClipboard gdkDisplaySupportsClipboardPersistence gdkDisplaySupportsComposite gdkDisplaySupportsCursorAlpha gdkDisplaySupportsCursorColor gdkDisplaySupportsInputShapes gdkDisplaySupportsSelectionNotification gdkDisplaySupportsShapes gdkDisplaySync gdkDisplayWarpPointer gdkDragAbort gdkDragBegin gdkDragContextGetType gdkDragContextNew gdkDragDrop gdkDragDropSucceeded gdkDragFindWindow gdkDragFindWindowForScreen gdkDragGetProtocol gdkDragGetProtocolForDisplay gdkDragGetSelection gdkDragMotion gdkDragStatus gdkDrawableCopyToImage gdkDrawableGetClipRegion gdkDrawableGetColormap gdkDrawableGetData gdkDrawableGetDepth gdkDrawableGetDisplay gdkDrawableGetImage gdkDrawableGetScreen gdkDrawableGetSize gdkDrawableGetType gdkDrawableGetVisibleRegion gdkDrawableGetVisual gdkDrawableSetColormap gdkDrawableSetData gdkDrawArc gdkDrawDrawable gdkDrawGlyphs gdkDrawGlyphsTransformed gdkDrawGrayImage gdkDrawImage gdkDrawIndexedImage gdkDrawLayout gdkDrawLayoutLine gdkDrawLayoutLineWithColors gdkDrawLayoutWithColors gdkDrawLine gdkDrawLines gdkDrawPixbuf gdkDrawPoint gdkDrawPoints gdkDrawPolygon gdkDrawRectangle gdkDrawRgb32Image gdkDrawRgb32ImageDithalign gdkDrawRgbImageDithalign gdkDrawSegments gdkDrawString gdkDrawText gdkDrawTextWc gdkDrawTrapezoids gdkDropFinish gdkDropReply gdkEventCopy gdkEventGet gdkEventGetAxis gdkEventGetCoords gdkEventGetGraphicsExpose gdkEventGetRootCoords gdkEventGetScreen gdkEventGetState gdkEventGetTime gdkEventGetType gdkEventHandlerSet gdkEventNew gdkEventPeek gdkEventPut gdkEventRequestMotions gdkEventSetScreen gdkEventsPending gdkFlush gdkFontFromDescription gdkFontFromDescriptionForDisplay gdkFontGetDisplay gdkFontId gdkFontLoad gdkFontLoadForDisplay gdkFontsetLoad gdkFontsetLoadForDisplay gdkGCCopy gdkGCGetColormap gdkGCGetScreen gdkGCGetType gdkGCGetValues gdkGCNew gdkGCNewWithValues gdkGCOffset gdkGCSetBackground gdkGCSetClipMask gdkGCSetClipOrigin gdkGCSetClipRectangle gdkGCSetClipRegion gdkGCSetColormap gdkGCSetDashes gdkGCSetExposures gdkGCSetFill gdkGCSetFont gdkGCSetForeground gdkGCSetFunction gdkGCSetLineAttributes gdkGCSetRgbBgColor gdkGCSetRgbFgColor gdkGCSetStipple gdkGCSetSubwindow gdkGCSetTile gdkGCSetTsOrigin gdkGCSetValues gdkGetDefaultRootWindow gdkGetDisplay gdkGetProgramClass gdkGetShowEvents gdkImageGet gdkImageGetColormap gdkImageGetPixel gdkImageGetType gdkImageNew gdkImagePutPixel gdkImageSetColormap gdkInputSetExtensionEvents gdkKeyboardGrab gdkKeyboardUngrab gdkKeymapAddVirtualModifiers gdkKeymapGetCapsLockState gdkKeymapGetDefault gdkKeymapGetDirection gdkKeymapGetEntriesForKeycode gdkKeymapGetEntriesForKeyval gdkKeymapGetForDisplay gdkKeymapGetType gdkKeymapHaveBidiLayouts gdkKeymapLookupKey gdkKeymapMapVirtualModifiers gdkKeymapTranslateKeyboardState gdkKeyvalConvertCase gdkKeyvalFromName gdkKeyvalIsLower gdkKeyvalIsUpper gdkKeyvalName gdkKeyvalToLower gdkKeyvalToUnicode gdkKeyvalToUpper gdkListVisuals gdkNotifyStartupComplete gdkNotifyStartupCompleteWithId gdkOffscreenWindowGetEmbedder gdkOffscreenWindowGetPixmap gdkOffscreenWindowSetEmbedder gdkPangoAttrEmbossColorNew gdkPangoAttrEmbossedNew gdkPangoAttrStippleNew gdkPangoContextGet gdkPangoContextGetForScreen gdkPangoContextSetColormap gdkPangoLayoutGetClipRegion gdkPangoLayoutLineGetClipRegion gdkPangoRendererGetDefault gdkPangoRendererGetType gdkPangoRendererNew gdkPangoRendererSetDrawable gdkPangoRendererSetGc gdkPangoRendererSetOverrideColor gdkPangoRendererSetStipple gdkPixbufAddAlpha gdkPixbufAnimationGetHeight gdkPixbufAnimationGetIter gdkPixbufAnimationGetStaticImage gdkPixbufAnimationGetType gdkPixbufAnimationGetWidth gdkPixbufAnimationIsStaticImage gdkPixbufAnimationIterAdvance gdkPixbufAnimationIterGetDelayTime gdkPixbufAnimationIterGetPixbuf gdkPixbufAnimationIterGetType gdkPixbufAnimationIterOnCurrentlyLoadingFrame gdkPixbufAnimationNewFromFile gdkPixbufApplyEmbeddedOrientation gdkPixbufComposite gdkPixbufCompositeColor gdkPixbufCompositeColorSimple gdkPixbufCopy gdkPixbufCopyArea gdkPixbufFill gdkPixbufFlip gdkPixbufFormatGetDescription gdkPixbufFormatGetExtensions gdkPixbufFormatGetLicense gdkPixbufFormatGetMimeTypes gdkPixbufFormatGetName gdkPixbufFormatIsDisabled gdkPixbufFormatIsScalable gdkPixbufFormatIsWritable gdkPixbufFormatSetDisabled gdkPixbufGetBitsPerSample gdkPixbufGetColorspace gdkPixbufGetFileInfo gdkPixbufGetFormats gdkPixbufGetFromDrawable gdkPixbufGetFromImage gdkPixbufGetHasAlpha gdkPixbufGetHeight gdkPixbufGetNChannels gdkPixbufGetOption gdkPixbufGetPixels gdkPixbufGetRowstride gdkPixbufGetWidth gdkPixbufLoaderClose gdkPixbufLoaderGetAnimation gdkPixbufLoaderGetFormat gdkPixbufLoaderGetPixbuf gdkPixbufLoaderGetType gdkPixbufLoaderNew gdkPixbufLoaderNewWithMimeType gdkPixbufLoaderNewWithType gdkPixbufLoaderSetSize gdkPixbufLoaderWrite gdkPixbufNew gdkPixbufNewFromFile gdkPixbufNewFromFileAtScale gdkPixbufNewFromFileAtSize gdkPixbufNewFromStream gdkPixbufNewFromStreamAtScale gdkPixbufNewFromXpmData gdkPixbufNewSubpixbuf gdkPixbufRenderPixmapAndMask gdkPixbufRenderPixmapAndMaskForColormap gdkPixbufRenderThresholdAlpha gdkPixbufRenderToDrawable gdkPixbufRenderToDrawableAlpha gdkPixbufRotateSimple gdkPixbufSaturateAndPixelate gdkPixbufSaveToBufferv gdkPixbufSaveToCallbackv gdkPixbufSaveToStream gdkPixbufSavev gdkPixbufScale gdkPixbufScaleSimple gdkPixbufSetOption gdkPixbufSimpleAnimAddFrame gdkPixbufSimpleAnimGetLoop gdkPixbufSimpleAnimNew gdkPixbufSimpleAnimSetLoop gdkPixmapColormapCreateFromXpm gdkPixmapColormapCreateFromXpmD gdkPixmapCreateFromData gdkPixmapCreateFromXpm gdkPixmapCreateFromXpmD gdkPixmapGetType gdkPixmapNew gdkPointerGrab gdkPointerIsGrabbed gdkPointerUngrab gdkPropertyChange gdkPropertyDelete gdkPropertyGet gdkQueryDepths gdkQueryVisualTypes gdkRectangleIntersect gdkRectangleUnion gdkRegionCopy gdkRegionEmpty gdkRegionEqual gdkRegionGetClipbox gdkRegionGetRectangles gdkRegionIntersect gdkRegionNew gdkRegionOffset gdkRegionPointIn gdkRegionPolygon gdkRegionRectangle gdkRegionRectEqual gdkRegionRectIn gdkRegionShrink gdkRegionSpansIntersectForeach gdkRegionSubtract gdkRegionUnion gdkRegionUnionWithRect gdkRegionXor gdkRgbCmapNew gdkRgbColormapDitherable gdkRgbDitherable gdkRgbFindColor gdkRgbGcSetBackground gdkRgbGcSetForeground gdkRgbGetCmap gdkRgbGetColormap gdkRgbGetVisual gdkRgbSetInstall gdkRgbSetMinColors gdkRgbSetVerbose gdkRgbXpixelFromRgb gdkScreenBroadcastClientMessage gdkScreenGetActiveWindow gdkScreenGetDefault gdkScreenGetDefaultColormap gdkScreenGetDisplay gdkScreenGetFontOptions gdkScreenGetHeight gdkScreenGetHeightMm gdkScreenGetMonitorAtPoint gdkScreenGetMonitorAtWindow gdkScreenGetMonitorGeometry gdkScreenGetMonitorHeightMm gdkScreenGetMonitorPlugName gdkScreenGetMonitorWidthMm gdkScreenGetNMonitors gdkScreenGetNumber gdkScreenGetPrimaryMonitor gdkScreenGetResolution gdkScreenGetRgbaColormap gdkScreenGetRgbaVisual gdkScreenGetRgbColormap gdkScreenGetRgbVisual gdkScreenGetRootWindow gdkScreenGetSetting gdkScreenGetSystemColormap gdkScreenGetSystemVisual gdkScreenGetToplevelWindows gdkScreenGetType gdkScreenGetWidth gdkScreenGetWidthMm gdkScreenGetWindowStack gdkScreenHeight gdkScreenHeightMm gdkScreenIsComposited gdkScreenListVisuals gdkScreenMakeDisplayName gdkScreenSetDefaultColormap gdkScreenSetFontOptions gdkScreenSetResolution gdkScreenWidth gdkScreenWidthMm gdkSelectionOwnerGet gdkSelectionOwnerGetForDisplay gdkSelectionPropertyGet gdkSetDoubleClickTime gdkSetProgramClass gdkSetShowEvents gdkSettingGet gdkSpawnCommandLineOnScreen gdkStringExtents gdkStringHeight gdkStringMeasure gdkStringWidth gdkTestRenderSync gdkTestSimulateButton gdkTestSimulateKey gdkTextExtentsWc gdkTextHeight gdkTextMeasure gdkTextWidth gdkTextWidthWc gdkUnicodeToKeyval gdkVisualGetBest gdkVisualGetBestDepth gdkVisualGetBestType gdkVisualGetBestWithBoth gdkVisualGetBestWithDepth gdkVisualGetBestWithType gdkVisualGetScreen gdkVisualGetSystem gdkWindowAddFilter gdkWindowAtPointer gdkWindowBeep gdkWindowBeginMoveDrag gdkWindowBeginPaintRect gdkWindowBeginPaintRegion gdkWindowBeginResizeDrag gdkWindowClear gdkWindowClearArea gdkWindowClearAreaE gdkWindowConfigureFinished gdkWindowDeiconify gdkWindowDestroy gdkWindowEnableSynchronizedConfigure gdkWindowEndPaint gdkWindowEnsureNative gdkWindowFlush gdkWindowFocus gdkWindowFreezeUpdates gdkWindowFullscreen gdkWindowGeometryChanged gdkWindowGetChildren gdkWindowGetCursor gdkWindowGetDecorations gdkWindowGetDeskrelativeOrigin gdkWindowGetEvents gdkWindowGetFrameExtents gdkWindowGetGeometry gdkWindowGetGroup gdkWindowGetInternalPaintInfo gdkWindowGetOrigin gdkWindowGetParent gdkWindowGetPointer gdkWindowGetPosition gdkWindowGetRootCoords gdkWindowGetRootOrigin gdkWindowGetState gdkWindowGetToplevel gdkWindowGetToplevels gdkWindowGetTypeHint gdkWindowGetUpdateArea gdkWindowGetUserData gdkWindowGetWindowType gdkWindowHide gdkWindowIconify gdkWindowInputShapeCombineMask gdkWindowInputShapeCombineRegion gdkWindowInvalidateRect gdkWindowInvalidateRegion gdkWindowIsDestroyed gdkWindowIsViewable gdkWindowIsVisible gdkWindowLower gdkWindowMaximize gdkWindowMergeChildInputShapes gdkWindowMergeChildShapes gdkWindowMove gdkWindowMoveRegion gdkWindowMoveResize gdkWindowObjectGetType gdkWindowPeekChildren gdkWindowProcessAllUpdates gdkWindowProcessUpdates gdkWindowRaise gdkWindowRedirectToDrawable gdkWindowRegisterDnd gdkWindowRemoveFilter gdkWindowRemoveRedirection gdkWindowReparent gdkWindowResize gdkWindowRestack gdkWindowScroll gdkWindowSetAcceptFocus gdkWindowSetBackground gdkWindowSetBackPixmap gdkWindowSetChildInputShapes gdkWindowSetChildShapes gdkWindowSetComposited gdkWindowSetCursor gdkWindowSetDebugUpdates gdkWindowSetDecorations gdkWindowSetEvents gdkWindowSetFocusOnMap gdkWindowSetFunctions gdkWindowSetGeometryHints gdkWindowSetGroup gdkWindowSetHints gdkWindowSetIcon gdkWindowSetIconList gdkWindowSetIconName gdkWindowSetKeepAbove gdkWindowSetKeepBelow gdkWindowSetModalHint gdkWindowSetOpacity gdkWindowSetOverrideRedirect gdkWindowSetRole gdkWindowSetSkipPagerHint gdkWindowSetSkipTaskbarHint gdkWindowSetStartupId gdkWindowSetStaticGravities gdkWindowSetTitle gdkWindowSetTransientFor gdkWindowSetTypeHint gdkWindowSetUrgencyHint gdkWindowSetUserData gdkWindowShapeCombineMask gdkWindowShapeCombineRegion gdkWindowShow gdkWindowShowUnraised gdkWindowStick gdkWindowThawUpdates gdkWindowUnfullscreen gdkWindowUnmaximize gdkWindowUnstick gdkWindowWithdraw gtkAlternativeDialogButtonOrder gtkDragFinish gtkDragSetIconDefault gtkDragSetIconName gtkDragSetIconPixbuf gtkDragSetIconPixmap gtkDragSetIconStock gtkDragSetIconWidget

gdkNotifyStartupComplete <-
function()
{
  

  w <- .RGtkCall("S_gdk_notify_startup_complete", PACKAGE = "RGtk2")

  return(w)
} 


gdkGetProgramClass <-
function()
{
  

  w <- .RGtkCall("S_gdk_get_program_class", PACKAGE = "RGtk2")

  return(w)
} 


gdkSetProgramClass <-
function(program.class)
{
  program.class <- as.character(program.class)

  w <- .RGtkCall("S_gdk_set_program_class", program.class, PACKAGE = "RGtk2")

  return(w)
} 


gdkGetDisplay <-
function()
{
  

  w <- .RGtkCall("S_gdk_get_display", PACKAGE = "RGtk2")

  return(w)
} 


gdkPointerGrab <-
function(window, owner.events = FALSE, event.mask = 0, confine.to = NULL, cursor = NULL, time = "GDK_CURRENT_TIME")
{
  checkPtrType(window, "GdkWindow")
  owner.events <- as.logical(owner.events)
  
  if (!is.null( confine.to )) checkPtrType(confine.to, "GdkWindow")
  if (!is.null( cursor )) checkPtrType(cursor, "GdkCursor")
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_pointer_grab", window, owner.events, event.mask, confine.to, cursor, time, PACKAGE = "RGtk2")

  return(w)
} 


gdkPointerUngrab <-
function(time = "GDK_CURRENT_TIME")
{
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_pointer_ungrab", time, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyboardGrab <-
function(window, owner.events = FALSE, time = "GDK_CURRENT_TIME")
{
  checkPtrType(window, "GdkWindow")
  owner.events <- as.logical(owner.events)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_keyboard_grab", window, owner.events, time, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyboardUngrab <-
function(time = "GDK_CURRENT_TIME")
{
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_keyboard_ungrab", time, PACKAGE = "RGtk2")

  return(w)
} 


gdkPointerIsGrabbed <-
function()
{
  

  w <- .RGtkCall("S_gdk_pointer_is_grabbed", PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenWidth <-
function()
{
  

  w <- .RGtkCall("S_gdk_screen_width", PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenHeight <-
function()
{
  

  w <- .RGtkCall("S_gdk_screen_height", PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenWidthMm <-
function()
{
  

  w <- .RGtkCall("S_gdk_screen_width_mm", PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenHeightMm <-
function()
{
  

  w <- .RGtkCall("S_gdk_screen_height_mm", PACKAGE = "RGtk2")

  return(w)
} 


gdkFlush <-
function()
{
  

  w <- .RGtkCall("S_gdk_flush", PACKAGE = "RGtk2")

  return(w)
} 


gdkBeep <-
function()
{
  

  w <- .RGtkCall("S_gdk_beep", PACKAGE = "RGtk2")

  return(w)
} 


gdkSetDoubleClickTime <-
function(msec)
{
  msec <- as.numeric(msec)

  w <- .RGtkCall("S_gdk_set_double_click_time", msec, PACKAGE = "RGtk2")

  return(w)
} 


gdkCairoCreate <-
function(drawable)
{
  checkPtrType(drawable, "GdkDrawable")

  w <- .RGtkCall("S_gdk_cairo_create", drawable, PACKAGE = "RGtk2")

  return(w)
} 


gdkCairoSetSourceColor <-
function(cr, color)
{
  checkPtrType(cr, "Cairo")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_cairo_set_source_color", cr, color, PACKAGE = "RGtk2")

  return(w)
} 


gdkCairoSetSourcePixbuf <-
function(cr, pixbuf, pixbuf.x, pixbuf.y)
{
  checkPtrType(cr, "Cairo")
  checkPtrType(pixbuf, "GdkPixbuf")
  pixbuf.x <- as.numeric(pixbuf.x)
  pixbuf.y <- as.numeric(pixbuf.y)

  w <- .RGtkCall("S_gdk_cairo_set_source_pixbuf", cr, pixbuf, pixbuf.x, pixbuf.y, PACKAGE = "RGtk2")

  return(w)
} 


gdkCairoRectangle <-
function(cr, rectangle)
{
  checkPtrType(cr, "Cairo")
  rectangle <- as.GdkRectangle(rectangle)

  w <- .RGtkCall("S_gdk_cairo_rectangle", cr, rectangle, PACKAGE = "RGtk2")

  return(w)
} 


gdkCairoRegion <-
function(cr, region)
{
  checkPtrType(cr, "Cairo")
  checkPtrType(region, "GdkRegion")

  w <- .RGtkCall("S_gdk_cairo_region", cr, region, PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_colormap_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapNew <-
function(visual, allocate)
{
  checkPtrType(visual, "GdkVisual")
  allocate <- as.logical(allocate)

  w <- .RGtkCall("S_gdk_colormap_new", visual, allocate, PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapGetSystem <-
function()
{
  

  w <- .RGtkCall("S_gdk_colormap_get_system", PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapGetSystemSize <-
function()
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  

  w <- .RGtkCall("S_gdk_colormap_get_system_size", PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapAllocColor <-
function(object, color, writeable, best.match)
{
  checkPtrType(object, "GdkColormap")
  color <- as.GdkColor(color)
  writeable <- as.logical(writeable)
  best.match <- as.logical(best.match)

  w <- .RGtkCall("S_gdk_colormap_alloc_color", object, color, writeable, best.match, PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapFreeColors <-
function(object, colors)
{
  checkPtrType(object, "GdkColormap")
  colors <- lapply(colors, function(x) { x <- as.GdkColor(x); x })

  w <- .RGtkCall("S_gdk_colormap_free_colors", object, colors, PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapQueryColor <-
function(object, pixel)
{
  checkPtrType(object, "GdkColormap")
  pixel <- as.numeric(pixel)

  w <- .RGtkCall("S_gdk_colormap_query_color", object, pixel, PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapGetVisual <-
function(object)
{
  checkPtrType(object, "GdkColormap")

  w <- .RGtkCall("S_gdk_colormap_get_visual", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkColormapGetScreen <-
function(object)
{
  checkPtrType(object, "GdkColormap")

  w <- .RGtkCall("S_gdk_colormap_get_screen", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkColorParse <-
function(spec)
{
  spec <- as.character(spec)

  w <- .RGtkCall("S_gdk_color_parse", spec, PACKAGE = "RGtk2")

  return(w)
} 


gdkColorWhite <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GdkColormap")

  w <- .RGtkCall("S_gdk_color_white", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkColorBlack <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GdkColormap")

  w <- .RGtkCall("S_gdk_color_black", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkColorAlloc <-
function(object, color)
{
  if(getOption("depwarn"))
    .Deprecated("gdkColormapAllocColor", "RGtk2")

  checkPtrType(object, "GdkColormap")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_color_alloc", object, color, PACKAGE = "RGtk2")

  return(w)
} 


gdkColorChange <-
function(object, color)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GdkColormap")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_color_change", object, color, PACKAGE = "RGtk2")

  return(w)
} 


gdkCursorNew <-
function(cursor.type)
{
  

  w <- .RGtkCall("S_gdk_cursor_new", cursor.type, PACKAGE = "RGtk2")

  return(w)
} 


gdkCursorNewFromName <-
function(display, name)
{
  checkPtrType(display, "GdkDisplay")
  name <- as.character(name)

  w <- .RGtkCall("S_gdk_cursor_new_from_name", display, name, PACKAGE = "RGtk2")

  return(w)
} 


gdkCursorNewForDisplay <-
function(display, cursor.type)
{
  checkPtrType(display, "GdkDisplay")
  

  w <- .RGtkCall("S_gdk_cursor_new_for_display", display, cursor.type, PACKAGE = "RGtk2")

  return(w)
} 


gdkCursorNewFromPixmap <-
function(source, mask, fg, bg, x, y)
{
  checkPtrType(source, "GdkPixmap")
  checkPtrType(mask, "GdkPixmap")
  fg <- as.GdkColor(fg)
  bg <- as.GdkColor(bg)
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_cursor_new_from_pixmap", source, mask, fg, bg, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gdkCursorNewFromPixbuf <-
function(display, source, x, y)
{
  checkPtrType(display, "GdkDisplay")
  checkPtrType(source, "GdkPixbuf")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_cursor_new_from_pixbuf", display, source, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gdkCursorGetDisplay <-
function(object)
{
  checkPtrType(object, "GdkCursor")

  w <- .RGtkCall("S_gdk_cursor_get_display", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkCursorGetImage <-
function(object)
{
  checkPtrType(object, "GdkCursor")

  w <- .RGtkCall("S_gdk_cursor_get_image", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_display_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayOpen <-
function(display.name)
{
  display.name <- as.character(display.name)

  w <- .RGtkCall("S_gdk_display_open", display.name, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetName <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetNScreens <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_n_screens", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetScreen <-
function(object, screen.num)
{
  checkPtrType(object, "GdkDisplay")
  screen.num <- as.integer(screen.num)

  w <- .RGtkCall("S_gdk_display_get_screen", object, screen.num, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetDefaultScreen <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_default_screen", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayPointerUngrab <-
function(object, time. = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GdkDisplay")
  time. <- as.numeric(time.)

  w <- .RGtkCall("S_gdk_display_pointer_ungrab", object, time., PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayKeyboardUngrab <-
function(object, time. = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GdkDisplay")
  time. <- as.numeric(time.)

  w <- .RGtkCall("S_gdk_display_keyboard_ungrab", object, time., PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayPointerIsGrabbed <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_pointer_is_grabbed", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayBeep <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_beep", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplaySync <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_sync", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayClose <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_close", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayListDevices <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_list_devices", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetEvent <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_event", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayPeekEvent <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_peek_event", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayPutEvent <-
function(object, event)
{
  checkPtrType(object, "GdkDisplay")
  checkPtrType(event, "GdkEvent")

  w <- .RGtkCall("S_gdk_display_put_event", object, event, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayAddClientMessageFilter <-
function(object, message.type, func, data)
{
  checkPtrType(object, "GdkDisplay")
  message.type <- as.GdkAtom(message.type)
  func <- as.function(func)
  

  w <- .RGtkCall("S_gdk_display_add_client_message_filter", object, message.type, func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplaySetDoubleClickTime <-
function(object, msec)
{
  checkPtrType(object, "GdkDisplay")
  msec <- as.numeric(msec)

  w <- .RGtkCall("S_gdk_display_set_double_click_time", object, msec, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayGetDefault <-
function()
{
  

  w <- .RGtkCall("S_gdk_display_get_default", PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetCorePointer <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_core_pointer", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetPointer <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_pointer", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayGetWindowAtPointer <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_window_at_pointer", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayWarpPointer <-
function(object, screen, x, y)
{
  checkPtrType(object, "GdkDisplay")
  checkPtrType(screen, "GdkScreen")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_display_warp_pointer", object, screen, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayStoreClipboard <-
function(object, clipboard.window, targets)
{
  checkPtrType(object, "GdkDisplay")
  checkPtrType(clipboard.window, "GdkWindow")
  targets <- lapply(targets, function(x) { x <- as.GdkAtom(x); x })

  w <- .RGtkCall("S_gdk_display_store_clipboard", object, clipboard.window, targets, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplaySupportsSelectionNotification <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_supports_selection_notification", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayRequestSelectionNotification <-
function(object, selection)
{
  checkPtrType(object, "GdkDisplay")
  selection <- as.GdkAtom(selection)

  w <- .RGtkCall("S_gdk_display_request_selection_notification", object, selection, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplaySupportsClipboardPersistence <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_supports_clipboard_persistence", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayManagerGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_display_manager_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayManagerGet <-
function()
{
  

  w <- .RGtkCall("S_gdk_display_manager_get", PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayManagerGetDefaultDisplay <-
function(object)
{
  checkPtrType(object, "GdkDisplayManager")

  w <- .RGtkCall("S_gdk_display_manager_get_default_display", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayManagerSetDefaultDisplay <-
function(object, display)
{
  checkPtrType(object, "GdkDisplayManager")
  checkPtrType(display, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_manager_set_default_display", object, display, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayManagerListDisplays <-
function(object)
{
  checkPtrType(object, "GdkDisplayManager")

  w <- .RGtkCall("S_gdk_display_manager_list_displays", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayFlush <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_flush", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplaySetDoubleClickDistance <-
function(object, distance)
{
  checkPtrType(object, "GdkDisplay")
  distance <- as.numeric(distance)

  w <- .RGtkCall("S_gdk_display_set_double_click_distance", object, distance, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplaySupportsCursorAlpha <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_supports_cursor_alpha", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplaySupportsCursorColor <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_supports_cursor_color", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetDefaultCursorSize <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_default_cursor_size", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDisplayGetMaximalCursorSize <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_maximal_cursor_size", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDisplayGetDefaultGroup <-
function(object)
{
  checkPtrType(object, "GdkDisplay")

  w <- .RGtkCall("S_gdk_display_get_default_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDragContextGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_drag_context_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkDragContextNew <-
function()
{
  

  w <- .RGtkCall("S_gdk_drag_context_new", PACKAGE = "RGtk2")

  return(w)
} 


gdkDragStatus <-
function(object, action, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GdkDragContext")
  
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_drag_status", object, action, time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDropReply <-
function(object, ok, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GdkDragContext")
  ok <- as.logical(ok)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_drop_reply", object, ok, time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDropFinish <-
function(object, success, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GdkDragContext")
  success <- as.logical(success)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_drop_finish", object, success, time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDragGetSelection <-
function(object)
{
  checkPtrType(object, "GdkDragContext")

  w <- .RGtkCall("S_gdk_drag_get_selection", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDragBegin <-
function(object, targets)
{
  checkPtrType(object, "GdkWindow")
  targets <- as.GList(targets)

  w <- .RGtkCall("S_gdk_drag_begin", object, targets, PACKAGE = "RGtk2")

  return(w)
} 


gdkDragGetProtocol <-
function(xid)
{
  xid <- as.GdkNativeWindow(xid)

  w <- .RGtkCall("S_gdk_drag_get_protocol", xid, PACKAGE = "RGtk2")

  return(w)
} 


gdkDragFindWindow <-
function(object, drag.window, x.root, y.root)
{
  checkPtrType(object, "GdkDragContext")
  checkPtrType(drag.window, "GdkWindow")
  x.root <- as.integer(x.root)
  y.root <- as.integer(y.root)

  w <- .RGtkCall("S_gdk_drag_find_window", object, drag.window, x.root, y.root, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDragGetProtocolForDisplay <-
function(display, xid)
{
  checkPtrType(display, "GdkDisplay")
  xid <- as.GdkNativeWindow(xid)

  w <- .RGtkCall("S_gdk_drag_get_protocol_for_display", display, xid, PACKAGE = "RGtk2")

  return(w)
} 


gdkDragFindWindowForScreen <-
function(object, drag.window, screen, x.root, y.root)
{
  checkPtrType(object, "GdkDragContext")
  checkPtrType(drag.window, "GdkWindow")
  checkPtrType(screen, "GdkScreen")
  x.root <- as.integer(x.root)
  y.root <- as.integer(y.root)

  w <- .RGtkCall("S_gdk_drag_find_window_for_screen", object, drag.window, screen, x.root, y.root, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDragMotion <-
function(object, dest.window, protocol, x.root, y.root, suggested.action, possible.actions, time)
{
  checkPtrType(object, "GdkDragContext")
  checkPtrType(dest.window, "GdkWindow")
  
  x.root <- as.integer(x.root)
  y.root <- as.integer(y.root)
  
  
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_drag_motion", object, dest.window, protocol, x.root, y.root, suggested.action, possible.actions, time, PACKAGE = "RGtk2")

  return(w)
} 


gdkDragDrop <-
function(object, time)
{
  checkPtrType(object, "GdkDragContext")
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_drag_drop", object, time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDragAbort <-
function(object, time)
{
  checkPtrType(object, "GdkDragContext")
  time <- as.numeric(time)

  w <- .RGtkCall("S_gdk_drag_abort", object, time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDragDropSucceeded <-
function(object)
{
  checkPtrType(object, "GdkDragContext")

  w <- .RGtkCall("S_gdk_drag_drop_succeeded", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_drawable_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableSetData <-
function(object, key, data)
{
  checkPtrType(object, "GdkDrawable")
  key <- as.character(key)
  

  w <- .RGtkCall("S_gdk_drawable_set_data", object, key, data, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetData <-
function(object, key)
{
  checkPtrType(object, "GdkDrawable")
  key <- as.character(key)

  w <- .RGtkCall("S_gdk_drawable_get_data", object, key, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetSize <-
function(object)
{
  checkPtrType(object, "GdkDrawable")

  w <- .RGtkCall("S_gdk_drawable_get_size", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawableSetColormap <-
function(object, colormap)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(colormap, "GdkColormap")

  w <- .RGtkCall("S_gdk_drawable_set_colormap", object, colormap, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawableGetColormap <-
function(object)
{
  checkPtrType(object, "GdkDrawable")

  w <- .RGtkCall("S_gdk_drawable_get_colormap", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetVisual <-
function(object)
{
  checkPtrType(object, "GdkDrawable")

  w <- .RGtkCall("S_gdk_drawable_get_visual", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetDepth <-
function(object)
{
  checkPtrType(object, "GdkDrawable")

  w <- .RGtkCall("S_gdk_drawable_get_depth", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetScreen <-
function(object)
{
  checkPtrType(object, "GdkDrawable")

  w <- .RGtkCall("S_gdk_drawable_get_screen", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetDisplay <-
function(object)
{
  checkPtrType(object, "GdkDrawable")

  w <- .RGtkCall("S_gdk_drawable_get_display", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawPoint <-
function(object, gc, x, y)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_draw_point", object, gc, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawLine <-
function(object, gc, x1, y1, x2, y2)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x1 <- as.integer(x1)
  y1 <- as.integer(y1)
  x2 <- as.integer(x2)
  y2 <- as.integer(y2)

  w <- .RGtkCall("S_gdk_draw_line", object, gc, x1, y1, x2, y2, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawRectangle <-
function(object, gc, filled, x, y, width, height)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  filled <- as.logical(filled)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_draw_rectangle", object, gc, filled, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawArc <-
function(object, gc, filled, x, y, width, height, angle1, angle2)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  filled <- as.logical(filled)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  angle1 <- as.integer(angle1)
  angle2 <- as.integer(angle2)

  w <- .RGtkCall("S_gdk_draw_arc", object, gc, filled, x, y, width, height, angle1, angle2, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawPolygon <-
function(object, gc, filled, points)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  filled <- as.logical(filled)
  points <- lapply(points, function(x) { x <- as.GdkPoint(x); x })

  w <- .RGtkCall("S_gdk_draw_polygon", object, gc, filled, points, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawString <-
function(object, font, gc, x, y, string)
{
  if(getOption("depwarn"))
    .Deprecated("gdkDrawableDrawLayout", "RGtk2")

  checkPtrType(object, "GdkDrawable")
  checkPtrType(font, "GdkFont")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  string <- as.character(string)

  w <- .RGtkCall("S_gdk_draw_string", object, font, gc, x, y, string, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawText <-
function(object, font, gc, x, y, text, text.length)
{
  if(getOption("depwarn"))
    .Deprecated("gdkDrawableDrawLayout", "RGtk2")

  checkPtrType(object, "GdkDrawable")
  checkPtrType(font, "GdkFont")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  text <- as.character(text)
  text.length <- as.integer(text.length)

  w <- .RGtkCall("S_gdk_draw_text", object, font, gc, x, y, text, text.length, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawTextWc <-
function(object, font, gc, x, text)
{
  if(getOption("depwarn"))
    .Deprecated("gdkDrawableDrawLayout", "RGtk2")

  checkPtrType(object, "GdkDrawable")
  checkPtrType(font, "GdkFont")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  text <- as.list(as.numeric(text))

  w <- .RGtkCall("S_gdk_draw_text_wc", object, font, gc, x, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawDrawable <-
function(object, gc, src, xsrc, ysrc, xdest, ydest, width, height)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  checkPtrType(src, "GdkDrawable")
  xsrc <- as.integer(xsrc)
  ysrc <- as.integer(ysrc)
  xdest <- as.integer(xdest)
  ydest <- as.integer(ydest)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_draw_drawable", object, gc, src, xsrc, ysrc, xdest, ydest, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawImage <-
function(object, gc, image, xsrc, ysrc, xdest, ydest, width, height)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  checkPtrType(image, "GdkImage")
  xsrc <- as.integer(xsrc)
  ysrc <- as.integer(ysrc)
  xdest <- as.integer(xdest)
  ydest <- as.integer(ydest)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_draw_image", object, gc, image, xsrc, ysrc, xdest, ydest, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawPoints <-
function(object, gc, points)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  points <- lapply(points, function(x) { x <- as.GdkPoint(x); x })

  w <- .RGtkCall("S_gdk_draw_points", object, gc, points, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawSegments <-
function(object, gc, segs)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  segs <- lapply(segs, function(x) { x <- as.GdkSegment(x); x })

  w <- .RGtkCall("S_gdk_draw_segments", object, gc, segs, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawLines <-
function(object, gc, points)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  points <- lapply(points, function(x) { x <- as.GdkPoint(x); x })

  w <- .RGtkCall("S_gdk_draw_lines", object, gc, points, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawPixbuf <-
function(object, gc = NULL, pixbuf, src.x, src.y, dest.x, dest.y, width = -1, height = -1, dither = "GDK_RGB_DITHER_NORMAL", x.dither = 0, y.dither = 0)
{
  checkPtrType(object, "GdkDrawable")
  if (!is.null( gc )) checkPtrType(gc, "GdkGC")
  checkPtrType(pixbuf, "GdkPixbuf")
  src.x <- as.integer(src.x)
  src.y <- as.integer(src.y)
  dest.x <- as.integer(dest.x)
  dest.y <- as.integer(dest.y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  x.dither <- as.integer(x.dither)
  y.dither <- as.integer(y.dither)

  w <- .RGtkCall("S_gdk_draw_pixbuf", object, gc, pixbuf, src.x, src.y, dest.x, dest.y, width, height, dither, x.dither, y.dither, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawGlyphs <-
function(object, gc, font, x, y, glyphs)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  checkPtrType(font, "PangoFont")
  x <- as.integer(x)
  y <- as.integer(y)
  checkPtrType(glyphs, "PangoGlyphString")

  w <- .RGtkCall("S_gdk_draw_glyphs", object, gc, font, x, y, glyphs, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawLayoutLine <-
function(object, gc, x, y, line)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  checkPtrType(line, "PangoLayoutLine")

  w <- .RGtkCall("S_gdk_draw_layout_line", object, gc, x, y, line, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawLayout <-
function(object, gc, x, y, layout)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  checkPtrType(layout, "PangoLayout")

  w <- .RGtkCall("S_gdk_draw_layout", object, gc, x, y, layout, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawLayoutLineWithColors <-
function(drawable, gc, x, y, line, foreground, background)
{
  checkPtrType(drawable, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  checkPtrType(line, "PangoLayoutLine")
  foreground <- as.GdkColor(foreground)
  background <- as.GdkColor(background)

  w <- .RGtkCall("S_gdk_draw_layout_line_with_colors", drawable, gc, x, y, line, foreground, background, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawLayoutWithColors <-
function(drawable, gc, x, y, layout, foreground, background)
{
  if(getOption("depwarn"))
    .Deprecated("gdkDrawableDrawLayout", "RGtk2")

  checkPtrType(drawable, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  checkPtrType(layout, "PangoLayout")
  foreground <- as.GdkColor(foreground)
  background <- as.GdkColor(background)

  w <- .RGtkCall("S_gdk_draw_layout_with_colors", drawable, gc, x, y, layout, foreground, background, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawGlyphsTransformed <-
function(drawable, gc, matrix, font, x, y, glyphs)
{
  checkPtrType(drawable, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  checkPtrType(matrix, "PangoMatrix")
  checkPtrType(font, "PangoFont")
  x <- as.integer(x)
  y <- as.integer(y)
  checkPtrType(glyphs, "PangoGlyphString")

  w <- .RGtkCall("S_gdk_draw_glyphs_transformed", drawable, gc, matrix, font, x, y, glyphs, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawTrapezoids <-
function(drawable, gc, trapezoids)
{
  checkPtrType(drawable, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  trapezoids <- lapply(trapezoids, function(x) { x <- as.GdkTrapezoid(x); x })

  w <- .RGtkCall("S_gdk_draw_trapezoids", drawable, gc, trapezoids, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDrawableGetImage <-
function(object, x, y, width, height)
{
  checkPtrType(object, "GdkDrawable")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_drawable_get_image", object, x, y, width, height, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableCopyToImage <-
function(object, image = NULL, src.x, src.y, dest.x, dest.y, width, height)
{
  checkPtrType(object, "GdkDrawable")
  if (!is.null( image )) checkPtrType(image, "GdkImage")
  src.x <- as.integer(src.x)
  src.y <- as.integer(src.y)
  dest.x <- as.integer(dest.x)
  dest.y <- as.integer(dest.y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_drawable_copy_to_image", object, image, src.x, src.y, dest.x, dest.y, width, height, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetClipRegion <-
function(object)
{
  checkPtrType(object, "GdkDrawable")

  w <- .RGtkCall("S_gdk_drawable_get_clip_region", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawableGetVisibleRegion <-
function(object)
{
  checkPtrType(object, "GdkDrawable")

  w <- .RGtkCall("S_gdk_drawable_get_visible_region", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_event_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkEventsPending <-
function()
{
  

  w <- .RGtkCall("S_gdk_events_pending", PACKAGE = "RGtk2")

  return(w)
} 


gdkEventGet <-
function()
{
  

  w <- .RGtkCall("S_gdk_event_get", PACKAGE = "RGtk2")

  return(w)
} 


gdkEventPeek <-
function()
{
  

  w <- .RGtkCall("S_gdk_event_peek", PACKAGE = "RGtk2")

  return(w)
} 


gdkEventGetGraphicsExpose <-
function(window)
{
  checkPtrType(window, "GdkWindow")

  w <- .RGtkCall("S_gdk_event_get_graphics_expose", window, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventPut <-
function(object)
{
  checkPtrType(object, "GdkEvent")

  w <- .RGtkCall("S_gdk_event_put", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkEventNew <-
function(type)
{
  

  w <- .RGtkCall("S_gdk_event_new", type, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventCopy <-
function(object)
{
  checkPtrType(object, "GdkEvent")

  w <- .RGtkCall("S_gdk_event_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventGetTime <-
function(object)
{
  checkPtrType(object, "GdkEvent")

  w <- .RGtkCall("S_gdk_event_get_time", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventGetState <-
function(object)
{
  checkPtrType(object, "GdkEvent")

  w <- .RGtkCall("S_gdk_event_get_state", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventGetCoords <-
function(object)
{
  checkPtrType(object, "GdkEvent")

  w <- .RGtkCall("S_gdk_event_get_coords", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventGetRootCoords <-
function(object)
{
  checkPtrType(object, "GdkEvent")

  w <- .RGtkCall("S_gdk_event_get_root_coords", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventGetAxis <-
function(object, axis.use)
{
  checkPtrType(object, "GdkEvent")
  

  w <- .RGtkCall("S_gdk_event_get_axis", object, axis.use, PACKAGE = "RGtk2")

  return(w)
} 


gdkEventHandlerSet <-
function(func, data)
{
  func <- as.function(func)
  

  w <- .RGtkCall("S_gdk_event_handler_set", func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkEventSetScreen <-
function(object, screen)
{
  checkPtrType(object, "GdkEvent")
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gdk_event_set_screen", object, screen, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkEventGetScreen <-
function(object)
{
  checkPtrType(object, "GdkEvent")

  w <- .RGtkCall("S_gdk_event_get_screen", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkSetShowEvents <-
function(show.events)
{
  show.events <- as.logical(show.events)

  w <- .RGtkCall("S_gdk_set_show_events", show.events, PACKAGE = "RGtk2")

  return(w)
} 


gdkGetShowEvents <-
function()
{
  

  w <- .RGtkCall("S_gdk_get_show_events", PACKAGE = "RGtk2")

  return(w)
} 


gdkAddClientMessageFilter <-
function(message.type, func, data)
{
  message.type <- as.GdkAtom(message.type)
  func <- as.function(func)
  

  w <- .RGtkCall("S_gdk_add_client_message_filter", message.type, func, data, PACKAGE = "RGtk2")

  return(w)
} 


gdkSettingGet <-
function(name)
{
  name <- as.character(name)

  w <- .RGtkCall("S_gdk_setting_get", name, PACKAGE = "RGtk2")

  return(w)
} 


gdkFontId <-
function(object)
{
  checkPtrType(object, "GdkFont")

  w <- .RGtkCall("S_gdk_font_id", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkFontLoadForDisplay <-
function(display, font.name)
{
  checkPtrType(display, "GdkDisplay")
  font.name <- as.character(font.name)

  w <- .RGtkCall("S_gdk_font_load_for_display", display, font.name, PACKAGE = "RGtk2")

  return(w)
} 


gdkFontsetLoadForDisplay <-
function(display, fontset.name)
{
  checkPtrType(display, "GdkDisplay")
  fontset.name <- as.character(fontset.name)

  w <- .RGtkCall("S_gdk_fontset_load_for_display", display, fontset.name, PACKAGE = "RGtk2")

  return(w)
} 


gdkFontFromDescriptionForDisplay <-
function(display, font.desc)
{
  checkPtrType(display, "GdkDisplay")
  checkPtrType(font.desc, "PangoFontDescription")

  w <- .RGtkCall("S_gdk_font_from_description_for_display", display, font.desc, PACKAGE = "RGtk2")

  return(w)
} 


gdkFontLoad <-
function(font.name)
{
  font.name <- as.character(font.name)

  w <- .RGtkCall("S_gdk_font_load", font.name, PACKAGE = "RGtk2")

  return(w)
} 


gdkFontsetLoad <-
function(fontset.name)
{
  fontset.name <- as.character(fontset.name)

  w <- .RGtkCall("S_gdk_fontset_load", fontset.name, PACKAGE = "RGtk2")

  return(w)
} 


gdkFontFromDescription <-
function(font.desc)
{
  checkPtrType(font.desc, "PangoFontDescription")

  w <- .RGtkCall("S_gdk_font_from_description", font.desc, PACKAGE = "RGtk2")

  return(w)
} 


gdkStringWidth <-
function(object, string)
{
  checkPtrType(object, "GdkFont")
  string <- as.character(string)

  w <- .RGtkCall("S_gdk_string_width", object, string, PACKAGE = "RGtk2")

  return(w)
} 


gdkTextWidth <-
function(object, text, text.length = -1)
{
  checkPtrType(object, "GdkFont")
  text <- as.character(text)
  text.length <- as.integer(text.length)

  w <- .RGtkCall("S_gdk_text_width", object, text, text.length, PACKAGE = "RGtk2")

  return(w)
} 


gdkTextWidthWc <-
function(object, text)
{
  checkPtrType(object, "GdkFont")
  text <- as.list(as.numeric(text))

  w <- .RGtkCall("S_gdk_text_width_wc", object, text, PACKAGE = "RGtk2")

  return(w)
} 


gdkCharWidth <-
function(object, character)
{
  checkPtrType(object, "GdkFont")
  character <- as.character(character)

  w <- .RGtkCall("S_gdk_char_width", object, character, PACKAGE = "RGtk2")

  return(w)
} 


gdkCharWidthWc <-
function(object, character)
{
  checkPtrType(object, "GdkFont")
  character <- as.numeric(character)

  w <- .RGtkCall("S_gdk_char_width_wc", object, character, PACKAGE = "RGtk2")

  return(w)
} 


gdkStringMeasure <-
function(object, string)
{
  checkPtrType(object, "GdkFont")
  string <- as.character(string)

  w <- .RGtkCall("S_gdk_string_measure", object, string, PACKAGE = "RGtk2")

  return(w)
} 


gdkTextMeasure <-
function(object, text, text.length = -1)
{
  checkPtrType(object, "GdkFont")
  text <- as.character(text)
  text.length <- as.integer(text.length)

  w <- .RGtkCall("S_gdk_text_measure", object, text, text.length, PACKAGE = "RGtk2")

  return(w)
} 


gdkCharMeasure <-
function(object, character)
{
  checkPtrType(object, "GdkFont")
  character <- as.character(character)

  w <- .RGtkCall("S_gdk_char_measure", object, character, PACKAGE = "RGtk2")

  return(w)
} 


gdkStringHeight <-
function(object, string)
{
  checkPtrType(object, "GdkFont")
  string <- as.character(string)

  w <- .RGtkCall("S_gdk_string_height", object, string, PACKAGE = "RGtk2")

  return(w)
} 


gdkTextHeight <-
function(object, text, text.length = -1)
{
  checkPtrType(object, "GdkFont")
  text <- as.character(text)
  text.length <- as.integer(text.length)

  w <- .RGtkCall("S_gdk_text_height", object, text, text.length, PACKAGE = "RGtk2")

  return(w)
} 


gdkCharHeight <-
function(object, character)
{
  checkPtrType(object, "GdkFont")
  character <- as.character(character)

  w <- .RGtkCall("S_gdk_char_height", object, character, PACKAGE = "RGtk2")

  return(w)
} 


gdkTextExtentsWc <-
function(object, text)
{
  checkPtrType(object, "GdkFont")
  text <- as.list(as.numeric(text))

  w <- .RGtkCall("S_gdk_text_extents_wc", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkStringExtents <-
function(object, string)
{
  checkPtrType(object, "GdkFont")
  string <- as.character(string)

  w <- .RGtkCall("S_gdk_string_extents", object, string, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkFontGetDisplay <-
function(object)
{
  checkPtrType(object, "GdkFont")

  w <- .RGtkCall("S_gdk_font_get_display", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkGCGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_gc_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkGCNew <-
function(drawable)
{
  checkPtrType(drawable, "GdkDrawable")

  w <- .RGtkCall("S_gdk_gc_new", drawable, PACKAGE = "RGtk2")

  return(w)
} 


gdkGCNewWithValues <-
function(object, values)
{
  checkPtrType(object, "GdkDrawable")
  values <- as.GdkGCValues(values)

  w <- .RGtkCall("S_gdk_gc_new_with_values", object, values, PACKAGE = "RGtk2")

  return(w)
} 


gdkGCGetValues <-
function(object)
{
  checkPtrType(object, "GdkGC")

  w <- .RGtkCall("S_gdk_gc_get_values", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkGCSetValues <-
function(object, values)
{
  checkPtrType(object, "GdkGC")
  values <- as.GdkGCValues(values)

  w <- .RGtkCall("S_gdk_gc_set_values", object, values, PACKAGE = "RGtk2")

  return(w)
} 


gdkGCSetForeground <-
function(object, color)
{
  checkPtrType(object, "GdkGC")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_gc_set_foreground", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetBackground <-
function(object, color)
{
  checkPtrType(object, "GdkGC")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_gc_set_background", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetFont <-
function(object, font)
{
  checkPtrType(object, "GdkGC")
  checkPtrType(font, "GdkFont")

  w <- .RGtkCall("S_gdk_gc_set_font", object, font, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetFunction <-
function(object, fun)
{
  checkPtrType(object, "GdkGC")
  

  w <- .RGtkCall("S_gdk_gc_set_function", object, fun, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetFill <-
function(object, fill)
{
  checkPtrType(object, "GdkGC")
  

  w <- .RGtkCall("S_gdk_gc_set_fill", object, fill, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetTile <-
function(object, tile)
{
  checkPtrType(object, "GdkGC")
  checkPtrType(tile, "GdkPixmap")

  w <- .RGtkCall("S_gdk_gc_set_tile", object, tile, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetStipple <-
function(object, stipple)
{
  checkPtrType(object, "GdkGC")
  checkPtrType(stipple, "GdkPixmap")

  w <- .RGtkCall("S_gdk_gc_set_stipple", object, stipple, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetTsOrigin <-
function(object, x, y)
{
  checkPtrType(object, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_gc_set_ts_origin", object, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetClipOrigin <-
function(object, x, y)
{
  checkPtrType(object, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_gc_set_clip_origin", object, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetClipMask <-
function(object, mask)
{
  checkPtrType(object, "GdkGC")
  checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gdk_gc_set_clip_mask", object, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetClipRectangle <-
function(object, rectangle)
{
  checkPtrType(object, "GdkGC")
  rectangle <- as.GdkRectangle(rectangle)

  w <- .RGtkCall("S_gdk_gc_set_clip_rectangle", object, rectangle, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetClipRegion <-
function(object, region)
{
  checkPtrType(object, "GdkGC")
  checkPtrType(region, "GdkRegion")

  w <- .RGtkCall("S_gdk_gc_set_clip_region", object, region, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetSubwindow <-
function(object, mode)
{
  checkPtrType(object, "GdkGC")
  

  w <- .RGtkCall("S_gdk_gc_set_subwindow", object, mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetExposures <-
function(object, exposures)
{
  checkPtrType(object, "GdkGC")
  exposures <- as.logical(exposures)

  w <- .RGtkCall("S_gdk_gc_set_exposures", object, exposures, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetLineAttributes <-
function(object, line.width, line.style, cap.style, join.style)
{
  checkPtrType(object, "GdkGC")
  line.width <- as.integer(line.width)
  
  
  

  w <- .RGtkCall("S_gdk_gc_set_line_attributes", object, line.width, line.style, cap.style, join.style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetDashes <-
function(object, dash.list)
{
  checkPtrType(object, "GdkGC")
  dash.list <- as.list(as.raw(dash.list))

  w <- .RGtkCall("S_gdk_gc_set_dashes", object, dash.list, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCOffset <-
function(object, x.offset, y.offset)
{
  checkPtrType(object, "GdkGC")
  x.offset <- as.integer(x.offset)
  y.offset <- as.integer(y.offset)

  w <- .RGtkCall("S_gdk_gc_offset", object, x.offset, y.offset, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCCopy <-
function(object, src.gc)
{
  checkPtrType(object, "GdkGC")
  checkPtrType(src.gc, "GdkGC")

  w <- .RGtkCall("S_gdk_gc_copy", object, src.gc, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetColormap <-
function(object, colormap)
{
  checkPtrType(object, "GdkGC")
  checkPtrType(colormap, "GdkColormap")

  w <- .RGtkCall("S_gdk_gc_set_colormap", object, colormap, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCGetColormap <-
function(object)
{
  checkPtrType(object, "GdkGC")

  w <- .RGtkCall("S_gdk_gc_get_colormap", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkGCSetRgbFgColor <-
function(object, color)
{
  checkPtrType(object, "GdkGC")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_gc_set_rgb_fg_color", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCSetRgbBgColor <-
function(object, color)
{
  checkPtrType(object, "GdkGC")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_gc_set_rgb_bg_color", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkGCGetScreen <-
function(object)
{
  checkPtrType(object, "GdkGC")

  w <- .RGtkCall("S_gdk_gc_get_screen", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkImageGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_image_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkImageNew <-
function(type, visual, width, height)
{
  
  checkPtrType(visual, "GdkVisual")
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_image_new", type, visual, width, height, PACKAGE = "RGtk2")

  return(w)
} 


gdkImageGet <-
function(object, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gdkDrawableGetImage", "RGtk2")

  checkPtrType(object, "GdkDrawable")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_image_get", object, x, y, width, height, PACKAGE = "RGtk2")

  return(w)
} 


gdkImagePutPixel <-
function(object, x, y, pixel)
{
  checkPtrType(object, "GdkImage")
  x <- as.integer(x)
  y <- as.integer(y)
  pixel <- as.numeric(pixel)

  w <- .RGtkCall("S_gdk_image_put_pixel", object, x, y, pixel, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkImageGetPixel <-
function(object, x, y)
{
  checkPtrType(object, "GdkImage")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_image_get_pixel", object, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gdkImageSetColormap <-
function(object, colormap)
{
  checkPtrType(object, "GdkImage")
  checkPtrType(colormap, "GdkColormap")

  w <- .RGtkCall("S_gdk_image_set_colormap", object, colormap, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkImageGetColormap <-
function(object)
{
  checkPtrType(object, "GdkImage")

  w <- .RGtkCall("S_gdk_image_get_colormap", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkDeviceGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_device_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkDevicesList <-
function()
{
  

  w <- .RGtkCall("S_gdk_devices_list", PACKAGE = "RGtk2")

  return(w)
} 


gdkDeviceSetSource <-
function(object, source)
{
  checkPtrType(object, "GdkDevice")
  

  w <- .RGtkCall("S_gdk_device_set_source", object, source, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDeviceSetMode <-
function(object, mode)
{
  checkPtrType(object, "GdkDevice")
  

  w <- .RGtkCall("S_gdk_device_set_mode", object, mode, PACKAGE = "RGtk2")

  return(w)
} 


gdkDeviceSetKey <-
function(object, index, keyval, modifiers)
{
  checkPtrType(object, "GdkDevice")
  index <- as.numeric(index)
  keyval <- as.numeric(keyval)
  

  w <- .RGtkCall("S_gdk_device_set_key", object, index, keyval, modifiers, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDeviceSetAxisUse <-
function(object, index, use)
{
  checkPtrType(object, "GdkDevice")
  index <- as.numeric(index)
  

  w <- .RGtkCall("S_gdk_device_set_axis_use", object, index, use, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDeviceGetState <-
function(object, window)
{
  checkPtrType(object, "GdkDevice")
  checkPtrType(window, "GdkWindow")

  w <- .RGtkCall("S_gdk_device_get_state", object, window, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDeviceGetHistory <-
function(object, window, start, stop)
{
  checkPtrType(object, "GdkDevice")
  checkPtrType(window, "GdkWindow")
  start <- as.numeric(start)
  stop <- as.numeric(stop)

  w <- .RGtkCall("S_gdk_device_get_history", object, window, start, stop, PACKAGE = "RGtk2")

  return(w)
} 


gdkDeviceGetAxis <-
function(object, axes, use)
{
  checkPtrType(object, "GdkDevice")
  axes <- as.list(as.numeric(axes))
  

  w <- .RGtkCall("S_gdk_device_get_axis", object, axes, use, PACKAGE = "RGtk2")

  return(w)
} 


gdkInputSetExtensionEvents <-
function(object, mask, mode)
{
  checkPtrType(object, "GdkWindow")
  mask <- as.integer(mask)
  

  w <- .RGtkCall("S_gdk_input_set_extension_events", object, mask, mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkDeviceGetCorePointer <-
function()
{
  

  w <- .RGtkCall("S_gdk_device_get_core_pointer", PACKAGE = "RGtk2")

  return(w)
} 


gdkKeymapGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_keymap_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkKeymapGetDefault <-
function()
{
  

  w <- .RGtkCall("S_gdk_keymap_get_default", PACKAGE = "RGtk2")

  return(w)
} 


gdkKeymapGetForDisplay <-
function(display)
{
  checkPtrType(display, "GdkDisplay")

  w <- .RGtkCall("S_gdk_keymap_get_for_display", display, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeymapLookupKey <-
function(object, key)
{
  checkPtrType(object, "GdkKeymap")
  key <- as.GdkKeymapKey(key)

  w <- .RGtkCall("S_gdk_keymap_lookup_key", object, key, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeymapTranslateKeyboardState <-
function(object, hardware.keycode, state, group)
{
  checkPtrType(object, "GdkKeymap")
  hardware.keycode <- as.numeric(hardware.keycode)
  
  group <- as.integer(group)

  w <- .RGtkCall("S_gdk_keymap_translate_keyboard_state", object, hardware.keycode, state, group, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeymapGetEntriesForKeyval <-
function(object, keyval)
{
  checkPtrType(object, "GdkKeymap")
  keyval <- as.numeric(keyval)

  w <- .RGtkCall("S_gdk_keymap_get_entries_for_keyval", object, keyval, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeymapGetEntriesForKeycode <-
function(object, hardware.keycode)
{
  checkPtrType(object, "GdkKeymap")
  hardware.keycode <- as.numeric(hardware.keycode)

  w <- .RGtkCall("S_gdk_keymap_get_entries_for_keycode", object, hardware.keycode, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeymapGetDirection <-
function(object)
{
  checkPtrType(object, "GdkKeymap")

  w <- .RGtkCall("S_gdk_keymap_get_direction", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyvalName <-
function(keyval)
{
  keyval <- as.numeric(keyval)

  w <- .RGtkCall("S_gdk_keyval_name", keyval, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyvalFromName <-
function(keyval.name)
{
  keyval.name <- as.character(keyval.name)

  w <- .RGtkCall("S_gdk_keyval_from_name", keyval.name, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyvalConvertCase <-
function(symbol)
{
  symbol <- as.numeric(symbol)

  w <- .RGtkCall("S_gdk_keyval_convert_case", symbol, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkKeyvalToUpper <-
function(keyval)
{
  keyval <- as.numeric(keyval)

  w <- .RGtkCall("S_gdk_keyval_to_upper", keyval, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyvalToLower <-
function(keyval)
{
  keyval <- as.numeric(keyval)

  w <- .RGtkCall("S_gdk_keyval_to_lower", keyval, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyvalIsUpper <-
function(keyval)
{
  keyval <- as.numeric(keyval)

  w <- .RGtkCall("S_gdk_keyval_is_upper", keyval, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyvalIsLower <-
function(keyval)
{
  keyval <- as.numeric(keyval)

  w <- .RGtkCall("S_gdk_keyval_is_lower", keyval, PACKAGE = "RGtk2")

  return(w)
} 


gdkKeyvalToUnicode <-
function(keyval)
{
  keyval <- as.numeric(keyval)

  w <- .RGtkCall("S_gdk_keyval_to_unicode", keyval, PACKAGE = "RGtk2")

  return(w)
} 


gdkUnicodeToKeyval <-
function(wc)
{
  wc <- as.numeric(wc)

  w <- .RGtkCall("S_gdk_unicode_to_keyval", wc, PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoRendererGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_pango_renderer_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoRendererNew <-
function(screen)
{
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gdk_pango_renderer_new", screen, PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoRendererGetDefault <-
function(screen)
{
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gdk_pango_renderer_get_default", screen, PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoRendererSetDrawable <-
function(object, drawable = NULL)
{
  checkPtrType(object, "GdkPangoRenderer")
  if (!is.null( drawable )) checkPtrType(drawable, "GdkDrawable")

  w <- .RGtkCall("S_gdk_pango_renderer_set_drawable", object, drawable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPangoRendererSetGc <-
function(object, gc = NULL)
{
  checkPtrType(object, "GdkPangoRenderer")
  if (!is.null( gc )) checkPtrType(gc, "GdkGC")

  w <- .RGtkCall("S_gdk_pango_renderer_set_gc", object, gc, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPangoRendererSetStipple <-
function(object, part, stipple)
{
  checkPtrType(object, "GdkPangoRenderer")
  
  checkPtrType(stipple, "GdkBitmap")

  w <- .RGtkCall("S_gdk_pango_renderer_set_stipple", object, part, stipple, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPangoRendererSetOverrideColor <-
function(object, part, color = NULL)
{
  checkPtrType(object, "GdkPangoRenderer")
  
  if (!is.null( color )) color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_pango_renderer_set_override_color", object, part, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPangoContextGetForScreen <-
function(screen)
{
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gdk_pango_context_get_for_screen", screen, PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoContextGet <-
function()
{
  

  w <- .RGtkCall("S_gdk_pango_context_get", PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoContextSetColormap <-
function(context, colormap)
{
  checkPtrType(context, "PangoContext")
  checkPtrType(colormap, "GdkColormap")

  w <- .RGtkCall("S_gdk_pango_context_set_colormap", context, colormap, PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoLayoutLineGetClipRegion <-
function(line, x.origin, index.ranges)
{
  checkPtrType(line, "PangoLayoutLine")
  x.origin <- as.integer(x.origin)
  index.ranges <- as.list(as.integer(index.ranges))

  w <- .RGtkCall("S_gdk_pango_layout_line_get_clip_region", line, x.origin, index.ranges, PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoLayoutGetClipRegion <-
function(layout, x.origin, index.ranges)
{
  checkPtrType(layout, "PangoLayout")
  x.origin <- as.integer(x.origin)
  index.ranges <- as.list(as.integer(index.ranges))

  w <- .RGtkCall("S_gdk_pango_layout_get_clip_region", layout, x.origin, index.ranges, PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoAttrStippleNew <-
function(stipple)
{
  checkPtrType(stipple, "GdkBitmap")

  w <- .RGtkCall("S_gdk_pango_attr_stipple_new", stipple, PACKAGE = "RGtk2")

  return(w)
} 


gdkPangoAttrEmbossedNew <-
function(embossed)
{
  embossed <- as.logical(embossed)

  w <- .RGtkCall("S_gdk_pango_attr_embossed_new", embossed, PACKAGE = "RGtk2")

  return(w)
} 


gdkPixbufRenderThresholdAlpha <-
function(object, bitmap, src.x, src.y, dest.x, dest.y, width = -1, height = -1, alpha.threshold)
{
  checkPtrType(object, "GdkPixbuf")
  checkPtrType(bitmap, "GdkBitmap")
  src.x <- as.integer(src.x)
  src.y <- as.integer(src.y)
  dest.x <- as.integer(dest.x)
  dest.y <- as.integer(dest.y)
  width <- as.integer(width)
  height <- as.integer(height)
  alpha.threshold <- as.integer(alpha.threshold)

  w <- .RGtkCall("S_gdk_pixbuf_render_threshold_alpha", object, bitmap, src.x, src.y, dest.x, dest.y, width, height, alpha.threshold, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPixbufRenderToDrawable <-
function(object, drawable, gc, src.x = 0, src.y = 0, dest.x, dest.y, width = -1, height = -1, dither = "GDK_RGB_DITHER_NORMAL", x.dither = 0, y.dither = 0)
{
  if(getOption("depwarn"))
    .Deprecated("gdkDrawableDrawPixbuf", "RGtk2")

  checkPtrType(object, "GdkPixbuf")
  checkPtrType(drawable, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  src.x <- as.integer(src.x)
  src.y <- as.integer(src.y)
  dest.x <- as.integer(dest.x)
  dest.y <- as.integer(dest.y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  x.dither <- as.integer(x.dither)
  y.dither <- as.integer(y.dither)

  w <- .RGtkCall("S_gdk_pixbuf_render_to_drawable", object, drawable, gc, src.x, src.y, dest.x, dest.y, width, height, dither, x.dither, y.dither, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPixbufRenderToDrawableAlpha <-
function(object, drawable, src.x = 0, src.y = 0, dest.x, dest.y, width = -1, height = -1, alpha.mode = NULL, alpha.threshold = NULL, dither = "GDK_RGB_DITHER_NORMAL", x.dither = 0, y.dither = 0)
{
  if(getOption("depwarn"))
    .Deprecated("gdkDrawableDrawPixbuf", "RGtk2")

  checkPtrType(object, "GdkPixbuf")
  checkPtrType(drawable, "GdkDrawable")
  src.x <- as.integer(src.x)
  src.y <- as.integer(src.y)
  dest.x <- as.integer(dest.x)
  dest.y <- as.integer(dest.y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  alpha.threshold <- as.integer(alpha.threshold)
  
  x.dither <- as.integer(x.dither)
  y.dither <- as.integer(y.dither)

  w <- .RGtkCall("S_gdk_pixbuf_render_to_drawable_alpha", object, drawable, src.x, src.y, dest.x, dest.y, width, height, alpha.mode, alpha.threshold, dither, x.dither, y.dither, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPixbufRenderPixmapAndMask <-
function(object, alpha.threshold = 127)
{
  checkPtrType(object, "GdkPixbuf")
  alpha.threshold <- as.integer(alpha.threshold)

  w <- .RGtkCall("S_gdk_pixbuf_render_pixmap_and_mask", object, alpha.threshold, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPixbufRenderPixmapAndMaskForColormap <-
function(object, colormap, alpha.threshold = 127)
{
  checkPtrType(object, "GdkPixbuf")
  checkPtrType(colormap, "GdkColormap")
  alpha.threshold <- as.integer(alpha.threshold)

  w <- .RGtkCall("S_gdk_pixbuf_render_pixmap_and_mask_for_colormap", object, colormap, alpha.threshold, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkPixbufGetFromDrawable <-
function(dest = NULL, src, cmap = NULL, src.x, src.y, dest.x, dest.y, width, height)
{
  if (!is.null( dest )) checkPtrType(dest, "GdkPixbuf")
  checkPtrType(src, "GdkDrawable")
  if (!is.null( cmap )) checkPtrType(cmap, "GdkColormap")
  src.x <- as.integer(src.x)
  src.y <- as.integer(src.y)
  dest.x <- as.integer(dest.x)
  dest.y <- as.integer(dest.y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_pixbuf_get_from_drawable", dest, src, cmap, src.x, src.y, dest.x, dest.y, width, height, PACKAGE = "RGtk2")

  return(w)
} 


gdkPixbufGetFromImage <-
function(src, cmap, src.x, src.y, dest.x, dest.y, width, height)
{
  checkPtrType(src, "GdkImage")
  checkPtrType(cmap, "GdkColormap")
  src.x <- as.integer(src.x)
  src.y <- as.integer(src.y)
  dest.x <- as.integer(dest.x)
  dest.y <- as.integer(dest.y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_pixbuf_get_from_image", src, cmap, src.x, src.y, dest.x, dest.y, width, height, PACKAGE = "RGtk2")

  return(w)
} 


gdkPixmapGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_pixmap_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkPixmapNew <-
function(drawable = NULL, width, height, depth = -1)
{
  if (!is.null( drawable )) checkPtrType(drawable, "GdkDrawable")
  width <- as.integer(width)
  height <- as.integer(height)
  depth <- as.integer(depth)

  w <- .RGtkCall("S_gdk_pixmap_new", drawable, width, height, depth, PACKAGE = "RGtk2")

  return(w)
} 


gdkPixmapCreateFromData <-
function(drawable = NULL, data, height, depth, fg, bg)
{
  if (!is.null( drawable )) checkPtrType(drawable, "GdkDrawable")
  data <- as.list(as.raw(data))
  height <- as.integer(height)
  depth <- as.integer(depth)
  fg <- as.GdkColor(fg)
  bg <- as.GdkColor(bg)

  w <- .RGtkCall("S_gdk_pixmap_create_from_data", drawable, data, height, depth, fg, bg, PACKAGE = "RGtk2")

  return(w)
} 


gdkPixmapCreateFromXpm <-
function(drawable, transparent.color, filename)
{
  checkPtrType(drawable, "GdkDrawable")
  transparent.color <- as.GdkColor(transparent.color)
  filename <- as.character(filename)

  w <- .RGtkCall("S_gdk_pixmap_create_from_xpm", drawable, transparent.color, filename, PACKAGE = "RGtk2")

  return(w)
} 


gdkPixmapColormapCreateFromXpm <-
function(drawable, colormap, transparent.color, filename)
{
  checkPtrType(drawable, "GdkDrawable")
  checkPtrType(colormap, "GdkColormap")
  transparent.color <- as.GdkColor(transparent.color)
  filename <- as.character(filename)

  w <- .RGtkCall("S_gdk_pixmap_colormap_create_from_xpm", drawable, colormap, transparent.color, filename, PACKAGE = "RGtk2")

  return(w)
} 


gdkPixmapCreateFromXpmD <-
function(drawable, transparent.color, data)
{
  checkPtrType(drawable, "GdkDrawable")
  transparent.color <- as.GdkColor(transparent.color)
  data <- as.list(as.character(data))

  w <- .RGtkCall("S_gdk_pixmap_create_from_xpm_d", drawable, transparent.color, data, PACKAGE = "RGtk2")

  return(w)
} 


gdkPixmapColormapCreateFromXpmD <-
function(drawable, colormap, transparent.color, data)
{
  checkPtrType(drawable, "GdkDrawable")
  checkPtrType(colormap, "GdkColormap")
  transparent.color <- as.GdkColor(transparent.color)
  data <- as.list(as.character(data))

  w <- .RGtkCall("S_gdk_pixmap_colormap_create_from_xpm_d", drawable, colormap, transparent.color, data, PACKAGE = "RGtk2")

  return(w)
} 


gdkAtomName <-
function(atom)
{
  atom <- as.GdkAtom(atom)

  w <- .RGtkCall("S_gdk_atom_name", atom, PACKAGE = "RGtk2")

  return(w)
} 


gdkAtomIntern <-
function(atom.name, only.if.exists = FALSE)
{
  atom.name <- as.character(atom.name)
  only.if.exists <- as.logical(only.if.exists)

  w <- .RGtkCall("S_gdk_atom_intern", atom.name, only.if.exists, PACKAGE = "RGtk2")

  return(w)
} 


gdkPropertyGet <-
function(object, property, type, offset, length, pdelete)
{
  checkPtrType(object, "GdkWindow")
  property <- as.GdkAtom(property)
  type <- as.GdkAtom(type)
  offset <- as.numeric(offset)
  length <- as.numeric(length)
  pdelete <- as.integer(pdelete)

  w <- .RGtkCall("S_gdk_property_get", object, property, type, offset, length, pdelete, PACKAGE = "RGtk2")

  return(w)
} 


gdkPropertyChange <-
function(object, property, type, format, mode, data)
{
  checkPtrType(object, "GdkWindow")
  property <- as.GdkAtom(property)
  type <- as.GdkAtom(type)
  format <- as.integer(format)
  
  data <- as.list(as.raw(data))

  w <- .RGtkCall("S_gdk_property_change", object, property, type, format, mode, data, PACKAGE = "RGtk2")

  return(w)
} 


gdkPropertyDelete <-
function(object, property)
{
  checkPtrType(object, "GdkWindow")
  property <- as.GdkAtom(property)

  w <- .RGtkCall("S_gdk_property_delete", object, property, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkRgbXpixelFromRgb <-
function(rgb)
{
  rgb <- as.numeric(rgb)

  w <- .RGtkCall("S_gdk_rgb_xpixel_from_rgb", rgb, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbGcSetForeground <-
function(gc, rgb)
{
  checkPtrType(gc, "GdkGC")
  rgb <- as.numeric(rgb)

  w <- .RGtkCall("S_gdk_rgb_gc_set_foreground", gc, rgb, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbGcSetBackground <-
function(gc, rgb)
{
  checkPtrType(gc, "GdkGC")
  rgb <- as.numeric(rgb)

  w <- .RGtkCall("S_gdk_rgb_gc_set_background", gc, rgb, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawRgbImageDithalign <-
function(object, gc, x, y, width, height, dith, rgb.buf, xdith, ydith)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  rgb.buf <- as.list(as.raw(rgb.buf))
  xdith <- as.integer(xdith)
  ydith <- as.integer(ydith)

  w <- .RGtkCall("S_gdk_draw_rgb_image_dithalign", object, gc, x, y, width, height, dith, rgb.buf, xdith, ydith, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawRgb32Image <-
function(object, gc, x, y, width, height, dith, buf)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  buf <- as.list(as.raw(buf))

  w <- .RGtkCall("S_gdk_draw_rgb_32_image", object, gc, x, y, width, height, dith, buf, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawRgb32ImageDithalign <-
function(object, gc, x, y, width, height, dith, buf, xdith, ydith)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  buf <- as.list(as.raw(buf))
  xdith <- as.integer(xdith)
  ydith <- as.integer(ydith)

  w <- .RGtkCall("S_gdk_draw_rgb_32_image_dithalign", object, gc, x, y, width, height, dith, buf, xdith, ydith, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbFindColor <-
function(colormap, color)
{
  checkPtrType(colormap, "GdkColormap")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_rgb_find_color", colormap, color, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbColormapDitherable <-
function(colormap)
{
  checkPtrType(colormap, "GdkColormap")

  w <- .RGtkCall("S_gdk_rgb_colormap_ditherable", colormap, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawGrayImage <-
function(object, gc, x, y, width, height, dith, buf)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  buf <- as.list(as.raw(buf))

  w <- .RGtkCall("S_gdk_draw_gray_image", object, gc, x, y, width, height, dith, buf, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbCmapNew <-
function(colors)
{
  colors <- as.list(as.numeric(colors))

  w <- .RGtkCall("S_gdk_rgb_cmap_new", colors, PACKAGE = "RGtk2")

  return(w)
} 


gdkDrawIndexedImage <-
function(object, gc, x, y, width, height, dith, buf, cmap)
{
  checkPtrType(object, "GdkDrawable")
  checkPtrType(gc, "GdkGC")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  buf <- as.list(as.raw(buf))
  cmap <- as.GdkRgbCmap(cmap)

  w <- .RGtkCall("S_gdk_draw_indexed_image", object, gc, x, y, width, height, dith, buf, cmap, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbDitherable <-
function()
{
  

  w <- .RGtkCall("S_gdk_rgb_ditherable", PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbSetVerbose <-
function(verbose)
{
  verbose <- as.logical(verbose)

  w <- .RGtkCall("S_gdk_rgb_set_verbose", verbose, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbSetInstall <-
function(install)
{
  install <- as.logical(install)

  w <- .RGtkCall("S_gdk_rgb_set_install", install, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbSetMinColors <-
function(min.colors)
{
  min.colors <- as.integer(min.colors)

  w <- .RGtkCall("S_gdk_rgb_set_min_colors", min.colors, PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbGetColormap <-
function()
{
  

  w <- .RGtkCall("S_gdk_rgb_get_colormap", PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbGetCmap <-
function()
{
  if(getOption("depwarn"))
    .Deprecated("gdkRgbGetColormap", "RGtk2")

  

  w <- .RGtkCall("S_gdk_rgb_get_cmap", PACKAGE = "RGtk2")

  return(w)
} 


gdkRgbGetVisual <-
function()
{
  

  w <- .RGtkCall("S_gdk_rgb_get_visual", PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_screen_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetDefaultColormap <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_default_colormap", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenSetDefaultColormap <-
function(object, colormap)
{
  checkPtrType(object, "GdkScreen")
  checkPtrType(colormap, "GdkColormap")

  w <- .RGtkCall("S_gdk_screen_set_default_colormap", object, colormap, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkScreenGetSystemColormap <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_system_colormap", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetSystemVisual <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_system_visual", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetRgbColormap <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_rgb_colormap", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetRgbaColormap <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_rgba_colormap", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetRgbVisual <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_rgb_visual", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetRgbaVisual <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_rgba_visual", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetRootWindow <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_root_window", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetDisplay <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_display", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetNumber <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_number", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetWidth <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_width", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetHeight <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_height", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetWidthMm <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_width_mm", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetHeightMm <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_height_mm", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenListVisuals <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_list_visuals", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetToplevelWindows <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_toplevel_windows", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenMakeDisplayName <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_make_display_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetNMonitors <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gdk_screen_get_n_monitors", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetMonitorGeometry <-
function(object, monitor.num)
{
  checkPtrType(object, "GdkScreen")
  monitor.num <- as.integer(monitor.num)

  w <- .RGtkCall("S_gdk_screen_get_monitor_geometry", object, monitor.num, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetMonitorAtPoint <-
function(object, x, y)
{
  checkPtrType(object, "GdkScreen")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_screen_get_monitor_at_point", object, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetMonitorAtWindow <-
function(object, window)
{
  checkPtrType(object, "GdkScreen")
  checkPtrType(window, "GdkWindow")

  w <- .RGtkCall("S_gdk_screen_get_monitor_at_window", object, window, PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenBroadcastClientMessage <-
function(object, event)
{
  checkPtrType(object, "GdkScreen")
  checkPtrType(event, "GdkEvent")

  w <- .RGtkCall("S_gdk_screen_broadcast_client_message", object, event, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkScreenGetDefault <-
function()
{
  

  w <- .RGtkCall("S_gdk_screen_get_default", PACKAGE = "RGtk2")

  return(w)
} 


gdkScreenGetSetting <-
function(object, name)
{
  checkPtrType(object, "GdkScreen")
  name <- as.character(name)

  w <- .RGtkCall("S_gdk_screen_get_setting", object, name, PACKAGE = "RGtk2")

  return(w)
} 


gdkSpawnCommandLineOnScreen <-
function(screen, command.line, .errwarn = TRUE)
{
  checkPtrType(screen, "GdkScreen")
  command.line <- as.character(command.line)

  w <- .RGtkCall("S_gdk_spawn_command_line_on_screen", screen, command.line, PACKAGE = "RGtk2")

  w <- handleError(w, .errwarn)

  return(w)
} 


gtkAlternativeDialogButtonOrder <-
function(object)
{
  checkPtrType(object, "GdkScreen")

  w <- .RGtkCall("S_gtk_alternative_dialog_button_order", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkSelectionOwnerGet <-
function(selection)
{
  selection <- as.GdkAtom(selection)

  w <- .RGtkCall("S_gdk_selection_owner_get", selection, PACKAGE = "RGtk2")

  return(w)
} 


gdkSelectionOwnerGetForDisplay <-
function(display, selection)
{
  checkPtrType(display, "GdkDisplay")
  selection <- as.GdkAtom(selection)

  w <- .RGtkCall("S_gdk_selection_owner_get_for_display", display, selection, PACKAGE = "RGtk2")

  return(w)
} 


gdkSelectionPropertyGet <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_selection_property_get", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkVisualGetBestDepth <-
function()
{
  

  w <- .RGtkCall("S_gdk_visual_get_best_depth", PACKAGE = "RGtk2")

  return(w)
} 


gdkVisualGetBestType <-
function()
{
  

  w <- .RGtkCall("S_gdk_visual_get_best_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkVisualGetSystem <-
function()
{
  

  w <- .RGtkCall("S_gdk_visual_get_system", PACKAGE = "RGtk2")

  return(w)
} 


gdkVisualGetBest <-
function()
{
  

  w <- .RGtkCall("S_gdk_visual_get_best", PACKAGE = "RGtk2")

  return(w)
} 


gdkVisualGetBestWithDepth <-
function(depth)
{
  depth <- as.integer(depth)

  w <- .RGtkCall("S_gdk_visual_get_best_with_depth", depth, PACKAGE = "RGtk2")

  return(w)
} 


gdkVisualGetBestWithType <-
function(visual.type)
{
  

  w <- .RGtkCall("S_gdk_visual_get_best_with_type", visual.type, PACKAGE = "RGtk2")

  return(w)
} 


gdkVisualGetBestWithBoth <-
function(depth, visual.type)
{
  depth <- as.integer(depth)
  

  w <- .RGtkCall("S_gdk_visual_get_best_with_both", depth, visual.type, PACKAGE = "RGtk2")

  return(w)
} 


gdkQueryDepths <-
function()
{
  

  w <- .RGtkCall("S_gdk_query_depths", PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkQueryVisualTypes <-
function()
{
  

  w <- .RGtkCall("S_gdk_query_visual_types", PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkListVisuals <-
function()
{
  

  w <- .RGtkCall("S_gdk_list_visuals", PACKAGE = "RGtk2")

  return(w)
} 


gdkVisualGetScreen <-
function(object)
{
  checkPtrType(object, "GdkVisual")

  w <- .RGtkCall("S_gdk_visual_get_screen", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowObjectGetType <-
function()
{
  

  w <- .RGtkCall("S_gdk_window_object_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowSetKeepAbove <-
function(object, setting)
{
  checkPtrType(object, "GdkWindow")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gdk_window_set_keep_above", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetKeepBelow <-
function(object, setting)
{
  checkPtrType(object, "GdkWindow")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gdk_window_set_keep_below", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowDestroy <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_destroy", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetWindowType <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_window_type", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowAtPointer <-
function()
{
  

  w <- .RGtkCall("S_gdk_window_at_pointer", PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowShow <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_show", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowShowUnraised <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_show_unraised", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowHide <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_hide", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowWithdraw <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_withdraw", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowMove <-
function(object, x, y)
{
  checkPtrType(object, "GdkWindow")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_window_move", object, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowResize <-
function(object, width, height)
{
  checkPtrType(object, "GdkWindow")
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_window_resize", object, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowMoveResize <-
function(object, x, y, width, height)
{
  checkPtrType(object, "GdkWindow")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_window_move_resize", object, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowMoveRegion <-
function(object, region, x, y)
{
  checkPtrType(object, "GdkWindow")
  checkPtrType(region, "GdkRegion")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_window_move_region", object, region, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowReparent <-
function(object, new.parent, x, y)
{
  checkPtrType(object, "GdkWindow")
  checkPtrType(new.parent, "GdkWindow")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gdk_window_reparent", object, new.parent, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowClear <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_clear", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowClearArea <-
function(object, x, y, width, height)
{
  checkPtrType(object, "GdkWindow")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_window_clear_area", object, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowClearAreaE <-
function(object, x, y, width, height)
{
  checkPtrType(object, "GdkWindow")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gdk_window_clear_area_e", object, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowRaise <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_raise", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowLower <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_lower", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowFocus <-
function(object, timestamp = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GdkWindow")
  timestamp <- as.numeric(timestamp)

  w <- .RGtkCall("S_gdk_window_focus", object, timestamp, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetUserData <-
function(object, user.data = NULL)
{
  checkPtrType(object, "GdkWindow")
  if (!is.null( user.data )) checkPtrType(user.data, "GtkWidget")

  w <- .RGtkCall("S_gdk_window_set_user_data", object, user.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetUserData <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_user_data", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowSetOverrideRedirect <-
function(object, override.redirect)
{
  checkPtrType(object, "GdkWindow")
  override.redirect <- as.logical(override.redirect)

  w <- .RGtkCall("S_gdk_window_set_override_redirect", object, override.redirect, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowAddFilter <-
function(object, fun, data)
{
  checkPtrType(object, "GdkWindow")
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gdk_window_add_filter", object, fun, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowRemoveFilter <-
function(object, fun, data)
{
  checkPtrType(object, "GdkWindow")
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gdk_window_remove_filter", object, fun, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowScroll <-
function(object, dx, dy)
{
  checkPtrType(object, "GdkWindow")
  dx <- as.integer(dx)
  dy <- as.integer(dy)

  w <- .RGtkCall("S_gdk_window_scroll", object, dx, dy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowShapeCombineMask <-
function(object, shape.mask = NULL, offset.x, offset.y)
{
  checkPtrType(object, "GdkWindow")
  if (!is.null( shape.mask )) checkPtrType(shape.mask, "GdkBitmap")
  offset.x <- as.integer(offset.x)
  offset.y <- as.integer(offset.y)

  w <- .RGtkCall("S_gdk_window_shape_combine_mask", object, shape.mask, offset.x, offset.y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowShapeCombineRegion <-
function(object, shape.region = NULL, offset.x, offset.y)
{
  checkPtrType(object, "GdkWindow")
  if (!is.null( shape.region )) checkPtrType(shape.region, "GdkRegion")
  offset.x <- as.integer(offset.x)
  offset.y <- as.integer(offset.y)

  w <- .RGtkCall("S_gdk_window_shape_combine_region", object, shape.region, offset.x, offset.y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetChildShapes <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_set_child_shapes", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowMergeChildShapes <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_merge_child_shapes", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowIsVisible <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_is_visible", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowIsViewable <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_is_viewable", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowGetState <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_state", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowSetStaticGravities <-
function(object, use.static)
{
  checkPtrType(object, "GdkWindow")
  use.static <- as.logical(use.static)

  w <- .RGtkCall("S_gdk_window_set_static_gravities", object, use.static, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowSetHints <-
function(object, x, y, min.width, min.height, max.width, max.height, flags)
{
  checkPtrType(object, "GdkWindow")
  x <- as.integer(x)
  y <- as.integer(y)
  min.width <- as.integer(min.width)
  min.height <- as.integer(min.height)
  max.width <- as.integer(max.width)
  max.height <- as.integer(max.height)
  flags <- as.integer(flags)

  w <- .RGtkCall("S_gdk_window_set_hints", object, x, y, min.width, min.height, max.width, max.height, flags, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetTypeHint <-
function(object, hint)
{
  checkPtrType(object, "GdkWindow")
  

  w <- .RGtkCall("S_gdk_window_set_type_hint", object, hint, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetModalHint <-
function(object, modal)
{
  checkPtrType(object, "GdkWindow")
  modal <- as.logical(modal)

  w <- .RGtkCall("S_gdk_window_set_modal_hint", object, modal, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetSkipTaskbarHint <-
function(object, modal)
{
  checkPtrType(object, "GdkWindow")
  modal <- as.logical(modal)

  w <- .RGtkCall("S_gdk_window_set_skip_taskbar_hint", object, modal, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetSkipPagerHint <-
function(object, modal)
{
  checkPtrType(object, "GdkWindow")
  modal <- as.logical(modal)

  w <- .RGtkCall("S_gdk_window_set_skip_pager_hint", object, modal, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetUrgencyHint <-
function(object, urgent)
{
  checkPtrType(object, "GdkWindow")
  urgent <- as.logical(urgent)

  w <- .RGtkCall("S_gdk_window_set_urgency_hint", object, urgent, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetGeometryHints <-
function(object, geometry)
{
  checkPtrType(object, "GdkWindow")
  geometry <- as.GdkGeometry(geometry)

  w <- .RGtkCall("S_gdk_window_set_geometry_hints", object, geometry, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowBeginPaintRect <-
function(object, rectangle)
{
  checkPtrType(object, "GdkWindow")
  rectangle <- as.GdkRectangle(rectangle)

  w <- .RGtkCall("S_gdk_window_begin_paint_rect", object, rectangle, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowBeginPaintRegion <-
function(object, region)
{
  checkPtrType(object, "GdkWindow")
  checkPtrType(region, "GdkRegion")

  w <- .RGtkCall("S_gdk_window_begin_paint_region", object, region, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowEndPaint <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_end_paint", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetTitle <-
function(object, title)
{
  checkPtrType(object, "GdkWindow")
  title <- as.character(title)

  w <- .RGtkCall("S_gdk_window_set_title", object, title, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetRole <-
function(object, role)
{
  checkPtrType(object, "GdkWindow")
  role <- as.character(role)

  w <- .RGtkCall("S_gdk_window_set_role", object, role, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetTransientFor <-
function(object, leader)
{
  checkPtrType(object, "GdkWindow")
  checkPtrType(leader, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_set_transient_for", object, leader, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetBackground <-
function(object, color)
{
  checkPtrType(object, "GdkWindow")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gdk_window_set_background", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetBackPixmap <-
function(object, pixmap = NULL, parent.relative)
{
  checkPtrType(object, "GdkWindow")
  if (!is.null( pixmap )) checkPtrType(pixmap, "GdkPixmap")
  parent.relative <- as.logical(parent.relative)

  w <- .RGtkCall("S_gdk_window_set_back_pixmap", object, pixmap, parent.relative, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetCursor <-
function(object, cursor = NULL)
{
  checkPtrType(object, "GdkWindow")
  if (!is.null( cursor )) checkPtrType(cursor, "GdkCursor")

  w <- .RGtkCall("S_gdk_window_set_cursor", object, cursor, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetGeometry <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_geometry", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetPosition <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_position", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetOrigin <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_origin", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowGetDeskrelativeOrigin <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_deskrelative_origin", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowGetRootOrigin <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_root_origin", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetFrameExtents <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_frame_extents", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowGetPointer <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_pointer", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowGetParent <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_parent", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowGetToplevel <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_toplevel", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowGetChildren <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_children", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowPeekChildren <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_peek_children", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowGetEvents <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_events", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowSetEvents <-
function(object, event.mask)
{
  checkPtrType(object, "GdkWindow")
  

  w <- .RGtkCall("S_gdk_window_set_events", object, event.mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetIconList <-
function(object, pixbufs)
{
  checkPtrType(object, "GdkWindow")
  pixbufs <- lapply(pixbufs, function(x) { x <- as.GList(x); x })

  w <- .RGtkCall("S_gdk_window_set_icon_list", object, pixbufs, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetIcon <-
function(object, icon.window, pixmap, mask)
{
  checkPtrType(object, "GdkWindow")
  checkPtrType(icon.window, "GdkWindow")
  checkPtrType(pixmap, "GdkPixmap")
  checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gdk_window_set_icon", object, icon.window, pixmap, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetIconName <-
function(object, name)
{
  checkPtrType(object, "GdkWindow")
  name <- as.character(name)

  w <- .RGtkCall("S_gdk_window_set_icon_name", object, name, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowSetGroup <-
function(object, leader)
{
  checkPtrType(object, "GdkWindow")
  checkPtrType(leader, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_set_group", object, leader, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetGroup <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowSetDecorations <-
function(object, decorations)
{
  checkPtrType(object, "GdkWindow")
  

  w <- .RGtkCall("S_gdk_window_set_decorations", object, decorations, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetDecorations <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_get_decorations", object, PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowSetFunctions <-
function(object, functions)
{
  checkPtrType(object, "GdkWindow")
  

  w <- .RGtkCall("S_gdk_window_set_functions", object, functions, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowGetToplevels <-
function()
{
  

  w <- .RGtkCall("S_gdk_window_get_toplevels", PACKAGE = "RGtk2")

  return(w)
} 


gdkWindowIconify <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_iconify", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowDeiconify <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_deiconify", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowStick <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_stick", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowUnstick <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_unstick", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowMaximize <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_maximize", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowUnmaximize <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_unmaximize", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowFullscreen <-
function(object)
{
  checkPtrType(object, "GdkWindow")

  w <- .RGtkCall("S_gdk_window_fullscreen", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gdkWindowUnfullscreen