/***************************************************************************
Basic frame, containing sub-items.
Logically the parent of menu objects. Also used for tabs.
*/

#ifndef MITEM_FRAME_QC__
#define MITEM_FRAME_QC__

class mitem_vslider : mitem
{
	virtual float(vector pos, float scan, float char, float down) item_keypress;
	virtual void(vector pos) item_draw;
	void() mitem_vslider;
	float val;
	float minv;
	float maxv;
	float stride;	//size of one 'notch'
};

class mitem_frame : mitem
{
	virtual void(mitem newfocus, float changedflag)				item_focuschange;
	virtual float(vector pos, float scan, float char, float down)	item_keypress;
	virtual void()			item_resized;
	virtual void(vector pos)	item_draw;
	virtual void()			item_remove;
	virtual void(mitem fromitem, string cmd)	item_execcommand;

	mitem 		item_children;
	mitem 		item_mactivechild;
	mitem 		item_kactivechild;
	mitem		item_exclusive;

	mitem_vslider	vslider;	//displayed if any client item's max[y] > our item_size[y]
	vector 	item_framesize;	//x=sides, y=top, z=bottom
	float frame_stdheight;	//adjust RS_Y_MIN_PARENT_MID to pinch inwards when the frame is smaller than this. Child items crossing the mid-point must size gracefully (like subframes).
	float frame_hasscroll;

	static mitem(string title) findchildtext;
	static mitem(string title) findchildcmd;
	static void(mitem newitem, float originflags, vector originmin, vector originmax) add;
	static void(mitem newitem, vector pos) adda;
	static void(mitem newitem, vector originmin, vector originmax) addm;
	static void(mitem newitem, float originflags, vector originmin, vector originmax) addr;
	static void(mitem newitem, float ypos) addc;

	void() mitem_frame =
	{
		item_flags |= IF_ISFRAME;
	};
};

void(mitem ch, vector parentsize) mitem_parentresized =
{
	float f = ch.resizeflags;

	if (f & RS_X_FRACTION)
		ch.item_position[0] = parentsize[0] * ch.mins[0];
	else if (f & RS_X_MIN_PARENT_MAX)
		ch.item_position[0] = parentsize[0] + ch.mins[0];
	else if (f & RS_X_MIN_PARENT_MID)
		ch.item_position[0] = parentsize[0]/2 + ch.mins[0];
	else //if (f & RS_X_MIN_PARENT_MIN)
		ch.item_position[0] = ch.mins[0];

	if (f & RS_X_FRACTION)
		ch.item_position[0] = parentsize[0] * ch.maxs[0];
	else if (f & RS_X_MAX_PARENT_MIN)
		ch.item_size[0] = ch.maxs[0] - ch.item_position[0];
	else if (f & RS_X_MAX_PARENT_MID)
		ch.item_size[0] = ch.maxs[0]+parentsize[0]/2 - ch.item_position[0];
	else if (f & RS_X_MAX_PARENT_MAX)
		ch.item_size[0] = ch.maxs[0]+parentsize[0] - ch.item_position[0];
	else //if (f & RS_X_MAX_OWN_MIN)
		ch.item_size[0] = ch.maxs[0];

	if (f & RS_Y_FRACTION)
		ch.item_position[1] = parentsize[1] * ch.mins[1];
	else if (f & RS_Y_MIN_PARENT_MAX)
		ch.item_position[1] = parentsize[1] + ch.mins[1];
	else if (f & RS_Y_MIN_PARENT_MID)
	{
		ch.item_position[1] = parentsize[1]/2 + ch.mins[1];
		if (ch.item_parent.frame_stdheight)
		if (parentsize[1] < ch.item_parent.frame_stdheight)
		{
			if (ch.item_position[1] < parentsize[1]*0.5)
				ch.item_position[1] += (ch.item_parent.frame_stdheight-parentsize[1])*0.5;
			else
				ch.item_position[1] -= (ch.item_parent.frame_stdheight-parentsize[1])*0.5;
		}
	}
	else //if (f & RS_Y_MIN_PARENT_MIN)
		ch.item_position[1] = ch.mins[1];

	if (f & RS_Y_FRACTION)
		ch.item_position[1] = parentsize[1] * ch.maxs[1];
	else if (f & RS_Y_MAX_PARENT_MIN)
		ch.item_size[1] = ch.maxs[1] - ch.item_position[1];
	else if (f & RS_Y_MAX_PARENT_MID)
	{
		ch.item_size[1] = ch.maxs[1]+parentsize[1]/2 - ch.item_position[1];
		if (ch.item_parent.frame_stdheight)
		if (parentsize[1] < ch.item_parent.frame_stdheight)
		{
			if (ch.item_position[1]+ch.item_size[1] < parentsize[1]*0.5)
				ch.item_size[1] += (ch.item_parent.frame_stdheight-parentsize[1])*0.5;
			else
				ch.item_size[1] -= (ch.item_parent.frame_stdheight-parentsize[1])*0.5;
		}
	}
	else if (f & RS_Y_MAX_PARENT_MAX)
		ch.item_size[1] = ch.maxs[1]+parentsize[1] - ch.item_position[1];
	else //if (f & RS_Y_MAX_OWN_MIN)
		ch.item_size[1] = ch.maxs[1];
};

