if (FindWindowById(WC_SEND_NETWORK_MSG, 0) != NULL) wz--;

			assert(wz >= _z_windows);

			if (wz != _last_z_window) memmove(wz + 1, wz, (byte*)_last_z_window - (byte*)wz);

		}

		*wz = w;

		_last_z_window++;

	}

	WindowEvent e;

	e.event = WE_CREATE;

	e.we.create.data = data;

	w->wndproc(w, &e);

	/* Try to make windows smaller when our window is too small.

	 * w->(width|height) is normally the same as min_(width|height),

	 * but this way the GUIs can be made a little more dynamic;

	 * one can use the same spec for multiple windows and those

	 * can then determine the real minimum size of the window. */

	if (w->width != def_width || w->height != def_height) {

		/* Think about the overlapping toolbars when determining the minimum window size */

		int free_height = _screen.height;

		const Window *wt = FindWindowById(WC_STATUS_BAR, 0);

		if (wt != NULL) free_height -= wt->height;

		wt = FindWindowById(WC_MAIN_TOOLBAR, 0);

		if (wt != NULL) free_height -= wt->height;

		int enlarge_x = max(min(def_width  - w->width,  _screen.width - w->width),  0);

		int enlarge_y = max(min(def_height - w->height, free_height   - w->height), 0);

		/* X and Y has to go by step.. calculate it.

		 * The cast to int is necessary else x/y are implicitly casted to

		 * unsigned int, which won't work. */

		if (w->resize.step_width  > 1) enlarge_x -= enlarge_x % (int)w->resize.step_width;

		if (w->resize.step_height > 1) enlarge_y -= enlarge_y % (int)w->resize.step_height;

		ResizeWindow(w, enlarge_x, enlarge_y);

		WindowEvent e;

		e.event = WE_RESIZE;

		e.we.sizing.size.x = w->width;

		e.we.sizing.size.y = w->height;

		e.we.sizing.diff.x = enlarge_x;

		e.we.sizing.diff.y = enlarge_y;

		w->wndproc(w, &e);

	}

	const Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0);

	SetWindowDirty(w);

	return w;

}

/**

 * Open a new window. If there is no space for a new window, close an open

 * window. Try to avoid stickied windows, but if there is no else, close one of

 * those as well. Then make sure all created windows are below some always-on-top

 * ones. Finally set all variables and call the WE_CREATE event

 * @param x offset in pixels from the left of the screen

 * @param y offset in pixels from the top of the screen

 * @param width width in pixels of the window

 * @param height height in pixels of the window

 * @param *proc see WindowProc function to call when any messages/updates happen to the window

 * @param cls see WindowClass class of the window, used for identification and grouping

 * @param *widget see Widget pointer to the window layout and various elements

 * @return Window pointer of the newly created window */

Window *AllocateWindow(

							int x, int y, int width, int height,

							WindowProc *proc, WindowClass cls, const Widget *widget, void *data)

{

	return LocalAllocateWindow(x, y, width, height, width, height, proc, cls, widget, 0, data);

}

struct SizeRect {

	int left,top,width,height;

};

static bool IsGoodAutoPlace1(int left, int top, int width, int height, Point &pos)

{

	Window* const *wz;

	int right  = width + left;

	int bottom = height + top;

	if (left < 0 || top < 22 || right > _screen.width || bottom > _screen.height)

		return false;

	/* Make sure it is not obscured by any window. */

	FOR_ALL_WINDOWS(wz) {

		const Window *w = *wz;

		if (w->window_class == WC_MAIN_WINDOW) continue;

		if (right > w->left &&

				w->left + w->width > left &&