예제 #1
0
파일: region.c 프로젝트: technosaurus/tekui
static TBOOL region_andrect_internal(struct RectList *temp,
	struct Region *region, TINT s[], TINT dx, TINT dy)
{
	struct RectPool *pool = region->rg_Pool;
	struct TNode *next, *node = region->rg_Rects.rl_List.tlh_Head;
	TBOOL success = TTRUE;
	TINT s0 = s[0] + dx;
	TINT s1 = s[1] + dy;
	TINT s2 = s[2] + dx;
	TINT s3 = s[3] + dy;
	for (; success && (next = node->tln_Succ); node = next)
	{
		struct RectNode *dr = (struct RectNode *) node;
		TINT x0 = dr->rn_Rect[0];
		TINT y0 = dr->rn_Rect[1];
		TINT x1 = dr->rn_Rect[2];
		TINT y1 = dr->rn_Rect[3];
		if (OVERLAP(x0, y0, x1, y1, s0, s1, s2, s3))
		{
			success = region_insertrect(pool, temp,
				TMAX(x0, s0), TMAX(y0, s1), TMIN(x1, s2), TMIN(y1, s3));
		}
	}
	if (!success)
		region_freerects(pool, temp);
	return success;
}
예제 #2
0
static void rfb_drawpointer(struct rfb_Display *mod)
{
	TINT x0 = mod->rfb_MouseX - mod->rfb_MouseHotX;
	TINT y0 = mod->rfb_MouseY - mod->rfb_MouseHotY;

	if (mod->rfb_Flags & RFBFL_PTR_VISIBLE)
	{
		if (x0 == mod->rfb_PtrBackBuffer.rect[0] &&
			y0 == mod->rfb_PtrBackBuffer.rect[1])
			return;
		rfb_restorebackbuf(mod, &mod->rfb_PtrBackBuffer);
	}

	TINT s0 = 0;
	TINT s1 = 0;
	TINT s2 = mod->rfb_Width - 1;
	TINT s3 = mod->rfb_Height - 1;
	TINT x1 = x0 + mod->rfb_PtrWidth - 1;
	TINT y1 = y0 + mod->rfb_PtrHeight - 1;

	if (REGION_OVERLAP(s0, s1, s2, s3, x0, y0, x1, y1))
	{
		struct TVPixBuf dst = mod->rfb_DevBuf;

		x0 = TMAX(x0, s0);
		y0 = TMAX(y0, s1);
		x1 = TMIN(x1, s2);
		y1 = TMIN(y1, s3);
		rfb_storebackbuf(mod, &mod->rfb_PtrBackBuffer, x0, y0, x1, y1);
		pixconv_convert(&mod->rfb_PtrImage, &dst, x0, y0, x1, y1, 0, 0,
			TTRUE, TFALSE);
	}

	mod->rfb_Flags |= RFBFL_PTR_VISIBLE;
}
예제 #3
0
LOCAL void win_getminmax(WINWINDOW *win, TINT *pm1, TINT *pm2, TINT *pm3,
	TINT *pm4, TBOOL windowsize)
{
	TINT m1 = win->fbv_MinWidth;
	TINT m2 = win->fbv_MinHeight;
	TINT m3 = win->fbv_MaxWidth;
	TINT m4 = win->fbv_MaxHeight;
	m1 = TMAX(0, m1);
	m2 = TMAX(0, m2);
	m3 = m3 < 0 ? 1000000 : m3;
	m4 = m4 < 0 ? 1000000 : m4;
	m3 = TMAX(m3, m1);
	m4 = TMAX(m4, m2);
	if (windowsize)
	{
		m1 += win->fbv_BorderWidth;
		m2 += win->fbv_BorderHeight;
		m3 += win->fbv_BorderWidth;
		m4 += win->fbv_BorderHeight;
	}
	*pm1 = m1;
	*pm2 = m2;
	*pm3 = m3;
	*pm4 = m4;
}
예제 #4
0
LOCAL void
fb_setattrs(WINDISPLAY *mod, struct TVRequest *req)
{
	struct attrdata data;
	struct THook hook;
	WINWINDOW *win = req->tvr_Op.SetAttrs.Window;
	TINT neww, newh;
	data.v = win;
	data.num = 0;
	data.mod = mod;
	data.neww = -1;
	data.newh = -1;
	TInitHook(&hook, setattrfunc, &data);
	TForEachTag(req->tvr_Op.SetAttrs.Tags, &hook);
	req->tvr_Op.SetAttrs.Num = data.num;

	win_getminmax(win, &win->fbv_MinWidth, &win->fbv_MinHeight,
		&win->fbv_MaxWidth, &win->fbv_MaxHeight, TFALSE);
	neww = data.neww < 0 ? (TINT) win->fbv_Width : data.neww;
	newh = data.newh < 0 ? (TINT) win->fbv_Height : data.newh;

	if (neww < win->fbv_MinWidth || newh < win->fbv_MinHeight)
	{
		neww = TMAX(neww, win->fbv_MinWidth);
		newh = TMAX(newh, win->fbv_MinHeight);
		neww += win->fbv_BorderWidth;
		newh += win->fbv_BorderHeight;
		SetWindowPos(win->fbv_HWnd, NULL, 0, 0, neww, newh, SWP_NOMOVE);
	}
}
예제 #5
0
파일: region.c 프로젝트: technosaurus/tekui
TLIBAPI TBOOL region_orrectlist(struct RectPool *pool, struct RectList *list, 
	TINT s[4], TBOOL opportunistic)
{
	if (list->rl_NumNodes > 0)
	{
		TINT x0 = s[0];
		TINT y0 = s[1];
		TINT x1 = s[2];
		TINT y1 = s[3];
		TUINT64 area = 0;
		
		struct TNode *next, *node = list->rl_List.tlh_Head;
		for (; (next = node->tln_Succ); node = next)
		{
			struct RectNode *rn = (struct RectNode *) node;
			TINT *r = rn->rn_Rect;
			if (s[0] >= r[0] && s[1] >= r[1] &&
				s[2] <= r[2] && s[3] <= r[3])
				return TTRUE;
			if (!opportunistic)
				continue;
			area += (r[2] - r[0] + 1) * (r[3] - r[1] + 1);
			x0 = TMIN(x0, r[0]);
			y0 = TMIN(y0, r[1]);
			x1 = TMAX(x1, r[2]);
			y1 = TMAX(y1, r[3]);
		}
		if (opportunistic)
		{
			TUINT64 area2 = (x1 - x0 + 1) * (y1 - y0 + 1);
			if (area2 < OPPORTUNISTIC_MERGE_THRESHOLD ||
				(area * 256 / area2) > OPPORTUNISTIC_MERGE_RATIO)
			{
				/* merge list into a single rectangle */
				TDBPRINTF(TDB_TRACE,("merge %d rects\n",
					list->rl_NumNodes + 1));
				region_freerects(pool, list);
				assert(list->rl_NumNodes == 0);
				return region_insertrect(pool, list, x0, y0, x1, y1);
			}
		}
	}

	struct RectList temp;
	region_initrectlist(&temp);
	if (region_cutrectlist(pool, list, &temp, s))
	{
		if (region_insertrect(pool, &temp, s[0], s[1], s[2], s[3]))
		{
			region_freerects(pool, list);
			region_relinkrects(list, &temp);
			return TTRUE;
		}
	}
	region_freerects(pool, &temp);
	return TFALSE;
}
예제 #6
0
LOCAL void
dfb_setattrs(DFBDISPLAY *mod, struct TVRequest *req)
{
	struct attrdata data;
	struct THook hook;
	DFBWINDOW *v = req->tvr_Op.SetAttrs.Window;

	data.v = v;
	data.num = 0;
	data.mod = mod;
	data.sizechanged = TFALSE;
	TInitHook(&hook, setattrfunc, &data);

	TForEachTag(req->tvr_Op.SetAttrs.Tags, &hook);
	req->tvr_Op.SetAttrs.Num = data.num;

	if (data.sizechanged)
	{
		TIMSG *imsg;

		v->wminwidth = v->wminwidth <= 0 ? 1 : v->wminwidth;
		v->wminheight = v->wminheight <= 0 ? 1 : v->wminheight;
		v->wmaxwidth = v->wmaxwidth <= 0 ? 1000000 : v->wmaxwidth;
		v->wmaxheight = v->wmaxheight <= 0 ? 1000000 : v->wmaxheight;

		if (v->wmaxwidth > 0)
			v->winwidth = TMIN(v->winwidth, v->wmaxwidth);
		if (v->wmaxheight > 0)
			v->winheight = TMIN(v->winheight, v->wmaxheight);
		if (v->wminwidth > 0)
			v->winwidth = TMAX(v->winwidth, v->wminwidth);
		if (v->wminheight > 0)
			v->winheight = TMAX(v->winheight, v->wminheight);

		v->window->Resize(v->window, v->winwidth, v->winheight);

		if ((v->eventmask & TITYPE_NEWSIZE) &&
			getimsg(mod, v, &imsg, TITYPE_NEWSIZE))
		{
			imsg->timsg_Width = v->winwidth;
			imsg->timsg_Height = v->winheight;
			TAddTail(&v->imsgqueue, &imsg->timsg_Node);
		}

		if ((v->eventmask & TITYPE_REFRESH) &&
			getimsg(mod, v, &imsg, TITYPE_REFRESH))
		{
			imsg->timsg_X = v->winleft;
			imsg->timsg_Y = v->wintop;
			imsg->timsg_Width = v->winwidth;
			imsg->timsg_Height = v->winheight;
			TAddTail(&v->imsgqueue, &imsg->timsg_Node);
		}
	}
}
예제 #7
0
파일: region.c 프로젝트: technosaurus/tekui
TLIBAPI TBOOL region_intersect(TINT *d, TINT *s)
{
	if (OVERLAP(d[0], d[1], d[2], d[3], s[0], s[1], s[2], s[3]))
	{
		d[0] = TMAX(d[0], s[0]);
		d[1] = TMAX(d[1], s[1]);
		d[2] = TMIN(d[2], s[2]);
		d[3] = TMIN(d[3], s[3]);
		return TTRUE;
	}
	return TFALSE;
}
예제 #8
0
LOCAL void
fb_setattrs(WINDISPLAY *mod, struct TVRequest *req)
{
	struct attrdata data;
	struct THook hook;
	WINWINDOW *win = req->tvr_Op.SetAttrs.Window;
	TINT noww, nowh, neww, newh, minw, minh;
	data.v = win;
	data.num = 0;
	data.mod = mod;
	data.neww = -1;
	data.newh = -1;
	TInitHook(&hook, setattrfunc, &data);

	EnterCriticalSection(&win->fbv_LockExtents);

	TForEachTag(req->tvr_Op.SetAttrs.Tags, &hook);

	win_getminmax(win, &win->fbv_MinWidth, &win->fbv_MinHeight,
		&win->fbv_MaxWidth, &win->fbv_MaxHeight, TFALSE);

	noww = (TINT) win->fbv_Width;
	nowh = (TINT) win->fbv_Height;
	minw = (TINT) win->fbv_MinWidth;
	minh = (TINT) win->fbv_MinHeight;

	LeaveCriticalSection(&win->fbv_LockExtents);

	neww = data.neww < 0 ? noww : data.neww;
	newh = data.newh < 0 ? nowh : data.newh;

	if (neww < minw || newh < minh)
	{
		neww = TMAX(neww, minw);
		newh = TMAX(newh, minh);
		neww += win->fbv_BorderWidth;
		newh += win->fbv_BorderHeight;
		SetWindowPos(win->fbv_HWnd, NULL, 0, 0, neww, newh, SWP_NOMOVE);
	}

	req->tvr_Op.SetAttrs.Num = data.num;
}
예제 #9
0
파일: region.c 프로젝트: AntonioModer/tekui
static int lib_overlap(lua_State *L)
{
	TINT d0 = luaL_checkinteger(L, 1);
	TINT d1 = luaL_checkinteger(L, 2);
	TINT d2 = luaL_checkinteger(L, 3);
	TINT d3 = luaL_checkinteger(L, 4);
	TINT s0 = luaL_checkinteger(L, 5);
	TINT s1 = luaL_checkinteger(L, 6);
	TINT s2 = luaL_checkinteger(L, 7);
	TINT s3 = luaL_checkinteger(L, 8);

	if (OVERLAP(d0, d1, d2, d3, s0, s1, s2, s3))
	{
		lua_pushinteger(L, TMAX(s0, d0));
		lua_pushinteger(L, TMAX(s1, d1));
		lua_pushinteger(L, TMIN(s2, d2));
		lua_pushinteger(L, TMIN(s3, d3));
		return 4;
	}
	return 0;
}
예제 #10
0
파일: region.c 프로젝트: technosaurus/tekui
TLIBAPI TBOOL region_getminmax(struct RectPool *pool, struct Region *region,
	TINT *minmax)
{
	if (region_isempty(pool, region))
		return TFALSE;
	TINT minx = 1000000;
	TINT miny = 1000000;
	TINT maxx = 0;
	TINT maxy = 0;
	struct TNode *next, *node = region->rg_Rects.rl_List.tlh_Head;
	for (; (next = node->tln_Succ); node = next)
	{
		struct RectNode *rn = (struct RectNode *) node;
		minx = TMIN(minx, rn->rn_Rect[0]);
		miny = TMIN(miny, rn->rn_Rect[1]);
		maxx = TMAX(maxx, rn->rn_Rect[2]);
		maxy = TMAX(maxy, rn->rn_Rect[3]);
	}
	minmax[0] = minx;
	minmax[1] = miny;
	minmax[2] = maxx;
	minmax[3] = maxy;
	return TTRUE;
}
예제 #11
0
파일: region.c 프로젝트: AntonioModer/tekui
static int region_overlaprect(lua_State *L)
{
	struct RectNode *rn = lua_touserdata(L, 2);

	TINT s0 = lua_tointeger(L, 3);
	TINT s1 = lua_tointeger(L, 4);
	TINT s2 = lua_tointeger(L, 5);
	TINT s3 = lua_tointeger(L, 6);
	TINT d0 = rn->rn_Rect[0];
	TINT d1 = rn->rn_Rect[1];
	TINT d2 = rn->rn_Rect[2];
	TINT d3 = rn->rn_Rect[3];

	if (OVERLAP(d0, d1, d2, d3, s0, s1, s2, s3))
	{
		lua_pushinteger(L, TMAX(s0, d0));
		lua_pushinteger(L, TMAX(s1, d1));
		lua_pushinteger(L, TMIN(s2, d2));
		lua_pushinteger(L, TMIN(s3, d3));
		return 4;
	}

	return 0;
}
예제 #12
0
int processPacket( char *packet, metaData_t *meta, void *flowdata )
{
	int i;
	struct timeval rtt;
	struct moduleData *data;
	struct icmp_echo_hdr *hdr;

	if ((meta->layers[2] != T_ICMP) && (meta->layers[2] != T_ICMP6)) {  // only use ICMP packets!
	    return 0;
	}

	data = (struct moduleData *) flowdata;
	hdr = (struct icmp_echo_hdr *) (&packet[meta->offs[2]]); /* skip layer 1 and 2 */

    // only want echo request and reply
	if ((hdr->type != 8) && (hdr->type != 0)) {
        return 0;
    }
    // dont want "unreachable" replies
	if (hdr->code != 0) {
        return 0;
    }

	if (hdr->type == 8 ) {  /* ICMP echo */

	    /* find new unused entry - if possible */
	    data->curr = 0;
	    if (data->free > 0) {
            while (data->list[data->curr].id != 0) {
                data->curr += 1;
            }
        }
	    
	    data->list[data->curr].id = hdr->id;
	    data->list[data->curr].seqno = hdr->seqno;
	    data->list[data->curr].tstamp.tv_sec = meta->tv_sec;
	    data->list[data->curr].tstamp.tv_usec = meta->tv_usec;

	    if (data->free > 0) {
            data->free -= 1;
        }

	} else {   /* ICMP reply */

	    for ( i = 0; i < data->lsize; i++ ) {
		
            if (data->list[i].id == 0) {
                continue; /* unused list entry */
            }
		
            if ((data->list[i].id == hdr->id) && (data->list[i].seqno == hdr->seqno)) {

                rtt.tv_sec = meta->tv_sec - data->list[i].tstamp.tv_sec;
                rtt.tv_usec = meta->tv_usec - data->list[i].tstamp.tv_usec;
                if (rtt.tv_usec < 0) {
                    rtt.tv_usec += 1000000;
                    rtt.tv_sec  -= 1;
                }

                /*fprintf( stderr, "%ld %ld \n", rtt.tv_sec, rtt.tv_usec );*/

                data->min = TMIN( data->min, rtt );
                data->max = TMAX( data->max, rtt );
		    
                data->sum.tv_usec += (unsigned long long) rtt.tv_usec;
                data->sum.tv_sec  += (unsigned long long) rtt.tv_sec;
                if (data->sum.tv_usec > 1000000) {
                    data->sum.tv_usec -= 1000000;
                    data->sum.tv_sec  += 1;
                }					

                data->list[i].id = 0;
                data->free += 1;
                data->matches += 1;

                if (data->matches == 1 ) {
                    data->min = rtt;
                }
            }			
	    }
	}

	return 0;
}
예제 #13
0
파일: default.c 프로젝트: callcc/tekui
static int layout_layoutaxis(lua_State *L)
{
	layout *layout = lua_touserdata(L, 3);
	int free = layout->free;
	int i1 = layout->i1;
	int i3 = layout->i3;
	int n = layout->n;
	RECTINT *padding = layout->padding;
	RECTINT *margin = layout->margin;
	RECTINT *minmax = layout->minmax;

	int it = 0;
	size_t len;
	int ssb, ssn = 0;
	int i;

	/**
	**	local fw, tw = 0, 0
	**	local list = { }
	**	local tmm = self.TempMinMax
	**	local wgh = group.Weights
	**	for i = 1, n do
	**		local mins, maxs = tmm[i1][i], tmm[i3][i]
	**		local free = maxs and (maxs > mins)
	**		local weight = wgh[i1][i]
	**		list[i] = { free, mins, maxs, weight, nil }
	**		if free then
	**			if weight then
	**				tw = tw + weight
	**			else
	**				fw = fw + 0x100
	**			end
	**		end
	**	end
	**/

	lua_Integer fw0 = 0;
	lua_Integer tw0 = 0;
	lua_Number fw;
	lua_Number tw;

	lua_createtable(L, n, 0);
	lua_getfield(L, 1, "TempMinMax");
	lua_rawgeti(L, -1, i1);
	lua_rawgeti(L, -2, i3);
	/* s: list, tmm, tmm[i1], tmm[i3] */
	lua_remove(L, -3);
	/* s: list, tmm[i1], tmm[i3] */
	
	lua_getfield(L, 1, "Weights");
	/* s: list, tmm[i1], tmm[i3], weights */
	lua_rawgeti(L, -1, i1);
	/* s: list, tmm[i1], tmm[i3], weights, wgh[i1] */
	lua_remove(L, -2);

	for (i = 1; i <= n; ++i)
	{
		int free;
		lua_rawgeti(L, -3, i);
		/* s: l, tmm[i1], tmm[i3], wgh[i1], mins */
		lua_rawgeti(L, -3, i);
		/* s: l, tmm[i1], tmm[i3], wgh[i1], mins, maxs */
		lua_rawgeti(L, -3, i);
		/* s: l, tmm[i1], tmm[i3], wgh[i1], mins, maxs, weight */
		free = lua_toboolean(L, -2) ?
			lua_tointeger(L, -2) > lua_tointeger(L, -3) : 0;
		lua_createtable(L, 5, 0);
		/* s: l, tmm[i1], tmm[i3], wgh[i1], mins, maxs, weight, t */
		lua_pushboolean(L, free);
		lua_rawseti(L, -2, 1);
		lua_pushvalue(L, -4);
		lua_rawseti(L, -2, 2);
		lua_pushvalue(L, -3);
		lua_rawseti(L, -2, 3);
		lua_pushvalue(L, -2);
		lua_rawseti(L, -2, 4);
		lua_pushnil(L);
		lua_rawseti(L, -2, 5);
		/* s: l, tmm[i1], tmm[i3], wgh[i1], mins, maxs, weight, t */
		lua_rawseti(L, -8, i);
		/* s: l, tmm[i1], tmm[i3], wgh[i1], mins, maxs, weight */
		if (free)
		{
			if (lua_toboolean(L, -1))
				tw0 += lua_tointeger(L, -1);
			else
				fw0 += 0x100;
		}
		lua_pop(L, 3);
	}
	lua_pop(L, 3);

	/**
	**	if tw < 0x10000 then
	**		if fw == 0 then
	**			tw = 0x10000
	**		else
	**			fw, tw = (0x10000 - tw) * 0x100 / fw, 0x10000
	**		end
	**	else
	**		fw = 0
	**	end
	**/

	if (tw0 < 0x10000)
	{
		if (fw0 == 0)
			tw0 = 0x10000;
		else
		{
			fw = 0x10000;
			fw -= tw0;
			fw *= 0x100;
			fw0 = fw / fw0;
			tw0 = 0x10000;
		}
	}
	else
		fw0 = 0;

	tw = tw0 / 0x100;
	fw = fw0 / 0x100;

	/**
	**	local mab = group.MarginAndBorder
	**	local ss = group:getSameSize(i1) and
	**		(group.MinMax[i1] - mab[i1] - mab[i3] - pad[i1] - pad[i3]) / n
	**/

	ssb = layout_getsamesize(L, 2, i1);
	if (ssb)
	{
		ssn = minmax[i1 - 1];
		ssn -= margin[i1 - 1];
		ssn -= margin[i3 - 1];
		ssn -= padding[i1 - 1];
		ssn -= padding[i3 - 1];
		ssn /= n;
	}

	lua_getglobal(L, "table");
	lua_getfield(L, -1, "insert");
	lua_getfield(L, -2, "remove");
	lua_remove(L, -3);
	/* s: list, insert, remove */

	/**
	**	local e = { unpack(list) }
	**/

#if LUA_VERSION_NUM < 502
	len = lua_objlen(L, -3);
#else
	len = lua_rawlen(L, -3);
#endif
	lua_createtable(L, len, 0);
	/* s: list, insert, remove, e */
	for (i = 1; i <= (int) len; ++i)
	{
		lua_rawgeti(L, -4, i);
		lua_rawseti(L, -2, i);
	}

	/**
	**	local it = 0
	**	while #e > 0 do
	**/

#if LUA_VERSION_NUM < 502
	while ((len = lua_objlen(L, -1)) > 0)
#else
	while ((len = lua_rawlen(L, -1)) > 0)
#endif
	{
		/**
		**	local rest = free
		**	local newfree = free
		**	it = it + 1
		**	local e2 = { }
		**/

		lua_Integer rest = free;
		lua_Integer newfree = free;
		it++;

		lua_createtable(L, len, 0);
		/* s: insert, remove, e, e2 */

		/**
		**	repeat
		**		...
		**	until #e == 0
		**/

		do
		{
			lua_Integer olds, news, ti;

			/**
			**	delta = 0
			**
			**	c = remove(e, 1)
			**
			**	if c[1] then -- free
			**		if c[4] then -- weight
			**			delta = free * (c[4] / 0x100) * (tw / 0x100) / 0x10000
			**		else
			**			delta = free * 0x100 * (fw / 0x100) / 0x10000
			**		end
			**		delta = floor(delta)
			**	end
			**/

			lua_Integer delta = 0;

			/* s: insert, remove, e, e2 */
			lua_pushvalue(L, -3);
			/* s: insert, remove, e, e2, remove */
			lua_pushvalue(L, -3);
			/* s: insert, remove, e, e2, remove, e */
			lua_pushinteger(L, 1);
			/* s: insert, remove, e, e2, remove, e, 1 */
			lua_call(L, 2, 1);
			/* s: insert, remove, e, e2, c */

			lua_rawgeti(L, -1, 1);
			/* s: insert, remove, e, e2, c, c[1] */
			if (lua_toboolean(L, -1))
			{
				lua_Number t;
				lua_rawgeti(L, -2, 4);
				/* s: insert, remove, e, e2, c, c[1], c[4] */
				if (lua_toboolean(L, -1))
				{
					t = lua_tointeger(L, -1);
					t /= 0x100;
					t *= tw;
					t *= free;
				}
				else
				{
					t = free;
					t *= 0x100;
					t *= fw;
				}
				t /= 0x10000;
				delta = t;
				lua_pop(L, 1);
			}
			/* s: insert, remove, e, e2, c, c[1] */

			/**
			**	if delta == 0 and it > 1 then
			**		delta = rest
			**	end
			**/

			if (delta == 0 && it > 1)
				delta = rest;

			/**
			**	olds = c[5] or ss or c[2] -- size, mins
			**	news = max(olds + delta, ss or c[2]) -- mins
			**	if not (ss and isgrid) and c[3] and news > c[3] then -- maxs
			**		news = c[3] -- maxs
			**	end
			**	c[5] = news
			**/

			lua_rawgeti(L, -2, 5);
			lua_rawgeti(L, -3, 2);
			/* s: insert, remove, e, e2, c, c[1], c[5], c[2] */

			if (lua_toboolean(L, -2))
				olds = lua_tointeger(L, -2);
			else if (ssb)
				olds = ssn;
			else
				olds = lua_tointeger(L, -1);
			/* s: insert, remove, e, e2, c, c[1], c[5], c[2] */

			ti = ssb ? ssn : lua_tointeger(L, -1);
			news = TMAX(olds + delta, ti);

			lua_rawgeti(L, -4, 3);
			/* s: insert, remove, e, e2, c, c[1], c[5], c[2], c[3] */
			if (!(ssb && layout->isgrid) && lua_toboolean(L, -1) && 
				news > lua_tointeger(L, -1))
				news = lua_tointeger(L, -1);

			lua_pushinteger(L, news);
			lua_rawseti(L, -6, 5);

			/**
			**	delta = news - olds
			**	newfree = newfree - delta
			**	rest = rest - delta
			**/

			delta = news - olds;
			newfree -= delta;
			rest -= delta;

			/**
			**	if not c[3] or c[3] >= HUGE or c[5] < c[3] then -- maxs
			**		insert(e2, c)
			**	end
			**/

			if (!lua_toboolean(L, -1) || lua_tointeger(L, -1) >= TEKUI_HUGE ||
				lua_tointeger(L, -3) < lua_tointeger(L, -1))
			{
				/* redo in next iteration: */
				/* s: ins, rem, e, e2, c, c[1], c[5], c[2], c[3] */
				lua_pushvalue(L, -9);
				/* s: ins, rem, e, e2, c, c[1], c[5], c[2], c[3], ins */
				lua_pushvalue(L, -7);
				/* s: ins, rem, e, e2, c, c[1], c[5], c[2], c[3], ins, e2 */
				lua_pushvalue(L, -7);
				/* s: ins, rem, e, e2, c, c[1], c[5], c[2], c[3], ins, e2, c */
				lua_call(L, 2, 0);
				/* s: insert, remove, e, e2, c, c[1], c[5], c[2], c[3] */
			}

			lua_pop(L, 5);
			/* s: insert, remove, e, e2 */
#if LUA_VERSION_NUM < 502
		} while (lua_objlen(L, -2) > 0);
#else
		} while (lua_rawlen(L, -2) > 0);
#endif
		/**
		**	if newfree < 1 then
		**		break
		**	end
		**
		**	free = newfree
		**	e = e2
		**/

		free = newfree;
		if (free < 1)
		{
			lua_pop(L, 1);
			break;
		}

		/* s: insert, remove, e, e2 */
		lua_replace(L, -2);
		/* s: insert, remove, e */
	}