void(mitem fromitem, string cmd) mitem_frame::item_execcommand =
{
	if (item_parent)
		item_parent.item_execcommand(fromitem, cmd);
	else
		localcmd(strcat(cmd, "\n"));
};

mitem(string title) mitem_frame::findchildtext =
{
	mitem ch;
	for (ch = item_children; ch; ch = ch.item_next)
	{
		if (ch.item_text == title)
			return ch;
	}
	return __NULL__;
};
mitem(string title) mitem_frame::findchildcmd =
{
	mitem ch;
	for (ch = item_children; ch; ch = ch.item_next)
	{
		if (ch.item_command == title)
			return ch;
	}
	return __NULL__;
};


//adds an item with the desired origin settings
void(mitem newitem, float originflags, vector originmin, vector originmax) mitem_frame::add =
{
	newitem.item_next = item_children;
	item_children = newitem;
	newitem.item_parent = this;

	//set up position and resize
	newitem.resizeflags = originflags;
	newitem.mins = originmin;
	newitem.maxs = originmax;
	local vector parentsize = [item_size[0] - item_framesize[0]*2, item_size[1] - (item_framesize[1] + item_framesize[2])];
	mitem_parentresized(newitem, parentsize);
	newitem.item_resized();
	
	item_flags |= IF_CLIENTMOVED;	//make sure it happens.

//	if (!item_kactivechild && (newitem.item_flags & IF_SELECTABLE))
//		item_focuschange(newitem, IF_KFOCUSED);
};

//adds an item to the parent with an absolute position relative to the parent's top-left. objects are expected to already have a size specified.
void(mitem newitem, vector pos) mitem_frame::adda =
{
	local vector parentsize = [item_size[0] - item_framesize[0]*2, item_size[1] - (item_framesize[1] + item_framesize[2])];
	newitem.item_next = item_children;
	item_children = newitem;
	newitem.item_parent = this;

	newitem.resizeflags = RS_X_MIN_PARENT_MIN | RS_X_MAX_OWN_MIN | RS_Y_MIN_PARENT_MIN | RS_Y_MAX_OWN_MIN;
	newitem.mins = pos;
	newitem.maxs = newitem.item_size;

	mitem_parentresized(newitem, parentsize);
	newitem.item_resized();
	
	item_flags |= IF_CLIENTMOVED;	//make sure it happens.

//	if (!item_kactivechild && (newitem.item_flags & IF_SELECTABLE))
//		item_focuschange(newitem, IF_KFOCUSED);
};

//adds an item to the parent in reverse order (ie: at the tail, so the actual order in code)
void(mitem newitem, float originflags, vector originmin, vector originmax) mitem_frame::addr =
{
	local vector parentsize = [item_size[0] - item_framesize[0]*2, item_size[1] - (item_framesize[1] + item_framesize[2])];
	if (item_children)
	{
		local mitem prev;
		for (prev = item_children; prev.item_next; prev = prev.item_next)
			;
		prev.item_next = newitem;
		newitem.item_next = __NULL__;
	}
	else
	{
		newitem.item_next = item_children;
		item_children = newitem;
	}
	newitem.item_parent = this;

	newitem.resizeflags = originflags;
	newitem.mins = originmin;
	newitem.maxs = originmax;
	mitem_parentresized(newitem, parentsize);
	newitem.item_resized();
	
	item_flags |= IF_CLIENTMOVED;	//make sure it happens.

//	if (!item_kactivechild && (newitem.item_flags & IF_SELECTABLE))
//		item_focuschange(newitem, IF_KFOCUSED);
};

