// 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;
  LX_XID BackPixmap;
  unsigned int BackPixel;
  LX_XID BorderPixmap;
  unsigned int BorderPixel;
  LX_GRAVITY BitGravity;
  LX_GRAVITY WinGravity;
  LX_BACKINGSTORE BackingStore;
  unsigned int BackingPlanes;
  unsigned int BackingPixel;
  int OverrideRedirect;
  int SaveUnder;
  unsigned int EventMask;
  unsigned int DontPropagate;
  LX_XID Colormap;
  LX_XID Cursor;
  } ;

static void do_ChangeWindowAttributes(LX_CONN *xc, ARGS *a)
{
 int o;
 unsigned char req[72];
 int proto_BitGravity;
 int proto_WinGravity;
 int proto_BackingStore;

 lx__nochain(xc);
 do <"badcall">
  { if (a->mask & LX_SWM_BitGravity)
     { proto_BitGravity = lx__bitgravity_to_proto(a->BitGravity);
       if (proto_BitGravity < 0) break <"badcall">;
     }
    if (a->mask & LX_SWM_WinGravity)
     { proto_WinGravity = lx__wingravity_to_proto(a->WinGravity);
       if (proto_WinGravity < 0) break <"badcall">;
     }
    if (a->mask & LX_SWM_BackingStore)
     { proto_BackingStore = lx__backingstore_to_proto(a->BackingStore);
       if (proto_BackingStore < 0) break <"badcall">;
     }
    req[0] = LX_CORE_ChangeWindowAttributes;
    req[1] = 0; // unused
    // req[2] and [3] filled in later
    w_card32(&req[4],a->window);
    w_card32(&req[8],a->mask);
    if (a->mask & LX_SWM_BackPixmap)
     { switch (a->BackPixmap)
	{ case LX_PIXMAP_None:           a->BackPixmap = 0;
	  case LX_PIXMAP_ParentRelative: a->BackPixmap = 1;
	}
     }
    if ((a->mask & LX_SWM_BorderPixmap) && (a->BorderPixmap == LX_PIXMAP_CopyFromParent)) a->BorderPixmap = 0;
    if ((a->mask & LX_SWM_Colormap) && (a->Colormap == LX_COLORMAP_CopyFromParent)) a->Colormap = 0;
    if ((a->mask & LX_SWM_Cursor) && (a->Cursor == LX_CURSOR_None)) a->Cursor = 0;
    o = 12;
#define FOO(bit,val) do { if (a->mask & (LX_SWM_##bit)) { w_card32(&req[o],(val)); o += 4; } } while (0)
    FOO(BackPixmap,a->BackPixmap);
    FOO(BackPixel,a->BackPixel);
    FOO(BorderPixmap,a->BorderPixmap);
    FOO(BorderPixel,a->BorderPixel);
    FOO(BitGravity,proto_BitGravity);
    FOO(WinGravity,proto_WinGravity);
    FOO(BackingStore,proto_BackingStore);
    FOO(BackingPlanes,a->BackingPlanes);
    FOO(BackingPixel,a->BackingPixel);
    FOO(OverrideRedirect,a->OverrideRedirect?1:0);
    FOO(SaveUnder,a->SaveUnder?1:0);
    FOO(EventMask,a->EventMask);
    FOO(DontPropagate,a->DontPropagate);
    FOO(Colormap,a->Colormap);
    FOO(Cursor,a->Cursor);
#undef FOO
    w_card16(&req[2],o>>2);
    lx__send_req(xc,&req[0],o);
    return;
  } while (0);
 lx__bad_call(xc,a->call);
}

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

 if (xc->flags & XCF_FAIL)
  { lx__bad_call(xc,"lx_ChangeWindowAttributes_va");
    return;
  }
 a.call = "lx_ChangeWindowAttributes_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_SWM_##name;				\
		break;
    switch (key)
     { ARG(BackPixmap,unsigned long int)
       ARG(BackPixel,unsigned int)
       ARG(BorderPixmap,unsigned long int)
       ARG(BitGravity,unsigned long int);
       ARG(WinGravity,unsigned long int);
       ARG(BackingStore,unsigned long int);
       ARG(BackingPlanes,unsigned int);
       ARG(BackingPixel,unsigned int);
       ARG(OverrideRedirect,int);
       ARG(SaveUnder,int);
       ARG(EventMask,unsigned int);
       ARG(DontPropagate,unsigned int);
       ARG(Colormap,unsigned long int)
       ARG(Cursor,unsigned long int)
       case LX__CWV_END:
	  break <"args">;
       default:
	  lx__bad_call(xc,"lx_ChangeWindowAttributes_va");
	  return;
	  break;
     }
#undef ARG
  }
 va_end(ap);
 do_ChangeWindowAttributes(xc,&a);
}

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

 if (xc->flags & XCF_FAIL)
  { lx__bad_call(xc,"lx_ChangeWindowAttributes_attr");
    return;
  }
 a.call = "lx_ChangeWindowAttributes_attr";
 a.window = window;
 a.mask = mask;
 if (mask & LX_SWM_BackPixmap) a.BackPixmap = attr->background_pixmap;
 if (mask & LX_SWM_BackPixel) a.BackPixel = attr->background_pixel;
 if (mask & LX_SWM_BorderPixmap) a.BorderPixmap = attr->border_pixmap;
 if (mask & LX_SWM_BorderPixel) a.BorderPixel = attr->border_pixel;
 if (mask & LX_SWM_BitGravity) a.BitGravity = attr->bit_gravity;
 if (mask & LX_SWM_WinGravity) a.WinGravity = attr->win_gravity;
 if (mask & LX_SWM_BackingStore) a.BackingStore = attr->backing_store;
 if (mask & LX_SWM_BackingPlanes) a.BackingPlanes = attr->backing_planes;
 if (mask & LX_SWM_BackingPixel) a.BackingPixel = attr->backing_pixel;
 if (mask & LX_SWM_OverrideRedirect) a.OverrideRedirect = attr->override_redirect;
 if (mask & LX_SWM_SaveUnder) a.SaveUnder = attr->save_under;
 if (mask & LX_SWM_EventMask) a.EventMask = attr->event_mask;
 if (mask & LX_SWM_DontPropagate) a.DontPropagate = attr->dont_propagate;
 if (mask & LX_SWM_Colormap) a.Colormap = attr->colormap;
 if (mask & LX_SWM_Cursor) a.Cursor = attr->cursor;
 do_ChangeWindowAttributes(xc,&a);
}