/******************************************************************

              Copyright 1991, by FUJITSU LIMITED

	Modified by Digital Equipment Corporation, 1993

This demo program is modified from the demo program in the 
public domain of X11R5 contribution.
To run this program, 
$ximdemo [-locale] [-display] [-Root / -Cb] [-fs] [-xrm_file] [-immodifier]

To set locale:
	-locale <locale name: eg, "ja_JP.eucJP">
To set display:
	-display <host:dpy>
To set root-window pre-editing as your preference choice:
	-Root
To set on-the-spot pre-editing as your preference choice:
	-Cb
To set your preferred base font name list:
	-fs	<font list>
To set your resource database:
	-xrm_file <file name>
To set im modifier name:
	-immodifier <modifier name>

******************************************************************/

#include <stdio.h>
#include <X11/Xlocale.h>
#include <X11/Xlib.h>
#include <X11/cursorfont.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/keysymdef.h>
#include <X11/Xresource.h>

#define W_WIDTH   422
#define W_HEIGHT  162

#define MAXTYPE 20
#define DEFAULT_LOCALE		"zh_TW.dechanyu"
#define DEFAULT_FONT_NAME	"-*-SCREEN-*-*-R-Normal--*-*, -*"

static void     CreateStatus();
static Window	JxCreateTextWindow();
static int      JxDestroyTextWindow();
static int      JxRealizeText();
static int      JxRedisplayText();
static int      _JxNextLine();
static int      JxWriteText();

/* Forward declarations */

typedef struct {
	Display *dpy;
	Window win;
	XFontSet fset;
} preedcb_data;

GC      Jxgc_on, Jxgc_off;
int     Jxcx, Jxcy;
int     Jxcx_offset=2, Jxcy_offset=2;
int     Jxsfont_w, Jxwfont_w, Jxfont_height;
XRectangle	*Jxfont_rect;
int	Jxw_width, Jxw_height;

#define Jxmax_line	10
int	Jxsize[Jxmax_line];
char 	Jxbuff[Jxmax_line][128];
int	Jxline_no;
int	Jxline_height;

int     sav_cx, sav_cy;
int	sav_w_width, w_height;
int	sav_size[Jxmax_line];
int	sav_line_no;
char    preedit_buffer[12];

void
save_value()
{
    int i;

    sav_cx = Jxcx;
    sav_cy = Jxcy;
    sav_line_no = Jxline_no;
    for (i=0; i< Jxmax_line; i++)
	sav_size[i] = Jxsize[i];
}

void 
restore_value()
{
    int i;
    Jxcx = sav_cx;
    Jxcy = sav_cy;
    Jxline_no = sav_line_no;
    for (i=0; i< Jxmax_line; i++)
	Jxsize[i] = sav_size[i];
}

int
api_preedit_start_cb(ic, clientdata, calldata)
XIC ic;
XPointer clientdata;
XPointer calldata;
{
    int len;
    len = 12;
/* save up the values */
    save_value();

    return(len);
}

void
api_preedit_done_cb(ic, clientdata, calldata)
XIC ic;
XPointer clientdata;
XPointer calldata;
{
    preedcb_data *cd = (preedcb_data *)clientdata;
/* restore up the values */
    restore_value();
    JxRedisplayText(cd->dpy, cd->win, cd->fset); /* convenient handling */
    return;
}

