// Copyright status: this file is in the public domain.

#include <stdarg.h>

#include "lx.h"

#include "proto.h"
#include "internal.h"

typedef struct args ARGS;

struct args {
  const char *call;
  LX_XID window;
  unsigned int mask;
  int X;
  int Y;
  int W;
  int H;
  int BorderWidth;
  LX_XID Sibling;
  LX_XID StackMode;
  } ;

static void do_ConfigureWindow(LX_CONN *xc, ARGS *a)
{
 unsigned char req[40];
 int proto_StackMode;
 int o;

 lx__trace_start(xc,LX_CORE_ConfigureWindow);
 if (lx__trace_id(xc,a->window,LX_ID_KIND_Window)) return;
 if ((a->mask & LX_CWM_Sibling) && lx__trace_id(xc,a->Sibling,LX_ID_KIND_Window)) return;
 if (lx__trace_done(xc)) return;
 lx__nochain(xc);
 do <"badcall">
  { if ( ((a->mask & LX_CWM_X) && ((a->X < -32768) || (a->X > 32767))) ||
	 ((a->mask & LX_CWM_Y) && ((a->Y < -32768) || (a->Y > 32767))) ||
	 ((a->mask & LX_CWM_W) && ((a->W < 0) || (a->W > 65535))) ||
	 ((a->mask & LX_CWM_H) && ((a->H < 0) || (a->H > 65535))) ||
	 ((a->mask & LX_CWM_BorderWidth) && ((a->BorderWidth < 0) || (a->BorderWidth > 65535))) ) break <"badcall">;
    if (a->mask & LX_CWM_StackMode)
     { proto_StackMode = lx__stackmode_to_proto(a->StackMode);
       if (proto_StackMode < 0) break <"badcall">;
     }
    req[0] = LX_CORE_ConfigureWindow;
    req[1] = 0; // unused
    // req[2] and [3] filled in later
    w_card32(&req[4],a->window);
    w_card16(&req[8],a->mask);
    req[10] = 0; // unused
    req[11] = 0; // unused
    o = 12;
#define SFIELD(bit,val) do { if (a->mask & (LX_CWM_##bit)) { w_int32(&req[o],(val)); o += 4; } } while (0)
#define UFIELD(bit,val) do { if (a->mask & (LX_CWM_##bit)) { w_card32(&req[o],(val)); o += 4; } } while (0)
    SFIELD(X,a->X);
    SFIELD(Y,a->Y);
    UFIELD(W,a->W);
    UFIELD(H,a->H);
    UFIELD(BorderWidth,a->BorderWidth);
    UFIELD(Sibling,a->Sibling);
    UFIELD(StackMode,proto_StackMode);
#undef SFIELD
#undef UFIELD
    w_card16(&req[2],o>>2);
    lx__send_req(xc,&req[0],o);
    return;
  } while (0);
 lx__bad_call(xc,a->call);
}

void lx_ConfigureWindow_va(LX_CONN *xc, LX_XID window, ...)
{
 ARGS a;
 va_list ap;
 int key;

 if (xc->flags & XCF_FAIL)
  { lx__bad_call(xc,"lx_ConfigureWindow_va");
    return;
  }
 a.call = "lx_ConfigureWindow_va";
 a.window = window;
 a.mask = 0;
 va_start(ap,window);
 while <"args"> (1)
  { key = va_arg(ap,int);
#define ARG(name,type)\
	case LX__CWV_##name:				\
		a.name = va_arg(ap,type);		\
		a.mask |= LX_CWM_##name;		\
		break;
    switch (key)
     { ARG(X,int)
       ARG(Y,int)
       ARG(W,int)
       ARG(H,int)
       ARG(BorderWidth,int)
       ARG(Sibling,unsigned long int)
       ARG(StackMode,unsigned long int)
       case LX__CWV_END:
	  break <"args">;
       default:
	  lx__bad_call(xc,"lx_ConfigureWindow_va");
	  return;
	  break;
     }
#undef ARG
  }
 va_end(ap);
 do_ConfigureWindow(xc,&a);
}

void lx_ConfigureWindow_attr(LX_CONN *xc, LX_XID window, unsigned int mask, const LX_CFG_WINDOW_ATTRIBUTES *attr)
{
 ARGS a;

 if (xc->flags & XCF_FAIL)
  { lx__bad_call(xc,"lx_ConfigureWindow_attr");
    return;
  }
 a.call = "lx_ConfigureWindow_attr";
 a.window = window;
 a.mask = mask;
 if (mask & LX_CWM_X) a.X = attr->x;
 if (mask & LX_CWM_Y) a.Y = attr->y;
 if (mask & LX_CWM_W) a.W = attr->w;
 if (mask & LX_CWM_H) a.H = attr->h;
 if (mask & LX_CWM_BorderWidth) a.BorderWidth = attr->border_width;
 if (mask & LX_CWM_Sibling) a.Sibling = attr->sibling;
 if (mask & LX_CWM_StackMode) a.StackMode = attr->stack_mode;
 do_ConfigureWindow(xc,&a);
}