srvnet.c

一个linux下的根文件系统的源码

		if(cde->data) {
			GsWrite(current_fd, cde->data, cde->datalen);
			free(cde->data);
		} cde->datalen = 0;
	}
	GsWrite(current_fd, &ret, sizeof(GR_CHAR));

	/* EXPERIMENTAL CODE for GTK+ select wait*/
	if (ret == 0) {
		/* tell main loop to call Finish routine on event*/
		curclient->waiting_for_event = TRUE;
	}
}

static void
GrLineWrapper(void *r)
{
	nxLineReq *req = r;

	GrLine(req->drawid, req->gcid, req->x1, req->y1, req->x2, req->y2);
}

static void
GrPointWrapper(void *r)
{
	nxPointReq *req = r;

	GrPoint(req->drawid, req->gcid, req->x, req->y);

}

static void
GrPointsWrapper(void *r)
{
	nxPointsReq *req = r;
	int        count;

	count = GetReqVarLen(req) / sizeof(GR_POINT);
	GrPoints(req->drawid, req->gcid, count, (GR_POINT *)GetReqData(req));
}

static void
GrRectWrapper(void *r)
{
	nxRectReq *req = r;

	GrRect(req->drawid, req->gcid, req->x, req->y, req->width, req->height);
}

static void
GrFillRectWrapper(void *r)
{
	nxFillRectReq *req = r;

	GrFillRect(req->drawid, req->gcid, req->x, req->y, req->width,
		req->height);
}

static void
GrPolyWrapper(void *r)
{
	nxPolyReq *req = r;
	int        count;

	count = GetReqVarLen(req) / sizeof(GR_POINT);
	GrPoly(req->drawid, req->gcid, count, (GR_POINT *)GetReqData(req));
}

/* FIXME: fails with pointtable size > 64k if sizeof(int) == 2*/
static void
GrFillPolyWrapper(void *r)
{
	nxPolyReq *req = r;
	int        count;

	count = GetReqVarLen(req) / sizeof(GR_POINT);
	GrFillPoly(req->drawid, req->gcid, count, (GR_POINT *)GetReqData(req));
}

static void
GrEllipseWrapper(void *r)
{
	nxEllipseReq *req = r;

	GrEllipse(req->drawid, req->gcid, req->x, req->y, req->rx, req->ry);
}

static void
GrFillEllipseWrapper(void *r)
{
	nxFillEllipseReq *req = r;

	GrFillEllipse(req->drawid, req->gcid, req->x, req->y, req->rx, req->ry);
}

static void
GrArcWrapper(void *r)
{
	nxArcReq *req = r;

	GrArc(req->drawid, req->gcid, req->x, req->y, req->rx, req->ry,
		req->ax, req->ay, req->bx, req->by, req->type);
}

static void
GrArcAngleWrapper(void *r)
{
	nxArcAngleReq *req = r;

	GrArcAngle(req->drawid, req->gcid, req->x, req->y, req->rx, req->ry,
		req->angle1, req->angle2, req->type);
}

static void
GrSetGCForegroundWrapper(void *r)
{
	nxSetGCForegroundReq *req = r;

	GrSetGCForeground(req->gcid, req->color);
}

static void
GrSetGCBackgroundWrapper(void *r)
{
	nxSetGCBackgroundReq *req = r;

	GrSetGCBackground(req->gcid, req->color);
}

static void
GrSetGCForegroundPixelValWrapper(void *r)
{
	nxSetGCForegroundPixelValReq *req = r;

	GrSetGCForegroundPixelVal(req->gcid, req->pixelval);
}

static void
GrSetGCBackgroundPixelValWrapper(void *r)
{
	nxSetGCBackgroundPixelValReq *req = r;

	GrSetGCBackgroundPixelVal(req->gcid, req->pixelval);
}

static void
GrSetGCUseBackgroundWrapper(void *r)
{
	nxSetGCUseBackgroundReq *req = r;

	GrSetGCUseBackground(req->gcid, req->flag);
}