void
api_preedit_draw_cb( ic, clientdata, calldata)
XIC ic;
XPointer clientdata;
XIMPreeditDrawCallbackStruct *calldata;
{
    preedcb_data *cd = (preedcb_data *)clientdata;
    int count;
    char *reset_str;

    if (calldata->text) {
	if (calldata->text->encoding_is_wchar)
        {
	} else {
	  count =  strlen(calldata->text->string.multi_byte);
	  if (count > 12) {
	     reset_str = XmbResetIC(ic); /* preedit string > max preedit buffer */
	     XFillRectangle(cd->dpy, cd->win, Jxgc_off, Jxcx, Jxcy, Jxw_width*13, Jxfont_height);	/* clear the preedit area */
	     restore_value();
	     if (reset_str)
		XFree(reset_str);
	     return;
	  }
	  if (!calldata->chg_length) {  /* insert character */
	     if (!calldata->chg_first)  { /* insert in first character in preedit buffer */
	        strncpy(&preedit_buffer[0],calldata->text->string.multi_byte, count);
		restore_value();
	     } else {
		/* Not Yet Implemented */
	     }
	  } else {			/* replace character */
	     if (!calldata->chg_first)  { /* replace from first character in preedit buffer */
	        strncpy(&preedit_buffer[0],calldata->text->string.multi_byte, count);
		restore_value();
	     } else {
		/* Not Yet Implemented */
	     }
	  }   
	  XFillRectangle(cd->dpy, cd->win, Jxgc_off, Jxcx, Jxcy, Jxw_width*13,
Jxfont_height);	/* clear the preedit area */
	  JxWriteText(cd->dpy, cd->win, cd->fset, count, preedit_buffer);
        }
    } else {	/* should delete preedit buffer */
	/* Not yet implemented */
    }

    return;
}

void
api_preedit_caret_cb(ic, clientdata, calldata)
XIC ic;
XPointer clientdata;
XIMPreeditCaretCallbackStruct *calldata;
{
    /* Not yet implemented	*/

    return;
}