//adds an item on the parent with the x coord centered, and absolute y.
//if multiple items are at the same ypos, it will recenter all with respect to the others
void(mitem newitem, float ypos) mitem_frame::addc =
{
	float w, c;
	local mitem prev;
	local vector parentsize = [item_size[0] - item_framesize[0]*2, item_size[1] - (item_framesize[1] + item_framesize[2])];

	newitem.item_next = item_children;
	item_children = newitem;
	newitem.item_position[1] = ypos;
	newitem.item_position[0] = (parentsize[0] - newitem.item_size[0])*0.5;
	newitem.item_parent = this;


	newitem.resizeflags = RS_X_MIN_PARENT_MID | RS_X_MAX_OWN_MIN | RS_Y_MIN_PARENT_MIN | RS_Y_MAX_OWN_MIN;
	newitem.mins[0] = 0;
	newitem.mins[1] = ypos;
	newitem.maxs = newitem.item_size;

	//count the width of the other items at this height.
	w = 0;
	c = 0;
	for (prev = item_children; prev; prev = prev.item_next)
		if (prev.resizeflags == newitem.resizeflags && prev.mins[1] == ypos && prev.maxs[1] == newitem.maxs[1])
		{
			w += prev.maxs[0];
			c += 1;
		}

	//distribute them evenly (from the right, because its add-at-head)
	w += (c-1)*16;	//this much gap space
	for (prev = item_children; prev; prev = prev.item_next)
	{
		if (prev.resizeflags == newitem.resizeflags && prev.mins[1] == ypos && prev.maxs[1] == newitem.maxs[1])
		{
			w -= prev.maxs[0];
			prev.mins[0] = (w+prev.maxs[0])/-2;
			mitem_parentresized(prev, parentsize);
			w -= 16;
		}
	}
	newitem.item_resized();
	
	item_flags |= IF_CLIENTMOVED;	//make sure it happens.

//	if (!item_kactivechild && (newitem.item_flags & IF_SELECTABLE))
//		item_focuschange(newitem, IF_KFOCUSED);
};

//Adds the item in the exact middle of the parent, in both axis
void(mitem newitem, vector min, vector max) mitem_frame::addm =
{
	this.add(newitem, RS_X_MIN_PARENT_MID|RS_Y_MIN_PARENT_MID | RS_X_MAX_PARENT_MID|RS_Y_MAX_PARENT_MID, min, max);
};

//updates this.item_activechild, and calls focus notifications to ensure things get the message. 
//flag should be IF_MFOCUSED or IF_KFOCUSED
void(mitem newfocus, float flag) mitem_frame::item_focuschange =
{
	local mitem it;

	if (newfocus == this)
	{
		//our focus didn't change, but the parent is telling us that *it* got changed while we're the focus
		if (flag & IF_MFOCUSED)
		{
			if (item_parent.item_flags & IF_MFOCUSED && item_parent.item_mactivechild == this)
				item_flags |= IF_MFOCUSED;
			else
				item_flags = item_flags - (item_flags&IF_MFOCUSED);
			//and tell the child
			it = item_mactivechild;
			if (it)
				if (it.item_focuschange)
					it.item_focuschange(it, IF_MFOCUSED);
		}
		if (flag & IF_KFOCUSED)
		{
			if (item_parent.item_flags & IF_KFOCUSED && item_parent.item_kactivechild == this)
				item_flags |= IF_KFOCUSED;
			else
				item_flags = item_flags - (item_flags&IF_KFOCUSED);
			//and tell the child
			it = item_kactivechild;
			if (it)
				if (it.item_focuschange)
					it.item_focuschange(it, IF_KFOCUSED);
		}
		return;
	}

	if ((flag & IF_MFOCUSED) && item_mactivechild != newfocus)
	{
		//make key focus follow the mouse cursor. this should probably only apply to button menus or something? :s
		if (newfocus && (item_flags & IF_FOCUSFOLLOWSMOUSE))
			flag |= IF_KFOCUSED;

		it = item_mactivechild;
		item_mactivechild = newfocus;
		if (it)
		{
			it.item_flags = it.item_flags - (it.item_flags&IF_MFOCUSED);
			if (it.item_focuschange)
				it.item_focuschange(it, IF_MFOCUSED);
		}
		it = item_mactivechild;
		if (it)
		{
			it.item_flags = it.item_flags | (item_flags & IF_MFOCUSED);
			if (it.item_focuschange)
				it.item_focuschange(it, IF_MFOCUSED);
		}
	}

	if ((flag & IF_KFOCUSED) && item_kactivechild != newfocus)
	{
		it = item_kactivechild;
		item_kactivechild = newfocus;
		if (it)
		{
			it.item_flags = it.item_flags - (it.item_flags&IF_KFOCUSED);
			if (it.item_focuschange)
				it.item_focuschange(it, IF_KFOCUSED);
		}
		it = item_kactivechild;
		if (it)
		{
			it.item_flags = it.item_flags | (item_flags & IF_KFOCUSED);
			if (it.item_focuschange)
				it.item_focuschange(it, IF_KFOCUSED);
		}
	}
};


