| 
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -15,7 +15,6 @@ | 
															
														
														
													
														
															
																 | 
																 | 
																#define INRECT(x,y,rx,ry,rw,rh) ((x) >= (rx) && (x) < (rx)+(rw) && (y) >= (ry) && (y) < (ry)+(rh)) | 
																 | 
																 | 
																#define INRECT(x,y,rx,ry,rw,rh) ((x) >= (rx) && (x) < (rx)+(rw) && (y) >= (ry) && (y) < (ry)+(rh)) | 
															
														
														
													
														
															
																 | 
																 | 
																#define MIN(a,b)                ((a) < (b) ? (a) : (b)) | 
																 | 
																 | 
																#define MIN(a,b)                ((a) < (b) ? (a) : (b)) | 
															
														
														
													
														
															
																 | 
																 | 
																#define MAX(a,b)                ((a) > (b) ? (a) : (b)) | 
																 | 
																 | 
																#define MAX(a,b)                ((a) > (b) ? (a) : (b)) | 
															
														
														
													
														
															
																 | 
																 | 
																#define UTF8_CODEPOINT(c)       (((c) & 0xc0) != 0x80) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																typedef struct Item Item; | 
																 | 
																 | 
																typedef struct Item Item; | 
															
														
														
													
														
															
																 | 
																 | 
																struct Item { | 
																 | 
																 | 
																struct Item { | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -32,7 +31,8 @@ static void grabkeyboard(void); | 
															
														
														
													
														
															
																 | 
																 | 
																static void insert(const char *s, ssize_t n); | 
																 | 
																 | 
																static void insert(const char *s, ssize_t n); | 
															
														
														
													
														
															
																 | 
																 | 
																static void keypress(XKeyEvent *ev); | 
																 | 
																 | 
																static void keypress(XKeyEvent *ev); | 
															
														
														
													
														
															
																 | 
																 | 
																static void match(void); | 
																 | 
																 | 
																static void match(void); | 
															
														
														
													
														
															
																 | 
																 | 
																static void paste(Atom atom); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																static size_t nextrune(int incr); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																static void paste(void); | 
															
														
														
													
														
															
																 | 
																 | 
																static void readstdin(void); | 
																 | 
																 | 
																static void readstdin(void); | 
															
														
														
													
														
															
																 | 
																 | 
																static void run(void); | 
																 | 
																 | 
																static void run(void); | 
															
														
														
													
														
															
																 | 
																 | 
																static void setup(void); | 
																 | 
																 | 
																static void setup(void); | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -52,7 +52,7 @@ static unsigned int lines = 0; | 
															
														
														
													
														
															
																 | 
																 | 
																static unsigned int promptw; | 
																 | 
																 | 
																static unsigned int promptw; | 
															
														
														
													
														
															
																 | 
																 | 
																static unsigned long normcol[ColLast]; | 
																 | 
																 | 
																static unsigned long normcol[ColLast]; | 
															
														
														
													
														
															
																 | 
																 | 
																static unsigned long selcol[ColLast]; | 
																 | 
																 | 
																static unsigned long selcol[ColLast]; | 
															
														
														
													
														
															
																 | 
																 | 
																static Atom clip, utf8; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																static Atom utf8; | 
															
														
														
													
														
															
																 | 
																 | 
																static Bool topbar = True; | 
																 | 
																 | 
																static Bool topbar = True; | 
															
														
														
													
														
															
																 | 
																 | 
																static DC *dc; | 
																 | 
																 | 
																static DC *dc; | 
															
														
														
													
														
															
																 | 
																 | 
																static Item *items = NULL; | 
																 | 
																 | 
																static Item *items = NULL; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -159,7 +159,9 @@ grabkeyboard(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
														
															
																 | 
																 | 
																insert(const char *s, ssize_t n) { | 
																 | 
																 | 
																insert(const char *s, ssize_t n) { | 
															
														
														
													
														
															
																 | 
																 | 
																	memmove(text + cursor + n, text + cursor, sizeof text - cursor - n); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(strlen(text) + n > sizeof text - 1) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	memmove(text + cursor + n, text + cursor, sizeof text - cursor - MAX(n, 0)); | 
															
														
														
													
														
															
																 | 
																 | 
																	if(n > 0) | 
																 | 
																 | 
																	if(n > 0) | 
															
														
														
													
														
															
																 | 
																 | 
																		memcpy(text + cursor, s, n); | 
																 | 
																 | 
																		memcpy(text + cursor, s, n); | 
															
														
														
													
														
															
																 | 
																 | 
																	cursor += n; | 
																 | 
																 | 
																	cursor += n; | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -169,7 +171,6 @@ insert(const char *s, ssize_t n) { | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
														
															
																 | 
																 | 
																keypress(XKeyEvent *ev) { | 
																 | 
																 | 
																keypress(XKeyEvent *ev) { | 
															
														
														
													
														
															
																 | 
																 | 
																	char buf[32]; | 
																 | 
																 | 
																	char buf[32]; | 
															
														
														
													
														
															
																 | 
																 | 
																	int n; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	size_t len; | 
																 | 
																 | 
																	size_t len; | 
															
														
														
													
														
															
																 | 
																 | 
																	KeySym ksym; | 
																 | 
																 | 
																	KeySym ksym; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -217,38 +218,31 @@ keypress(XKeyEvent *ev) { | 
															
														
														
													
														
															
																 | 
																 | 
																			ksym = XK_Up; | 
																 | 
																 | 
																			ksym = XK_Up; | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		case XK_u:  /* delete left */ | 
																 | 
																 | 
																		case XK_u:  /* delete left */ | 
															
														
														
													
														
															
																 | 
																 | 
																			insert(NULL, -cursor); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			insert(NULL, 0 - cursor); | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		case XK_w:  /* delete word */ | 
																 | 
																 | 
																		case XK_w:  /* delete word */ | 
															
														
														
													
														
															
																 | 
																 | 
																			if(cursor == 0) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																				return; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			n = 0; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			while(cursor - n++ > 0 && text[cursor - n] == ' '); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			while(cursor - n++ > 0 && text[cursor - n] != ' '); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			insert(NULL, 1-n); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			while(cursor > 0 && text[nextrune(-1)] == ' ') | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				insert(NULL, nextrune(-1) - cursor); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			while(cursor > 0 && text[nextrune(-1)] != ' ') | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				insert(NULL, nextrune(-1) - cursor); | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		case XK_y:  /* paste selection */ | 
																 | 
																 | 
																		case XK_y:  /* paste selection */ | 
															
														
														
													
														
															
																 | 
																 | 
																			XConvertSelection(dc->dpy, XA_PRIMARY, utf8, clip, win, CurrentTime); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			XConvertSelection(dc->dpy, XA_PRIMARY, utf8, utf8, win, CurrentTime); | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																			return; | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	switch(ksym) { | 
																 | 
																 | 
																	switch(ksym) { | 
															
														
														
													
														
															
																 | 
																 | 
																	default: | 
																 | 
																 | 
																	default: | 
															
														
														
													
														
															
																 | 
																 | 
																		if(isprint(*buf)) | 
																 | 
																 | 
																		if(isprint(*buf)) | 
															
														
														
													
														
															
																 | 
																 | 
																			insert(buf, MIN(strlen(buf), sizeof text - cursor)); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		break; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	case XK_BackSpace: | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		if(cursor == 0) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		for(n = 1; cursor - n > 0 && !UTF8_CODEPOINT(text[cursor - n]); n++); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		insert(NULL, -n); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			insert(buf, strlen(buf)); | 
															
														
														
													
														
															
																 | 
																 | 
																		break; | 
																 | 
																 | 
																		break; | 
															
														
														
													
														
															
																 | 
																 | 
																	case XK_Delete: | 
																 | 
																 | 
																	case XK_Delete: | 
															
														
														
													
														
															
																 | 
																 | 
																		if(cursor == len) | 
																 | 
																 | 
																		if(cursor == len) | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																			return; | 
															
														
														
													
														
															
																 | 
																 | 
																		for(n = 1; cursor + n < len && !UTF8_CODEPOINT(text[cursor + n]); n++); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		cursor += n; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		insert(NULL, -n); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		cursor = nextrune(+1); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	case XK_BackSpace: | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(cursor > 0) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			insert(NULL, nextrune(-1) - cursor); | 
															
														
														
													
														
															
																 | 
																 | 
																		break; | 
																 | 
																 | 
																		break; | 
															
														
														
													
														
															
																 | 
																 | 
																	case XK_End: | 
																 | 
																 | 
																	case XK_End: | 
															
														
														
													
														
															
																 | 
																 | 
																		if(cursor < len) { | 
																 | 
																 | 
																		if(cursor < len) { | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -274,15 +268,13 @@ keypress(XKeyEvent *ev) { | 
															
														
														
													
														
															
																 | 
																 | 
																		break; | 
																 | 
																 | 
																		break; | 
															
														
														
													
														
															
																 | 
																 | 
																	case XK_Left: | 
																 | 
																 | 
																	case XK_Left: | 
															
														
														
													
														
															
																 | 
																 | 
																		if(cursor > 0 && (!sel || !sel->left || lines > 0)) { | 
																 | 
																 | 
																		if(cursor > 0 && (!sel || !sel->left || lines > 0)) { | 
															
														
														
													
														
															
																 | 
																 | 
																			while(cursor-- > 0 && !UTF8_CODEPOINT(text[cursor])); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			cursor = nextrune(-1); | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																		else if(lines > 0) | 
																 | 
																 | 
																		else if(lines > 0) | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																			return; | 
															
														
														
													
														
															
																 | 
																 | 
																	case XK_Up: | 
																 | 
																 | 
																	case XK_Up: | 
															
														
														
													
														
															
																 | 
																 | 
																		if(!sel || !sel->left) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		if((sel = sel->left)->right == curr) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(sel && sel->left && (sel = sel->left)->right == curr) { | 
															
														
														
													
														
															
																 | 
																 | 
																			curr = prev; | 
																 | 
																 | 
																			curr = prev; | 
															
														
														
													
														
															
																 | 
																 | 
																			calcoffsets(); | 
																 | 
																 | 
																			calcoffsets(); | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -306,15 +298,13 @@ keypress(XKeyEvent *ev) { | 
															
														
														
													
														
															
																 | 
																 | 
																		exit(EXIT_SUCCESS); | 
																 | 
																 | 
																		exit(EXIT_SUCCESS); | 
															
														
														
													
														
															
																 | 
																 | 
																	case XK_Right: | 
																 | 
																 | 
																	case XK_Right: | 
															
														
														
													
														
															
																 | 
																 | 
																		if(cursor < len) { | 
																 | 
																 | 
																		if(cursor < len) { | 
															
														
														
													
														
															
																 | 
																 | 
																			while(cursor++ < len && !UTF8_CODEPOINT(text[cursor])); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			cursor = nextrune(+1); | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																		else if(lines > 0) | 
																 | 
																 | 
																		else if(lines > 0) | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																			return; | 
															
														
														
													
														
															
																 | 
																 | 
																	case XK_Down: | 
																 | 
																 | 
																	case XK_Down: | 
															
														
														
													
														
															
																 | 
																 | 
																		if(!sel || !sel->right) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		if((sel = sel->right) == next) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(sel && sel->right && (sel = sel->right) == next) { | 
															
														
														
													
														
															
																 | 
																 | 
																			curr = next; | 
																 | 
																 | 
																			curr = next; | 
															
														
														
													
														
															
																 | 
																 | 
																			calcoffsets(); | 
																 | 
																 | 
																			calcoffsets(); | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -370,14 +360,23 @@ match(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																	calcoffsets(); | 
																 | 
																 | 
																	calcoffsets(); | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																size_t | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																nextrune(int incr) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	size_t n, len; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	len = strlen(text); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	for(n = cursor + incr; n >= 0 && n < len && (text[n] & 0xc0) == 0x80; n += incr); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	return n; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
														
															
																 | 
																 | 
																paste(Atom atom) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																paste(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																	char *p, *q; | 
																 | 
																 | 
																	char *p, *q; | 
															
														
														
													
														
															
																 | 
																 | 
																	int di; | 
																 | 
																 | 
																	int di; | 
															
														
														
													
														
															
																 | 
																 | 
																	unsigned long dl; | 
																 | 
																 | 
																	unsigned long dl; | 
															
														
														
													
														
															
																 | 
																 | 
																	Atom da; | 
																 | 
																 | 
																	Atom da; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	XGetWindowProperty(dc->dpy, win, atom, 0, sizeof text - cursor, False, | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	XGetWindowProperty(dc->dpy, win, utf8, 0, (sizeof text / 4) + 1, False, | 
															
														
														
													
														
															
																 | 
																 | 
																	                   utf8, &da, &di, &dl, &dl, (unsigned char **)&p); | 
																 | 
																 | 
																	                   utf8, &da, &di, &dl, &dl, (unsigned char **)&p); | 
															
														
														
													
														
															
																 | 
																 | 
																	insert(p, (q = strchr(p, '\n')) ? q-p : strlen(p)); | 
																 | 
																 | 
																	insert(p, (q = strchr(p, '\n')) ? q-p : strlen(p)); | 
															
														
														
													
														
															
																 | 
																 | 
																	XFree(p); | 
																 | 
																 | 
																	XFree(p); | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -396,8 +395,8 @@ readstdin(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																			eprintf("cannot malloc %u bytes\n", sizeof *item); | 
																 | 
																 | 
																			eprintf("cannot malloc %u bytes\n", sizeof *item); | 
															
														
														
													
														
															
																 | 
																 | 
																		if(!(item->text = strdup(buf))) | 
																 | 
																 | 
																		if(!(item->text = strdup(buf))) | 
															
														
														
													
														
															
																 | 
																 | 
																			eprintf("cannot strdup %u bytes\n", strlen(buf)+1); | 
																 | 
																 | 
																			eprintf("cannot strdup %u bytes\n", strlen(buf)+1); | 
															
														
														
													
														
															
																 | 
																 | 
																		inputw = MAX(inputw, textw(dc, item->text)); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		item->next = item->left = item->right = NULL; | 
																 | 
																 | 
																		item->next = item->left = item->right = NULL; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		inputw = MAX(inputw, textw(dc, item->text)); | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -415,8 +414,8 @@ run(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																			keypress(&ev.xkey); | 
																 | 
																 | 
																			keypress(&ev.xkey); | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		case SelectionNotify: | 
																 | 
																 | 
																		case SelectionNotify: | 
															
														
														
													
														
															
																 | 
																 | 
																			if(ev.xselection.property != None) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																				paste(ev.xselection.property); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			if(ev.xselection.property == utf8) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				paste(); | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		case VisibilityNotify: | 
																 | 
																 | 
																		case VisibilityNotify: | 
															
														
														
													
														
															
																 | 
																 | 
																			if(ev.xvisibility.state != VisibilityUnobscured) | 
																 | 
																 | 
																			if(ev.xvisibility.state != VisibilityUnobscured) | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -437,7 +436,6 @@ setup(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																	screen = DefaultScreen(dc->dpy); | 
																 | 
																 | 
																	screen = DefaultScreen(dc->dpy); | 
															
														
														
													
														
															
																 | 
																 | 
																	root = RootWindow(dc->dpy, screen); | 
																 | 
																 | 
																	root = RootWindow(dc->dpy, screen); | 
															
														
														
													
														
															
																 | 
																 | 
																	utf8 = XInternAtom(dc->dpy, "UTF8_STRING", False); | 
																 | 
																 | 
																	utf8 = XInternAtom(dc->dpy, "UTF8_STRING", False); | 
															
														
														
													
														
															
																 | 
																 | 
																	clip = XInternAtom(dc->dpy, "_DMENU_STRING", False); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	normcol[ColBG] = getcolor(dc, normbgcolor); | 
																 | 
																 | 
																	normcol[ColBG] = getcolor(dc, normbgcolor); | 
															
														
														
													
														
															
																 | 
																 | 
																	normcol[ColFG] = getcolor(dc, normfgcolor); | 
																 | 
																 | 
																	normcol[ColFG] = getcolor(dc, normfgcolor); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																	
																 | 
																
  |