main(argc, argv)
int	argc;
char	*argv[];
	{
	Display			*display;
	int			screen;
	Window			root, window, client;
	XRectangle		rect, StatusArea;
	XEvent			event;
	unsigned long		mask;
	unsigned long		fpixel, bpixel;
	int			font_height;
	int			i, n;
	char			*base_font_name = NULL;
	int			len = 128;
	char			string[128];
	KeySym			keysym;
	int			count;
	XIMStyles		*im_styles;
	XIMStyle		xim_mode=0;
	XIMStyle		best_style = XIMPreeditCallbacks;
	XIM			im;
	XIC			ic;
	XFontSet		font_set;
	char			*locale = NULL;
	XVaNestedList		preedit_attr, status_attr;
	char			**missing_list;
	int			missing_count;
	char			*def_string;
	char			*display_name = NULL;
	char			*res_file = NULL;
	XrmDatabase		rdb = NULL;
	XIMStyle		app_supported_styles;
	long			im_event_mask;
    	XVaNestedList 		nestlist;
    	XIMCallback 		ximapicb[10];
	char			immodifier[100];
	preedcb_data		preedcb_cd;
	static char		title[30];
 
        immodifier[0]		= '\0';

	for(i=1; i<argc; i++) {
		if(!strcmp(argv[i], "-Root")) {
			best_style = XIMPreeditNothing;
			}
		else if (!strcmp(argv[i], "-Cb")) {
			best_style = XIMPreeditCallbacks;
			}
		else if(!strcmp(argv[i], "-fs"))
			base_font_name = argv[++i];
		else if(!strcmp(argv[i], "-display"))
			display_name = argv[++i];
		else if(!strcmp(argv[i], "-xrm_file"))
			res_file = argv[++i];
		else if (!strcmp(argv[i], "-locale"))
			locale = argv[++i];
		else if (!strcmp(argv[i], "-immodifier")) {
		 	strcpy(immodifier, "@im=");
       			strcat(immodifier, argv[++i]);
		     }	
		}
	rect.x      = rect.y      = 0;
	rect.width  = W_WIDTH;
	rect.height = W_HEIGHT;
	display = XOpenDisplay(display_name);
	preedcb_cd.dpy = display;
	screen  = DefaultScreen(display);
	root    = RootWindow(display, screen);
	fpixel  = BlackPixel(display, screen);
	bpixel  = WhitePixel(display, screen);
	window = XCreateSimpleWindow(display, root, 0, 0,
				W_WIDTH, W_HEIGHT, 2, bpixel, fpixel);

	if(locale == NULL)
		locale = DEFAULT_LOCALE;
	if(setlocale(LC_CTYPE, locale) == NULL) {
		fprintf(stderr, "Error : setlocale() !\n");
 		exit(0);
		}
	if (!XSupportsLocale()) {
	   fprintf(stderr, "X does not support this locale");
	   exit(1);
 	}

	if (XSetLocaleModifiers(immodifier) == NULL) {
	   (void) fprintf(stderr, "%s: Warning : cannot set locale modifiers. \n", argv[0]);
	}

	if (base_font_name == NULL)
		base_font_name = DEFAULT_FONT_NAME;

	font_set = XCreateFontSet(display, base_font_name, &missing_list,
			       &missing_count, &def_string);
	preedcb_cd.fset = font_set;
	/*
	 * if there are charsets for which no fonts can be found,
	 * print a warning message.
	 */
	if (missing_count > 0) {
		fprintf(stderr, "The following charsets are missing: \n");
		for (i=0; i<missing_count; i++)
		    fprintf(stderr, "%s \n", missing_list[i]);
		XFreeStringList(missing_list);
	} 

	client = JxCreateTextWindow(display, window, 0, 0,
				W_WIDTH-2, W_HEIGHT-2, 1, bpixel, fpixel,
				font_set, &font_height);
	preedcb_cd.win = client;
	if(res_file) {
		printf("Set Database : file name = %s\n", res_file);
		rdb = XrmGetFileDatabase(res_file);
		}

	if((im = XOpenIM(display, rdb, NULL, NULL)) == NULL) {
		printf("Error : XOpenIM() !\n");
		exit(0);
		}

	if (!strcmp(locale,"zh_TW.dechanyu")) {
		strcpy(title, "XIM Æüî¯");
	} else if (!strcmp(locale, "zh_CN.dechanzi")) {
		strcpy(title, "XIM ʾ·¶");
	} else if (!strncmp(locale, "ja_JP", 5)) {
		strcpy(title, "XIM ¥Ç¥â"); 
	} else if (!strcmp(locale, "ko_KR.deckorean")) {
		strcpy(title, "XIM µ¥¸ð");
	} else if (!strcmp(locale, "th_TH.TACTIS")) {
		strcpy(title, "XIM ¡ÒÃÊÒ¸Ôµ");
	} else {
	    strcpy(title, "XIM Demo");
	}
	
	XmbSetWMProperties(display, window, title, title, NULL, 0, NULL,
NULL, NULL);

	/* set flags for the styles our application can support */
	app_supported_styles = XIMPreeditNone | XIMPreeditNothing | XIMPreeditCallbacks;
	app_supported_styles |= XIMStatusNone | XIMStatusNothing;
	XGetIMValues(im, XNQueryInputStyle, &im_styles, NULL);
	n = 1; 
	if(im_styles != (XIMStyles *)NULL) {
		for(i=0; i<im_styles->count_styles; i++) {
			xim_mode = im_styles->supported_styles[i];
			if((xim_mode & app_supported_styles) == xim_mode) { /* if we can handle it */
				n = 0;
				if (xim_mode & best_style) /* pick user selected style */ 
				   break;
			}
		}
	}
	if(n) {
		printf("warning : Unsupport InputStyle. or No IMserver.\n");
		exit (0);
		}

	if (xim_mode & XIMPreeditCallbacks) {
   		ximapicb[0].client_data = (XPointer)NULL;
    		ximapicb[0].callback = (XIMProc)api_preedit_start_cb;
    		ximapicb[1].client_data = (XPointer)(&preedcb_cd);
    		ximapicb[1].callback = (XIMProc)api_preedit_done_cb;
    		ximapicb[2].client_data = (XPointer)(&preedcb_cd);
    		ximapicb[2].callback = (XIMProc)api_preedit_draw_cb;
    		ximapicb[3].client_data = (XPointer)NULL;
    		ximapicb[3].callback = (XIMProc)api_preedit_caret_cb;
    		nestlist = XVaCreateNestedList(10, 
				XNPreeditStartCallback, &ximapicb[0],
                		XNPreeditDoneCallback, &ximapicb[1],
                		XNPreeditDrawCallback, &ximapicb[2],
                		XNPreeditCaretCallback, &ximapicb[3], NULL);
	}

	if (xim_mode & XIMPreeditCallbacks) {
			ic = XCreateIC(im,
			XNInputStyle, xim_mode,
			XNClientWindow, window,
			XNFocusWindow, client,
			XNPreeditAttributes, nestlist,
			NULL);
	} else { 	/* preedit nothing */
			ic = XCreateIC(im, 
				XNInputStyle, xim_mode,
		    		XNClientWindow, window,
		  		XNFocusWindow, client,
		    		NULL );
	}

	if(ic == NULL) {
		printf("Error : XCreateIC() !\n");
		XCloseIM(im);
		exit(0);
		}

	XGetICValues(ic, XNFilterEvents, &im_event_mask, NULL); 
	mask = StructureNotifyMask | FocusChangeMask | ExposureMask;
	XSelectInput(display, window, mask);
	mask = ExposureMask | KeyPressMask | FocusChangeMask | im_event_mask;
	XSelectInput(display, client, mask);

	if(res_file) {
		static char Resouce_name[] = "*";
		char *ret;

		ret = XSetICValues(ic, XNResourceName, Resouce_name, NULL);
		if(ret != NULL)
			printf("Error : XSetICValues() name = %s\n", ret);
		}

	XMapWindow(display, window);
	XMapWindow(display, client);
	JxRealizeText(display, client);

	for(;;) {
		XNextEvent(display, &event);
		if(XFilterEvent(&event, NULL) == True)
			continue;
		switch(event.type ) {
		case FocusIn :
			if(event.xany.window == window)
				XSetInputFocus(display, client, RevertToParent, CurrentTime);
			else if(event.xany.window == client) {
				XSetICFocus(ic);
				}
			break;
		case FocusOut :
			if(event.xany.window == client) {
				XUnsetICFocus(ic);
				}
			break;
		case Expose :
			if(event.xany.window == client)
				JxRedisplayText(display, client, font_set);
			break;
		case KeyPress :
			
			count = XmbLookupString(ic, (XKeyPressedEvent *)&event, string, len, &keysym, NULL);
			if( count == 1 && string[0] == (0x1F&'c')) {	/* exit */
				goto exit;
				}
			if( count > 0 ) {
				JxWriteText(display, client, font_set, 
						count, string);
			}
			break;
		case MappingNotify :
			XRefreshKeyboardMapping( (XMappingEvent *)&event );
			break;
		case DestroyNotify :
			printf("Error : DestroyEvent !\n");
			break;
			}
		}
exit:
	XDestroyIC(ic);
	XCloseIM(im);
	JxDestroyTextWindow(display, client);
	XDestroyWindow(display, window);
	XCloseDisplay(display);
	return(0);
	}