float(vector pos, float scan, float char, float down) mitem_vslider::item_keypress =
{
	if (down != 1)
	{
		if (scan == K_MOUSE1 && ui.mgrabs == this)
			ui.mgrabs = __NULL__;
		return FALSE;
	}
	if (scan == K_MWHEELDOWN)
		val = bound(minv, val+stride, maxv);
	else if (scan == K_MWHEELUP)
		val = bound(minv, val-stride, maxv);
	else if (scan == K_MOUSE1)
		ui.mgrabs = this;
	else
		return FALSE;
	return TRUE;
};
void(vector pos) mitem_vslider::item_draw =
{
	float f;
	float w = item_size[0];
	float h = item_size[1];
	float isize = w;
	
	vector v = dp_workarounds?'0 0 0':drawgetimagesize("scrollbars/slider.tga");

	if (v != '0 0 0')
	{
		ui.drawpic(pos, "scrollbars/arrow_up.tga", [w, w], '1 1 1', item_alpha, 0);	//top
		pos_y += w;
		h -= w*2;
		ui.drawpic(pos + [0, h], "scrollbars/arrow_down.tga", [w, w], '1 1 1', item_alpha, 0);	//bottom
		ui.drawpic(pos, "scrollbars/slidebg.tga", [w, h], '1 1 1', item_alpha, 0);	//back-middle
	
		isize = (v_y * w) / (v_x);
		if (isize > h/2)
			isize = h/2;
	}
	else
	{
//		ui.drawfill(pos, [w, w], '1 1 1', item_alpha, 0);	//top
//		pos_y += w;
//		h -= w*2;
//		ui.drawfill(pos + [0, h], [w, w], '1 1 1', item_alpha, 0);	//bottom
		ui.drawfill(pos, [w, h], '0.5 0.5 0.5', item_alpha, 0);	//back-middle
	}

	if (ui.mgrabs == this)
	{
		f = (ui.mousepos[1] - pos_y - (isize/2))/(h - isize);
		f = bound(0, f, 1);
		val = minv + (f * (maxv - minv));
	}
	else
		f = bound(0, (val - minv) / (maxv - minv), 1);

	h -= isize;
	if (v != '0 0 0')
		ui.drawpic(pos + [0, h*f], "scrollbars/slider.tga", [w, isize], '1 1 1', item_alpha, 0);	//back-middle
	else
		ui.drawfill(pos + [0, h*f], [w, isize], '1 1 1', item_alpha, 0);	//back-middle
};
void() mitem_vslider::mitem_vslider =
{
	item_size[0] = 8;
	item_size[1] = 128;
};

//does NOT wrap.
//does NOT pass go.
static mitem(mitem item, float upwards) menu_simplenextitem =
{
	mitem_frame menu = item.item_parent;
	mitem prev;
	if (upwards)
	{
		if (item)
		{
			item = item.item_next;
			if (!item)
				return __NULL__;
			return item;
		}
		else
			return __NULL__;
	}
	else
	{
		for(prev = menu.item_children; prev.item_next; prev = prev.item_next)
		{
			if (prev.item_next == item)
				return prev;
		}
		return __NULL__;
	}
};