static void
GrSetGCModeWrapper(void *r)
{
	nxSetGCModeReq *req = r;

	GrSetGCMode(req->gcid, req->mode);
}

static void
GrSetGCLineAttributesWrapper(void *r)
{
	nxSetGCLineAttributesReq *req = r;

	GrSetGCLineAttributes(req->gcid, req->linestyle);
}

static void
GrSetGCDashWrapper(void *r)
{
	nxSetGCDashReq *req = r;
	char *buffer = ALLOCA(req->count);

	memcpy((void *) buffer, GetReqData(req), req->count);
	GrSetGCDash(req->gcid, buffer, req->count);
	FREEA(buffer);
}


static void
GrSetGCFillModeWrapper(void *r)
{
	nxSetGCFillModeReq *req = r;

	GrSetGCFillMode(req->gcid, req->fillmode);
}

static void
GrSetGCStippleWrapper(void *r)
{
	nxSetGCStippleReq *req = r;
	GR_BITMAP *buffer;
	
	buffer = ALLOCA(GR_BITMAP_SIZE(req->width, req->height) *
		sizeof(GR_BITMAP));

	memcpy((void *) buffer, GetReqData(req),
	       GR_BITMAP_SIZE(req->width, req->height) * sizeof(GR_BITMAP));

	GrSetGCStipple(req->gcid, (GR_BITMAP *)buffer, req->width, req->height);
	FREEA(buffer);
}

static void
GrSetGCTileWrapper(void *r)
{
	nxSetGCTileReq *req = r;

	GrSetGCTile(req->gcid, req->pixmap, req->width, req->height);
}

static void
GrSetGCTSOffsetWrapper(void *r)
{
	nxSetGCTSOffsetReq *req = r;

	GrSetGCTSOffset(req->gcid, req->xoffset, req->yoffset);
}

static void
GrCreateFontWrapper(void *r)
{
	nxCreateFontReq *req = r;
	GR_FONT_ID 	fontid;

	fontid = GrCreateFont(GetReqData(req), req->height, NULL);

	GsWriteType(current_fd,GrNumCreateFont);
	GsWrite(current_fd, &fontid, sizeof(fontid));
}

static void
GrCreateLogFontWrapper(void *r)
{
	nxCreateLogFontReq *req = r;
	GR_FONT_ID fontid;

	fontid = GrCreateFont(NULL, 0, &req->lf);

	GsWriteType(current_fd, GrNumCreateLogFont);
	GsWrite(current_fd, &fontid, sizeof(fontid));
}

static void
GrSetFontSizeWrapper(void *r)
{
	nxSetFontSizeReq *req = r;

 	GrSetFontSize(req->fontid, req->fontsize);
}

static void
GrSetFontRotationWrapper(void *r)
{
	nxSetFontRotationReq *req = r;

 	GrSetFontRotation(req->fontid, req->tenthdegrees);
}

static void
GrSetFontAttrWrapper(void *r)
{
	nxSetFontAttrReq *req = r;

 	GrSetFontAttr(req->fontid, req->setflags, req->clrflags);
}

static void
GrDestroyFontWrapper(void *r)
{
	nxDestroyFontReq *req = r;

	GrDestroyFont(req->fontid);
}

static void
GrSetGCFontWrapper(void *r)
{
	nxSetGCFontReq *req = r;

	GrSetGCFont(req->gcid, req->fontid);
}

static void
GrGetGCTextSizeWrapper(void *r)
{
	nxGetGCTextSizeReq *req = r;
	GR_SIZE             retwidth, retheight, retbase;

	GrGetGCTextSize(req->gcid, GetReqData(req), req->charcount,
		req->flags, &retwidth, &retheight, &retbase);

 	GsWriteType(current_fd,GrNumGetGCTextSize);
	GsWrite(current_fd, &retwidth, sizeof(retwidth));
	GsWrite(current_fd, &retheight, sizeof(retheight));
	GsWrite(current_fd, &retbase, sizeof(retbase));
}

