Return to XMacros.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / X

Annotation of researchv9/X11/src/X.V11R1/lib/X/XMacros.c, revision 1.1

1.1     ! root        1: #include "copyright.h"
        !             2: 
        !             3: /* $Header: XMacros.c,v 11.18 87/09/11 17:24:30 newman Exp $ */
        !             4: /* Copyright    Massachusetts Institute of Technology    1987  */
        !             5: 
        !             6: #include "Xlibint.h"
        !             7: /*
        !             8:  * This file makes full definitions of routines for each macro.
        !             9:  * We do not expect C programs to use these, but other languages may
        !            10:  * need them.
        !            11:  */
        !            12: 
        !            13: int XConnectionNumber(dpy) Display *dpy; { return (ConnectionNumber(dpy)); }
        !            14: 
        !            15: Window XRootWindow (dpy, scr)
        !            16:     Display *dpy; int scr;
        !            17:        {       return (RootWindow(dpy,scr));   }
        !            18: 
        !            19: int XDefaultScreen(dpy) Display *dpy; { return (DefaultScreen(dpy)); }
        !            20: 
        !            21: Window XDefaultRootWindow (dpy)
        !            22:     Display *dpy;
        !            23:        {       return (RootWindow(dpy,DefaultScreen(dpy)));    }
        !            24: 
        !            25: Visual *XDefaultVisual(dpy, scr)
        !            26:     Display *dpy; int scr;
        !            27:        {       return (DefaultVisual(dpy, scr)); }
        !            28: 
        !            29: GC XDefaultGC(dpy, scr) 
        !            30:     Display *dpy; int scr;
        !            31:        {       return (DefaultGC(dpy,scr)); }
        !            32: 
        !            33: unsigned long XBlackPixel(dpy, scr) 
        !            34:     Display *dpy; int scr; 
        !            35:        {       return (BlackPixel(dpy, scr)); }
        !            36: 
        !            37: unsigned long XWhitePixel(dpy, scr) 
        !            38:     Display *dpy; int scr; 
        !            39:        {       return (WhitePixel(dpy,scr)); }
        !            40: 
        !            41: unsigned long XAllPlanes() { return AllPlanes; }
        !            42: 
        !            43: int XQLength(dpy) Display *dpy; { return (QLength(dpy)); }
        !            44: 
        !            45: int XDisplayWidth(dpy, scr)
        !            46:     Display *dpy; int scr;
        !            47:        { return (DisplayWidth(dpy,scr)); }
        !            48: 
        !            49: int XDisplayHeight(dpy, scr)
        !            50:     Display *dpy; int scr;
        !            51:        { return (DisplayHeight(dpy, scr)); }
        !            52: 
        !            53: int XDisplayWidthMM(dpy, scr)
        !            54:     Display *dpy; int scr;
        !            55:        { return (DisplayWidthMM(dpy, scr)); }
        !            56: 
        !            57: int XDisplayHeightMM(dpy, scr)
        !            58:     Display *dpy; int scr;
        !            59:        { return (DisplayHeightMM(dpy, scr)); }
        !            60: 
        !            61: int XDisplayPlanes(dpy, scr)
        !            62:     Display *dpy; int scr;
        !            63:        { return (DisplayPlanes(dpy, scr)); }
        !            64: 
        !            65: int XDisplayCells(dpy, scr)
        !            66:     Display *dpy; int scr;
        !            67:        { return (DisplayCells (dpy, scr)); }
        !            68: 
        !            69: int XScreenCount(dpy) Display *dpy; { return (ScreenCount(dpy)); }
        !            70: 
        !            71: char *XServerVendor(dpy)  Display *dpy; { return (ServerVendor(dpy)); }
        !            72: 
        !            73: int XProtocolVersion(dpy)  Display *dpy; { return (ProtocolVersion(dpy)); }
        !            74: 
        !            75: int XProtocolRevision(dpy)  Display *dpy; { return (ProtocolRevision(dpy));}
        !            76: 
        !            77: int XVendorRelease(dpy)  Display *dpy; { return (VendorRelease(dpy)); }
        !            78: 
        !            79: char *XDisplayString(dpy)  Display *dpy; { return (DisplayString(dpy)); }
        !            80: 
        !            81: int XDefaultDepth(dpy, scr) 
        !            82:     Display *dpy; int scr;
        !            83:        { return(DefaultDepth(dpy, scr)); }
        !            84: 
        !            85: Colormap XDefaultColormap(dpy, scr)
        !            86:     Display *dpy; int scr;
        !            87:        { return (DefaultColormap(dpy, scr)); }
        !            88: 
        !            89: int XBitmapUnit(dpy) Display *dpy; { return (BitmapUnit(dpy)); }
        !            90: 
        !            91: int XBitmapBitOrder(dpy) Display *dpy; { return (BitmapBitOrder(dpy)); }
        !            92: 
        !            93: int XBitmapPad(dpy) Display *dpy; { return (BitmapPad(dpy)); }
        !            94: 
        !            95: int XImageByteOrder(dpy) Display *dpy; { return (ImageByteOrder(dpy)); }
        !            96: 
        !            97: /* screen oriented macros (toolkit) */
        !            98: Screen *XScreenOfDisplay(dpy, scr) Display *dpy; int scr;
        !            99:        { return (ScreenOfDisplay(dpy, scr)); }
        !           100: 
        !           101: Screen *XDefaultScreenOfDisplay(dpy) Display *dpy;
        !           102:        { return (DefaultScreenOfDisplay(dpy)); }
        !           103: 
        !           104: Display *XDisplayOfScreen(s) Screen *s; { return (DisplayOfScreen(s)); }
        !           105: 
        !           106: Window XRootWindowOfScreen(s) Screen *s; { return (RootWindowOfScreen(s)); }
        !           107: 
        !           108: unsigned long XBlackPixelOfScreen(s) Screen *s; 
        !           109:        { return (BlackPixelOfScreen(s)); }
        !           110: 
        !           111: unsigned long XWhitePixelOfScreen(s) Screen *s; 
        !           112:        { return (WhitePixelOfScreen(s)); }
        !           113: 
        !           114: Colormap XDefaultColormapOfScreen(s) Screen *s; 
        !           115:        { return (DefaultColormapOfScreen(s)); }
        !           116: 
        !           117: int XDefaultDepthOfScreen(s) Screen *s; { return (DefaultDepthOfScreen(s)); }
        !           118: 
        !           119: GC XDefaultGCOfScreen(s) Screen *s; { return (DefaultGCOfScreen(s)); }
        !           120: 
        !           121: Visual *XDefaultVisualOfScreen(s) Screen *s; 
        !           122:        { return (DefaultVisualOfScreen(s)); }
        !           123: 
        !           124: int XWidthOfScreen(s) Screen *s; { return (WidthOfScreen(s)); }
        !           125: 
        !           126: int XHeightOfScreen(s) Screen *s; { return (HeightOfScreen(s)); }
        !           127: 
        !           128: int XWidthMMOfScreen(s) Screen *s; { return (WidthMMOfScreen(s)); }
        !           129: 
        !           130: int XHeightMMOfScreen(s) Screen *s; { return (HeightMMOfScreen(s)); }
        !           131: 
        !           132: int XPlanesOfScreen(s) Screen *s; { return (PlanesOfScreen(s)); }
        !           133: 
        !           134: int XCellsOfScreen(s) Screen *s; { return (CellsOfScreen(s)); }
        !           135: 
        !           136: int XMinCmapsOfScreen(s) Screen *s; { return (MinCmapsOfScreen(s)); }
        !           137: 
        !           138: int XMaxCmapsOfScreen(s) Screen *s; { return (MaxCmapsOfScreen(s)); }
        !           139: 
        !           140: Bool XDoesSaveUnders(s) Screen *s; { return (DoesSaveUnders(s)); }
        !           141: 
        !           142: int XDoesBackingStore(s) Screen *s; { return (DoesBackingStore(s)); }
        !           143: 
        !           144: long XEventMaskOfScreen(s) Screen *s; { return (EventMaskOfScreen(s)); }
        !           145: 
        !           146: /*
        !           147:  * These macros are used to give some sugar to the image routines so that
        !           148:  * naive people are more comfortable with them.
        !           149:  */
        !           150: #undef XDestroyImage(ximage)
        !           151: XDestroyImage(ximage)
        !           152:        XImage *ximage;
        !           153: {
        !           154:        return((*((ximage)->f.destroy_image))((ximage)));
        !           155: }
        !           156: #undef XGetPixel(ximage, x, y)
        !           157: unsigned long XGetPixel(ximage, x, y)
        !           158:        XImage *ximage;
        !           159:        int x, y;
        !           160: {
        !           161:        return ((*((ximage)->f.get_pixel))((ximage), (x), (y)));
        !           162: }
        !           163: #undef XPutPixel(ximage, x, y, pixel)
        !           164: int XPutPixel(ximage, x, y, pixel)
        !           165:        XImage *ximage;
        !           166:        int x, y;
        !           167:        unsigned long pixel;
        !           168: {
        !           169:        return((*((ximage)->f.put_pixel))((ximage), (x), (y), (pixel)));
        !           170: }
        !           171: #undef XSubImage(ximage, x, y, width, height)
        !           172: XImage *XSubImage(ximage, x, y, width, height)
        !           173:        XImage *ximage;
        !           174:        int x, y;
        !           175:        unsigned int width, height;
        !           176: {
        !           177:        return((*((ximage)->f.sub_image))((ximage), (x),
        !           178:                (y), (width), (height)));
        !           179: }
        !           180: #undef XAddPixel(ximage, value)
        !           181: int XAddPixel(ximage, value)
        !           182:        XImage *ximage;
        !           183:        unsigned long value;
        !           184: {
        !           185:        return((*((ximage)->f.add_pixel))((ximage), (value)));
        !           186: }
        !           187: 
        !           188: 
        !           189: XNoOp (dpy)
        !           190:     register Display *dpy;
        !           191: {
        !           192:     register xReq *req;
        !           193: 
        !           194:     LockDisplay(dpy);
        !           195:     GetEmptyReq(NoOperation, req);
        !           196: 
        !           197:     UnlockDisplay(dpy);
        !           198: }
        !           199: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.