//finds the next/prev item through multiple children, returning NULL when it runs out of items in the sequence.
//call this with item==null to find the first item in the sequence (to handle wraps).
static mitem(mitem_frame menu, float upwards, mitem item) menu_findnextitem =
{
	mitem_frame frame;
	mitem citem;
	
	if (item && (item.item_flags & IF_ISFRAME))
	{
		frame = (mitem_frame)item;
		citem = menu_findnextitem(frame, upwards, frame.item_kactivechild?frame.item_kactivechild:frame.item_mactivechild);
		if (citem)
			return citem;
	}
	
	for(;;)
	{
		if (!item)
		{	//we go for the opposite end here, as we assume to be starting/unfocused
			item = menu.item_children;
			if (!upwards && item)
			{
				while(item.item_next)
					item = item.item_next;
			}
		}
		else
			item = menu_simplenextitem(item, upwards);
		
		if (!item)
		{	//we reached the end of the list, let the parent frame try its next
			return __NULL__;
		}
		
		if (item.item_flags & IF_ISFRAME)
		{	//if the next item is a frame, try and select its first element instead
			frame = (mitem_frame)item;
			citem = menu_findnextitem(frame, upwards, __NULL__);
			if (citem)
				return citem;
		}

		if (item.item_flags & IF_INVISIBLE)
			continue;
		if (item.item_flags & IF_SELECTABLE)
			return item;
	}
	
};
static void(mitem item) menu_deselectitem =
{
	if (!item)
		return;
	if (item && (item.item_flags & IF_ISFRAME))
	{
		mitem_frame frame = (mitem_frame)item;
		if (frame.item_kactivechild)
			menu_deselectitem(frame.item_kactivechild);
	}
	item.item_focuschange(__NULL__, IF_KFOCUSED);	//deselect the previous one	
};
static void(mitem item) menu_selectitem =
{
	if (!item)
		return;
	mitem_frame menu = item.item_parent;
	if (menu)
	{
		if (menu.item_kactivechild != item)
			menu_deselectitem(menu.item_kactivechild);
		menu_selectitem(menu);
		menu.item_focuschange(item, IF_KFOCUSED);	//focus on the new
	}
};
void(mitem_frame rootmenu, float upwards) menu_selectnextitem =
{
	mitem item = menu_findnextitem(rootmenu, upwards, rootmenu.item_kactivechild?rootmenu.item_kactivechild:rootmenu.item_mactivechild);
	if (!item)
		item = menu_findnextitem(rootmenu, upwards, __NULL__);

	menu_selectitem(item);
	item.item_focuschange(item, IF_KFOCUSED);	//focus on the new
};