/* FIXME: fails with size > 64k if sizeof(int) == 2*/
static void
GrReadAreaWrapper(void *r)
{
	nxReadAreaReq *req = r;
	int            size;
	GR_PIXELVAL *   area;

	/* FIXME: optimize for smaller pixelvals*/
	size = req->width * req->height * sizeof(GR_PIXELVAL);

	if(!(area = malloc(size))) {
		/*GsPutCh(current_fd, GrRetENoMem);*/ /* FIXME*/
		/*return;*/
	}

	GrReadArea(req->drawid, req->x, req->y, req->width, req->height, area);
	GsWriteType(current_fd,GrNumReadArea);
	GsWrite(current_fd, area, size);
	free(area);
}

/* FIXME: fails with size > 64k if sizeof(int) == 2*/
static void
GrAreaWrapper(void *r)
{
	nxAreaReq *req = r;

	GrArea(req->drawid, req->gcid, req->x, req->y, req->width, req->height,
		GetReqData(req), req->pixtype);
}

/* FIXME: fails with bitmapsize > 64k if sizeof(int) == 2*/
static void
GrBitmapWrapper(void *r)
{
	nxBitmapReq *req = r;

	GrBitmap(req->drawid, req->gcid, req->x, req->y, req->width,
		req->height, GetReqData(req));
}

static void
GrDrawImageBitsWrapper(void *r)
{
	nxDrawImageBitsReq *req = r;
	char *		    addr;
	int		    imagesize;
	GR_IMAGE_HDR	    hdr;

	hdr.width = req->width;
	hdr.height = req->height;
	hdr.planes = req->planes;
	hdr.bpp = req->bpp;
	hdr.pitch = req->pitch;
	hdr.bytesperpixel = req->bytesperpixel;
	hdr.compression = req->compression;
	hdr.palsize = req->palsize;
	hdr.transcolor = req->transcolor;
	addr = GetReqData(req);
	hdr.imagebits = (MWUCHAR *)addr;
	imagesize = hdr.pitch * hdr.height;
	hdr.palette = (MWPALENTRY *)(addr + imagesize);
	GrDrawImageBits(req->drawid, req->gcid, req->x, req->y, &hdr);
}

static void
GrCopyAreaWrapper(void *r)
{
	nxCopyAreaReq *req = r;

	GrCopyArea(req->drawid, req->gcid, req->x, req->y, req->width, req->height,
		req->srcid, req->srcx, req->srcy, req->op);
}

static void
GrTextWrapper(void *r)
{
	nxTextReq *req = r;

	GrText(req->drawid, req->gcid, req->x, req->y, GetReqData(req),
		req->count, req->flags);
}

static void
GrNewCursorWrapper(void *r)
{
	nxNewCursorReq *req = r;
	int		varlen;
	char *          bitmap;
	GR_CURSOR_ID	cursorid;

	varlen = GetReqVarLen(req);
	bitmap = GetReqData(req);

	cursorid = GrNewCursor(req->width, req->height,
		req->hotx, req->hoty, req->fgcolor, req->bgcolor,
		(GR_BITMAP *)bitmap, (GR_BITMAP *)(bitmap+varlen/2));

	GsWriteType(current_fd, GrNumNewCursor);
	GsWrite(current_fd, &cursorid, sizeof(cursorid));
}

static void
GrMoveCursorWrapper(void *r)
{
	nxMoveCursorReq *req = r;

	GrMoveCursor(req->x, req->y);
}

static void
GrGetSystemPaletteWrapper(void *r)
{
	GR_PALETTE             pal;

	GrGetSystemPalette(&pal);
	GsWriteType(current_fd,GrNumGetSystemPalette);
	GsWrite(current_fd, &pal, sizeof(pal));
}