static Window
JxCreateTextWindow(display, window, x, y,
			w_width, w_height, w_bw, bpixel, fpixel,
			font_set, font_heightp)
     Display	*display;
     int	x, y, w_width, w_height, w_bw;
     unsigned long	fpixel, bpixel;
     XFontSet	font_set;
     int	*font_heightp;
     {
     Window	client;
     unsigned long	mask;
     XGCValues      gcvalues;
     XFontSetExtents *fset_extents;

     Jxw_width  = w_width;
     Jxw_height = w_height;

     client = XCreateSimpleWindow(display, window, x, y,
				w_width, w_height, w_bw, bpixel, fpixel);

     mask   = GCBackground | GCForeground;
     gcvalues.foreground = bpixel;
     gcvalues.background = fpixel;
     Jxgc_on  = XCreateGC(display, window, mask, &gcvalues);
     gcvalues.foreground = fpixel;
     gcvalues.background = bpixel;
     Jxgc_off = XCreateGC(display, window, mask, &gcvalues);

     Jxsfont_w = XmbTextEscapement(font_set, "$", 1);
     fset_extents = XExtentsOfFontSet(font_set);
     Jxfont_rect = &(fset_extents->max_logical_extent);
     *font_heightp = Jxfont_height = Jxfont_rect->height;
     Jxline_height = Jxfont_height + 2;
     Jxwfont_w = Jxfont_rect->width;
     return( client );
     }