float(vector pos, float scan, float char, float down) mitem_frame::item_keypress =
{
	mitem ch;
	float handled = FALSE;

	//compensate for the frame
	pos[0] += item_framesize[0];
	pos[1] += item_framesize[1];

	if (scan >= K_MOUSE1 && scan <= K_MOUSE5 && scan != K_MWHEELUP && scan != K_MWHEELDOWN)
	{
		if (item_exclusive)
			ch = item_exclusive;
		else 
			ch = item_mactivechild;
		if (down)	//keyboard focus follows on mouse click.
		{
			item_focuschange(ch, IF_KFOCUSED);
		}
	}
	else
	{
		ch = item_kactivechild;
		if (!ch && down)
		{
			//if there's no key child active, then go and pick one so you can just start using keyboard access etc.
			if (item_exclusive)
				ch = item_exclusive;
			else if (item_mactivechild)
				ch = item_mactivechild;
			else
			{
				mitem c;
				for (c = item_children; c; c = c.item_next)
				{
					if (c.item_flags & IF_SELECTABLE)
						ch = c;
				}
			}
			if (ch)
				item_focuschange(ch, IF_KFOCUSED);
			ch = item_kactivechild;
		}
	}

	if (vslider)
		pos[1] -= vslider.val;

	if (ch)
	{
		if (ch.item_keypress)
			handled = ch.item_keypress(pos + ch.item_position, scan, char, down);
	}
	if (vslider && !handled && (scan == K_MWHEELUP || scan == K_MWHEELDOWN))	//give mwheel to the slider if its visible.
		handled = vslider.item_keypress(pos + vslider.item_position, scan, char, down);

	return handled;
};
void() mitem_frame::item_remove =
{
	local mitem ch;
	while (this.item_children)
	{
		ch = this.item_children;
		this.item_children = ch.item_next;
		ch.item_remove();
	}
	super::item_remove();
};
void() mitem_frame::item_resized =
{
	mitem ch;
	vector framemax = [item_size[0] - item_framesize[0]*2, item_size[1] - (item_framesize[1] + item_framesize[2])];
	for (ch = this.item_children; ch; ch = ch.item_next)
	{
		vector os = ch.item_size;
		mitem_parentresized(ch, framemax);
		if (ch.item_resized && ch.item_size != os)
			ch.item_resized();
	}
	item_flags |= IF_CLIENTMOVED;	//make sure it happens.

	super::item_resized();
};
void(vector pos) mitem_frame::item_draw =
{
	local vector omin = ui.drawrectmin, omax = ui.drawrectmax;
	local mitem ch;
	local vector clientpos;
	local vector clientsize;

	if (frame_hasscroll && (item_flags & IF_CLIENTMOVED))
	{
		//if a client object moved, make sure the scrollbar is updated
		item_flags &~= IF_CLIENTMOVED;
		clientsize= '0 0';
		for(ch = item_children; ch; ch = ch.item_next)
		{
			if (clientsize[0] < ch.item_position[0] + ch.item_size[0])
				clientsize[0] = ch.item_position[0] + ch.item_size[0];
			if (clientsize[1] < ch.item_position[1] + ch.item_size[1])
				clientsize[1] = ch.item_position[1] + ch.item_size[1];
		}
//		if (clientsize[0] > item_size[0] - item_framesize[0]*2)
//			//add hscroll
		if (clientsize[1] > item_size[1] - (item_framesize[1]+item_framesize[2]))
		{
			if (!vslider)
			{
				local mitem_vslider tmp;
				tmp = spawn(mitem_vslider, val:0, stride:8);
				vslider = tmp;
			}
			vslider.maxv = clientsize[1] - (item_size[1] - (item_framesize[1]+item_framesize[2]));
		}
		else if (vslider)
		{
			vslider.item_remove();
			vslider = (mitem_vslider)__NULL__;
		}
	}
	else if (!frame_hasscroll && this.vslider)
	{
		vslider.item_remove();
		vslider = (mitem_vslider)__NULL__;
	}


	//compensate for the frame
	pos[0] += item_framesize[0];
	pos[1] += item_framesize[1];

	clientpos = pos;
	clientsize = this.item_size;
	clientsize[0] -= item_framesize[0]*2;
	clientsize[1] -= (item_framesize[1]+item_framesize[2]);

	if (vslider)
	{
		//scroll+shrink the client area to fit the slider on it.
		clientpos[1] -= vslider.val;
		clientsize[0] -= vslider.item_size[0];
	}


	if (ui.mousepos != ui.oldmousepos)
	{
		local mitem newfocus = __NULL__;
		//if the mouse moved, select the new item
		if (item_exclusive)
			newfocus = item_exclusive;
		else
		{
			for(ch = item_children; ch; ch = ch.item_next)
			{
				if (ch.item_flags & IF_SELECTABLE)
				if (mouseinbox(clientpos + ch.item_position, ch.item_size))
				{
					newfocus = ch;
				}
			}
		}
		if (vslider)
			if (mouseinbox(pos + [clientsize[0], 0], vslider.item_size))
				newfocus = vslider;
		this.item_focuschange(newfocus, IF_MFOCUSED);
	}

	//clip the draw rect to our area, so children don't draw outside it. don't draw if its inverted.
	if (pos_x > ui.drawrectmin[0])
		ui.drawrectmin[0] = pos_x;
	if (pos_y > ui.drawrectmin[1])
		ui.drawrectmin[1] = pos_y;
	if (pos_x+clientsize_x < ui.drawrectmax[0])
		ui.drawrectmax[0] = pos_x+clientsize_x;
	if (pos_y+clientsize_y < ui.drawrectmax[1])
		ui.drawrectmax[1] = pos_y+clientsize[1];
	if (ui.drawrectmax[0] > ui.drawrectmin[0] && ui.drawrectmax[1] > ui.drawrectmin[1])
	{
		ui.setcliparea(ui.drawrectmin[0], ui.drawrectmin[1], ui.drawrectmax[0] - ui.drawrectmin[0], ui.drawrectmax[1] - ui.drawrectmin[1]);
		if (item_exclusive)
			item_exclusive.item_draw(clientpos + ch.item_position);
		else
		{
			for(ch = item_children; ch; ch = ch.item_next)
			{
				if not (ch.item_flags & IF_INVISIBLE)
					ch.item_draw(clientpos + ch.item_position);
			}
		}
		ui.setcliparea(omin_x, omin_y, omax_x - omin_x, omax_y - omin_y);

		if (vslider)
		{
			vslider.item_size[1] = clientsize[1];
			vslider.item_draw(pos + [clientsize[0], 0]);
		}
	}
	ui.drawrectmin = omin;
	ui.drawrectmax = omax;
};
#define menuitemframe_spawn(sz) spawn(mitem_frame, item_size:sz)

#endif //MITEM_FRAME_QC__