static void
GrSetSystemPaletteWrapper(void *r)
{
	nxSetSystemPaletteReq *req = r;
	GR_PALETTE	       pal;

	pal.count = req->count;
	memcpy(pal.palette, req->palette, sizeof(pal.palette));
	GrSetSystemPalette(req->first, &pal);
}

static void
GrFindColorWrapper(void *r)
{
	nxFindColorReq *req = r;
	GR_PIXELVAL	pixel;

	GrFindColor(req->color, &pixel);
	GsWriteType(current_fd,GrNumFindColor);
	GsWrite(current_fd, &pixel, sizeof(pixel));
}

static void
GrInjectEventWrapper(void *r)
{
	nxInjectEventReq *req = r;

	switch(req->event_type) {
	case GR_INJECT_EVENT_POINTER:
		GrInjectPointerEvent(req->event.pointer.x,
				     req->event.pointer.y,
				     req->event.pointer.button,
				     req->event.pointer.visible);
		break;

	case GR_INJECT_EVENT_KEYBOARD:
		GrInjectKeyboardEvent(req->event.keyboard.wid,
				      req->event.keyboard.keyvalue,
				      req->event.keyboard.modifier,
				      req->event.keyboard.scancode,
				      req->event.keyboard.pressed);
		break;
	}
}

static void
GrSetWMPropertiesWrapper(void *r)
{
	nxSetWMPropertiesReq *req = r;
	GR_WM_PROPERTIES *props = GetReqData(req);

	if(GetReqVarLen(req) - sizeof(GR_WM_PROPERTIES)) 
		props->title = (GR_CHAR *)props + sizeof(GR_WM_PROPERTIES);
	else
		props->title = NULL;
	GrSetWMProperties(req->windowid, props);
}

static void
GrGetWMPropertiesWrapper(void *r)
{
	nxGetWMPropertiesReq *req = r;
	UINT16 textlen;
	GR_WM_PROPERTIES props;
	
	GrGetWMProperties(req->windowid, &props);

	if(props.title)
		textlen = strlen((const char *)props.title) + 1;
	else textlen = 0;

	GsWriteType(current_fd,GrNumGetWMProperties);
	GsWrite(current_fd, &props, sizeof(props));
	GsWrite(current_fd, &textlen, sizeof(textlen));
	if(textlen)
		GsWrite(current_fd, props.title, textlen);
}

static void
GrCloseWindowWrapper(void *r)
{
	nxCloseWindowReq *req = r;

	GrCloseWindow(req->windowid);
}

static void
GrKillWindowWrapper(void *r)
{
	nxKillWindowReq *req = r;

	GrKillWindow(req->windowid);
}

#if MW_FEATURE_IMAGES && defined(HAVE_FILEIO)
static void
GrDrawImageFromFileWrapper(void *r)
{
	nxDrawImageFromFileReq *req = r;

	GrDrawImageFromFile(req->drawid, req->gcid, req->x, req->y, req->width,
		req->height, GetReqData(req), req->flags);
}

static void
GrLoadImageFromFileWrapper(void *r)
{
	nxLoadImageFromFileReq *req = r;
	GR_IMAGE_ID		id;

	id = GrLoadImageFromFile(GetReqData(req), req->flags);
	GsWriteType(current_fd, GrNumLoadImageFromFile);
	GsWrite(current_fd, &id, sizeof(id));
}
#else /* if ! (MW_FEATURE_IMAGES && defined(HAVE_FILEIO)) */
#define GrDrawImageFromFileWrapper GrNotImplementedWrapper
#define GrLoadImageFromFileWrapper GrNotImplementedWrapper
#endif

#if MW_FEATURE_IMAGES
static void
GrDrawImageToFitWrapper(void *r)
{
	nxDrawImageToFitReq *req = r;

	GrDrawImageToFit(req->drawid, req->gcid, req->x, req->y, req->width,
		req->height, req->imageid);
}

static void
GrFreeImageWrapper(void *r)
{
	nxFreeImageReq *req = r;

	GrFreeImage(req->id);
}