예제 #14
0
static TINT rfb_cmdrectaffected(struct rfb_Display *mod, struct TVRequest *req,
	TINT result[4], TBOOL source_affect)
{
	struct rfb_Window *v = TNULL;
	TINT *rect = TNULL;
	TINT *xywh = TNULL;
	TINT temprect[4];

	switch (req->tvr_Req.io_Command)
	{
		default:
			/* not affected, no rect */
			return 0;

		case TVCMD_FLUSH:
		case TVCMD_SETATTRS:
		case TVCMD_CLOSEWINDOW:
			/* yes, affected, but no rect */
			return -1;

			/* window rect: */
		case TVCMD_DRAWSTRIP:
			v = req->tvr_Op.Strip.Window;
			break;
		case TVCMD_DRAWFAN:
			v = req->tvr_Op.Fan.Window;
			break;
		case TVCMD_TEXT:
			v = req->tvr_Op.Text.Window;
			break;

			/* specific rect: */
		case TVCMD_RECT:
			v = req->tvr_Op.Rect.Window;
			xywh = req->tvr_Op.Rect.Rect;
			break;
		case TVCMD_FRECT:
			v = req->tvr_Op.FRect.Window;
			xywh = req->tvr_Op.FRect.Rect;
			break;
		case TVCMD_LINE:
			v = req->tvr_Op.Line.Window;
			xywh = req->tvr_Op.Line.Rect;
			break;
		case TVCMD_DRAWBUFFER:
			v = req->tvr_Op.DrawBuffer.Window;
			xywh = req->tvr_Op.DrawBuffer.RRect;
			break;
		case TVCMD_COPYAREA:
		{
			v = req->tvr_Op.CopyArea.Window;
			TINT *s = req->tvr_Op.CopyArea.Rect;
			TINT dx0 = req->tvr_Op.CopyArea.DestX;
			TINT dy0 = req->tvr_Op.CopyArea.DestY;
			TINT sx0 = s[0];
			TINT sy0 = s[1];
			TINT sx1 = s[0] + s[2] - 1;
			TINT sy1 = s[1] + s[3] - 1;
			TINT dx = dx0 - sx0;
			TINT dy = dy0 - sy0;
			TINT dx1 = sx1 + dx;
			TINT dy1 = sy1 + dy;

			rect = temprect;
			if (source_affect)
			{
				rect[0] = TMIN(sx0, dx0);
				rect[1] = TMIN(sy0, dy0);
				rect[2] = TMAX(sx1, dx1);
				rect[3] = TMAX(sy1, dy1);
				break;
			}
			rect[0] = dx0;
			rect[1] = dy0;
			rect[2] = dx1;
			rect[3] = dy1;
			break;
		}
		case TVCMD_PLOT:
			v = req->tvr_Op.Plot.Window;
			rect = temprect;
			rect[0] = req->tvr_Op.Plot.Rect[0];
			rect[1] = req->tvr_Op.Plot.Rect[1];
			rect[2] = req->tvr_Op.Plot.Rect[0];
			rect[3] = req->tvr_Op.Plot.Rect[1];
			break;
	}

	if (v->rfbw_ClipRect.r[0] == -1)
		return 0;

	if (xywh)
	{
		rect = temprect;
		rect[0] = xywh[0];
		rect[1] = xywh[1];
		rect[2] = xywh[0] + xywh[2] - 1;
		rect[3] = xywh[1] + xywh[3] - 1;
	}

	if (rect)
	{
		result[0] = rect[0] + v->rfbw_WinRect.r[0];
		result[1] = rect[1] + v->rfbw_WinRect.r[1];
		result[2] = rect[2] + v->rfbw_WinRect.r[0];
		result[3] = rect[3] + v->rfbw_WinRect.r[1];
	}
	else
		memcpy(result, v->rfbw_WinRect.r, 16);

	return region_intersect(result, v->rfbw_ClipRect.r);
}
예제 #15
0
파일: visual_io.c 프로젝트: callcc/tekui
static TBOOL tek_lib_visual_io_init(struct TTask *task)
{
	struct TExecBase *TExecBase = TGetExecBase(task);
	struct IOData *iodata = TGetTaskData(task);
	
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
	TEKVisual *vis = iodata->vis;

	iodata->fd_pipe[0] = -1;
	iodata->fd_pipe[1] = -1;
	iodata->fdmax = 0;
	
	TInitHook(&iodata->mphook, tek_lib_visual_io_mphookfunc, iodata);
	TSetPortHook(TGetUserPort(TNULL), &iodata->mphook);
#endif

#if defined(ENABLE_FILENO)
	int fd = vis->vis_IOFileNo;
	iodata->fd_stdin = fd == -1 ? STDIN_FILENO : fd;
	visual_io_reader_init(&iodata->linereader, iodata->fd_stdin, IOMAXMSGSIZE);
	iodata->fdmax = TMAX(iodata->fdmax, iodata->fd_stdin);
#endif
	
#if defined(ENABLE_DGRAM)
	iodata->fd_dgram = socket(PF_INET, SOCK_DGRAM, 0);
	if (iodata->fd_dgram != -1)
	{
		int reuse = 1;
		setsockopt(iodata->fd_dgram, SOL_SOCKET, SO_REUSEADDR,
			(char *) &reuse, sizeof(reuse));
		struct sockaddr_in addr;
		memset(&addr, 0, sizeof(struct sockaddr_in));
		addr.sin_family = AF_INET;
		addr.sin_addr.s_addr = inet_addr(ENABLE_DGRAM_ADDR);
		addr.sin_port = htons(ENABLE_DGRAM);
		if (bind(iodata->fd_dgram, 
			(struct sockaddr *) &addr, sizeof addr) == -1)
		{
			close(iodata->fd_dgram);
			iodata->fd_dgram = -1;
		}
	}
	if (iodata->fd_dgram == -1)
	{
		tek_lib_visual_io_exit(task);
		return TFALSE;
	}
	iodata->fdmax = TMAX(iodata->fdmax, iodata->fd_dgram);
#endif
	
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
	if (pipe(iodata->fd_pipe) != 0)
		return TFALSE;

	iodata->fdmax = TMAX(iodata->fdmax, iodata->fd_pipe[0]) + 1;
#endif
	
	TAPTR atom = TLockAtom(iodata->atomname, TATOMF_CREATE | TATOMF_NAME);
	if (atom)
	{
		TSetAtomData(atom, (TTAG) TGetUserPort(TNULL));
		TUnlockAtom(atom, TATOMF_KEEP);
	}
	
	return TTRUE;
}
예제 #16
0
LOCAL void
dfb_openvisual(DFBDISPLAY *mod, struct TVRequest *req)
{
	TTAGITEM *tags = req->tvr_Op.OpenWindow.Tags;
	TAPTR exec = TGetExecBase(mod);
	DFBWINDOW *v;
	DFBWindowDescription wdsc;

	struct FontNode *fn;

	v = TExecAlloc0(exec, mod->dfb_MemMgr, sizeof(DFBWINDOW));
	req->tvr_Op.OpenWindow.Window = v;
	if (v == TNULL) return;

	v->userdata = TGetTag(tags, TVisual_UserData, TNULL);
	v->eventmask = (TUINT) TGetTag(tags, TVisual_EventMask, 0);

	TInitList(&v->penlist);
	v->bgpen = TVPEN_UNDEFINED;
	v->fgpen = TVPEN_UNDEFINED;

	TInitList(&v->imsgqueue);
	v->imsgport = req->tvr_Op.OpenWindow.IMsgPort;

	v->title = (TSTRPTR)
		TGetTag(tags, TVisual_Title, (TTAG) "TEKlib visual");

	/* size/position calculation: */

	v->winwidth = (TINT) TGetTag(tags,
		TVisual_Width,
		(TTAG) TMIN(mod->dfb_ScrWidth, DEF_WINWIDTH));
	v->winheight = (TINT) TGetTag(tags,
		TVisual_Height,
		(TTAG) TMIN(mod->dfb_ScrHeight, DEF_WINHEIGHT));

	if (TGetTag(tags, TVisual_Center, TFALSE))
	{
		v->winleft = (mod->dfb_ScrWidth - v->winwidth) / 2;
		v->wintop = (mod->dfb_ScrHeight - v->winheight) / 2;
	}
	else if (TGetTag(tags, TVisual_FullScreen, TFALSE))
	{
		v->winwidth = mod->dfb_ScrWidth;
		v->winheight = mod->dfb_ScrHeight;
		v->winleft = 0;
		v->wintop = 0;
	}
	else
	{
		v->winleft = (TINT) TGetTag(tags, TVisual_WinLeft, (TTAG) -1);
		v->wintop = (TINT) TGetTag(tags, TVisual_WinTop, (TTAG) -1);
	}

	if (!TGetTag(tags, TVisual_Borderless, TFALSE))
	{
		v->wminwidth = (TINT) TGetTag(tags, TVisual_MinWidth, (TTAG) -1);
		v->wminheight = (TINT) TGetTag(tags, TVisual_MinHeight, (TTAG) -1);
		v->wmaxwidth = (TINT) TGetTag(tags, TVisual_MaxWidth, (TTAG) -1);
		v->wmaxheight = (TINT) TGetTag(tags, TVisual_MaxHeight, (TTAG) -1);

		if (v->wmaxwidth > 0)
			v->winwidth = TMIN(v->winwidth, v->wmaxwidth);
		if (v->wmaxheight > 0)
			v->winheight = TMIN(v->winheight, v->wmaxheight);
		if (v->wminwidth > 0)
			v->winwidth = TMAX(v->winwidth, v->wminwidth);
		if (v->wminheight > 0)
			v->winheight = TMAX(v->winheight, v->wminheight);

		v->wminwidth = v->wminwidth <= 0 ? 1 : v->wminwidth;
		v->wminheight = v->wminheight <= 0 ? 1 : v->wminheight;
		v->wmaxwidth = v->wmaxwidth <= 0 ? 1000000 : v->wmaxwidth;
		v->wmaxheight = v->wmaxheight <= 0 ? 1000000 : v->wmaxheight;
	}

	v->winleft = TMAX(v->winleft, 0);
	v->wintop = TMAX(v->wintop, 0);

	if (TGetTag(tags, TVisual_Borderless, TFALSE))
		v->borderless = TTRUE;

	wdsc.flags = (DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT);
	wdsc.posx   = v->winleft;
	wdsc.posy   = v->wintop;
	wdsc.width  = v->winwidth;
	wdsc.height = v->winheight;

	if (mod->dfb_Layer->CreateWindow(mod->dfb_Layer, &wdsc, &v->window) == DFB_OK)
	{
		v->window->GetSurface(v->window, &v->winsurface);
		v->window->SetOpacity(v->window, 0xFF);
		v->window->GetID(v->window, &v->winid);
		v->window->AttachEventBuffer(v->window, mod->dfb_Events);

		v->window->RequestFocus(v->window);
		v->window->RaiseToTop(v->window);

		if (!v->borderless)
		{
			/* generate focus events */
			genimsg(mod, (DFBWINDOW *)mod->dfb_Focused, v, TITYPE_FOCUS);
			mod->dfb_Focused = (TAPTR) v;
		}

		v->winsurface->SetColor(v->winsurface, 0x00, 0x00, 0xff, 0xff);
		v->winsurface->DrawRectangle(v->winsurface, 0, 0, wdsc.width, wdsc.height);
		v->winsurface->SetColor(v->winsurface, 0x80, 0x80, 0x80, 0xff);
		v->winsurface->FillRectangle(v->winsurface, 1, 1, wdsc.width-2, wdsc.height-2);
		v->winsurface->Flip(v->winsurface, NULL, 0);

		/* init default font */
		fn = mod->dfb_fm.deffont;
		v->curfont = fn;
		mod->dfb_fm.defref++;

		if (v->winsurface->SetFont(v->winsurface, fn->font) == DFB_OK)
		{
			if (v->winsurface->SetFont(v->winsurface, fn->font) == DFB_OK)
			{
				TDBPRINTF(TDB_TRACE,("Add window: %p\n", v->window));
				TAddHead(&mod->dfb_vlist, &v->node);

				/* success: */
				return;
			}
		}
     }

	TExecFree(exec, v);

	/* failure: */
	TDBPRINTF(TDB_ERROR,("Open failed\n"));
	req->tvr_Op.OpenWindow.Window = TNULL;
}
예제 #17
0
void
load_database(cron_db *old_db) {
	struct stat spool_stat, syscron_stat, crond_stat;
	cron_db new_db;
	user *u, *nu;
	time_t new_mtime;

	Debug(DLOAD, ("[%ld] load_database()\n", (long)getpid()));

	/* before we start loading any data, do a stat on SPOOL_DIR
	 * so that if anything changes as of this moment (i.e., before we've
	 * cached any of the database), we'll see the changes next time.
	 */
	if (stat(SPOOL_DIR, &spool_stat) < OK) {
		log_it("CRON", getpid(), "STAT FAILED", SPOOL_DIR);
		(void) exit(ERROR_EXIT);
	}

	/* track system crontab directory
	 */
	if (stat(CROND_DIR, &crond_stat) < OK)
		crond_stat.st_mtime = 0;

	/* track system crontab file
	 */
	if (stat(SYSCRONTAB, &syscron_stat) < OK)
		syscron_stat.st_mtime = 0;

	/* if spooldir's mtime has not changed, we don't need to fiddle with
	 * the database.
	 *
	 * Note that old_db->mtime is initialized to 0 in main(), and
	 * so is guaranteed to be different than the stat() mtime the first
	 * time this function is called.
	 */
	new_mtime = TMAX(crond_stat.st_mtime, TMAX(spool_stat.st_mtime,
	    syscron_stat.st_mtime));
	if (old_db->mtime == new_mtime) {
		Debug(DLOAD, ("[%ld] spool dir mtime unch, no load needed.\n",
			      (long)getpid()));
		return;
	}

	/* something's different.  make a new database, moving unchanged
	 * elements from the old database, reloading elements that have
	 * actually changed.  Whatever is left in the old database when
	 * we're done is chaff -- crontabs that disappeared.
	 */
	new_db.mtime = new_mtime;
	new_db.head = new_db.tail = NULL;

	if (syscron_stat.st_mtime)
		process_crontab("root", NULL, SYSCRONTAB, &syscron_stat,
				&new_db, old_db);

	if (crond_stat.st_mtime)
		process_dir(CROND_DIR, &crond_stat, 1, &new_db, old_db);

	process_dir(SPOOL_DIR, &spool_stat, 0, &new_db, old_db);

	/* if we don't do this, then when our children eventually call
	 * getpwnam() in do_command.c's child_process to verify MAILTO=,
	 * they will screw us up (and v-v).
	 */
	endpwent();

	/* whatever's left in the old database is now junk.
	 */
	Debug(DLOAD, ("unlinking old database:\n"));
	for (u = old_db->head;  u != NULL;  u = nu) {
		Debug(DLOAD, ("\t%s\n", u->name));
		nu = u->next;
		unlink_user(old_db, u);
		free_user(u);
	}

	/* overwrite the database control block with the new one.
	 */
	*old_db = new_db;
	Debug(DLOAD, ("load_database is done\n"));
}
예제 #18
0
파일: host.c 프로젝트: ld-test/tekui
TLIBAPI TAPTR
TEKlib_LoadModule(TAPTR boot, TSTRPTR progdir, TSTRPTR moddir, TSTRPTR modname,
	TTAGITEM *tags)
{
	TAPTR knmod = TNULL;
	TINT len1, len2, len3;
	TSTRPTR t;
	struct TInitModule *imod;
	struct host_modhandle *handle;

	handle = TEKlib_Alloc(boot, sizeof(*handle));
	if (!handle)
		return TNULL;

	imod = host_lookupmodule(modname, tags);
	if (imod)
	{
		handle->entry.func = imod->tinm_InitFunc;
		handle->type = TYPE_LIB;
		return handle;
	}

	len1 = progdir ? strlen(progdir) : 0;
	len2 = moddir ? strlen(moddir) : 0;
	len3 = strlen(modname);

	/* + mod/ + .so + \0 */
	t = TEKlib_Alloc(boot, TMAX(len1, len2) + len3 + 4 + TEKHOST_EXTLEN + 1);
	if (t)
	{
		if (progdir)
			strcpy(t, progdir);
		strcpy(t + len1, "mod/");
		strcpy(t + len1 + 4, modname);
		strcpy(t + len1 + 4 + len3, TEKHOST_EXTSTR);

		TDBPRINTF(3,("trying dlopen %s\n", t));
		knmod = host_getmodule(t);
		if (!knmod)
		{
			if (moddir) strcpy(t, moddir);
			strcpy(t + len2, modname);
			strcpy(t + len2 + len3, TEKHOST_EXTSTR);

			TDBPRINTF(3,("trying dlopen %s\n", t));
			knmod = host_getmodule(t);
		}

		if (!knmod)
			TDBPRINTF(20,("dlopen %s failed\n", modname));

		TEKlib_FreeVec(boot, t);
	}

	if (knmod)
	{
		handle->entry.object = knmod;
		handle->type = TYPE_DLL;
	}
	else
	{
		TEKlib_FreeVec(boot, handle);
		handle = TNULL;
	}

	return handle;
}
예제 #19
0
LOCAL void fbp_drawtriangle(struct rfb_Display *mod, struct rfb_Window *v,
	TINT x0, TINT y0, TINT x1, TINT y1, TINT x2, TINT y2, struct rfb_Pen *pen)
{
	struct Coord res[MAX_VERT];
	TINT outlen;

	struct Region R;

	if (!rfb_getlayermask(mod, &R, v->rfbw_ClipRect.r, v, 0, 0))
		return;

	TUINT p = pixconv_rgbfmt(v->rfbw_PixBuf.tpb_Format, pen->rgb);

	struct TNode *next, *node = R.rg_Rects.rl_List.tlh_Head.tln_Succ;

	for (; (next = node->tln_Succ); node = next)
	{
		struct RectNode *rn = (struct RectNode *) node;
		TINT *r = rn->rn_Rect;

		if (!clippoly(res, &outlen, x0, y0, x1, y1, x2, y2,
				r[0], r[1], r[2], r[3]))
			continue;

		TINT d[4];

		if (outlen == 1)
		{
			d[0] = res[0].x;
			d[1] = res[0].y;
			d[2] = res[0].x;
			d[3] = res[0].y;
			rfb_markdirty(mod, v, d);
			pixconv_setpixelbuf(&v->rfbw_PixBuf, res[0].x, res[0].y, p);
		}
		else if (outlen == 2)
		{
			TINT rect[4] = { res[0].x, res[0].y, res[1].x, res[1].y };
			rfb_markdirty(mod, v, rect);
			fbp_drawline(mod, v, rect, pen);
		}
		else
		{
			TINT i;

			d[0] = TMIN(TMIN(res[0].x, res[1].x), res[2].x);
			d[1] = TMIN(TMIN(res[0].y, res[1].y), res[2].y);
			d[2] = TMAX(TMAX(res[0].x, res[1].x), res[2].x);
			d[3] = TMAX(TMAX(res[0].y, res[1].y), res[2].y);
			rfb_markdirty(mod, v, d);

			rendertriangle(v, res[0], res[1], res[2], p);
			for (i = 2; i < outlen; i++)
			{
				if ((i + 1) < outlen)
					rendertriangle(v, res[0], res[i], res[i + 1], p);
			}
		}
	}
	region_free(&mod->rfb_RectPool, &R);
}