static int
JxDestroyTextWindow(display, client)
     Display *display;
     Window	client;
     {
     XFreeGC(display, Jxgc_on);
     XFreeGC(display, Jxgc_off);
     XDestroyWindow(display, client);
     }

static int
JxRealizeText(display, client)
     Display *display;
     Window	client;
     {
     int	i;

     Jxline_no = 0;
     for(i=0; i < Jxmax_line; i++) {
	 Jxsize[i] = 0;
	 Jxbuff[i][0] = 0;
	 }
     Jxcx = Jxcx_offset;
     Jxcy = Jxcy_offset; 
     XFillRectangle(display, client, Jxgc_on, Jxcx, Jxcy, Jxsfont_w, Jxfont_height);
     }

static int
JxRedisplayText(display, client, font_set)
     Display *display;
     Window	client;
     XFontSet	font_set;
     {
     int   i, fy;
     for(i=0; i < Jxmax_line; i++) {
         fy   = i * Jxline_height + Jxcy_offset - Jxfont_rect->y;
	 if( Jxsize[i] > 0 ){
             XmbDrawImageString(display, client, font_set, Jxgc_on, 
			   Jxcx_offset, fy, Jxbuff[i], Jxsize[i]);
		}
         }
     XFillRectangle(display, client, Jxgc_on,
			     Jxcx, Jxcy, Jxsfont_w, Jxfont_height);
     }

static int
_JxNextLine()
    {
     Jxcx = Jxcx_offset;
     Jxcy += Jxline_height;
     Jxline_no++;
     if(Jxline_no >= Jxmax_line) {
         Jxline_no = 0;
         Jxcy = Jxcy_offset;
         }
    Jxsize[Jxline_no] = 0;
    Jxbuff[Jxline_no][0] = 0;
    }

#define	LF	0x0a
#define	CR	0x0d
#define	TAB	0x09

static int
JxWriteText(display, client, font_set, len, string)
     Display *display;
     Window	client;
     XFontSet	font_set;
     int	len;
     char	*string;
     {
     int   fy;
     XFillRectangle(display, client, Jxgc_off, Jxcx, Jxcy, Jxsfont_w, Jxfont_height);
     if(len == 1 && 
	 (string[0] == LF || string[0] == TAB || string[0] == CR)) {
	 _JxNextLine();
         XFillRectangle(display, client, Jxgc_off, 0, Jxcy, Jxw_width, Jxfont_height);
	 }
     else {
	 if(Jxcx >= (Jxw_width - Jxwfont_w)
	 || (Jxsize[Jxline_no] + len) >=  256) {
	     _JxNextLine();
             XFillRectangle(display, client, Jxgc_off, 0, Jxcy, Jxw_width, Jxfont_height);
	 }
	 strncpy(&Jxbuff[Jxline_no][Jxsize[Jxline_no]], string, len);
	 Jxsize[Jxline_no] += len;
         fy   = -Jxfont_rect->y + Jxcy;
         XmbDrawImageString(display, client, font_set, Jxgc_on, 
			      Jxcx, fy, string, len);
	 Jxcx += XmbTextEscapement(font_set, string, len);
	 if(Jxcx >= Jxw_width) {
	     _JxNextLine();
             XFillRectangle(display, client, Jxgc_off, 0, Jxcy, Jxw_width, Jxfont_height);
	     }
	 }
     XFillRectangle(display, client, Jxgc_on, Jxcx, Jxcy, Jxsfont_w, Jxfont_height);
     }