5 #include <X11/keysym.h>
10 #define CURSOR_BLINK_ON_DELAY 600
11 #define CURSOR_BLINK_OFF_DELAY 300
13 char *WMTextDidChangeNotification
= "WMTextDidChangeNotification";
14 char *WMTextDidBeginEditingNotification
= "WMTextDidBeginEditingNotification";
15 char *WMTextDidEndEditingNotification
= "WMTextDidEndEditingNotification";
17 typedef struct W_TextField
{
22 struct W_TextField
*nextField
; /* next textfield in the chain */
23 struct W_TextField
*prevField
;
27 int textLen
; /* size of text */
28 int bufferSize
; /* memory allocated for text */
30 int viewPosition
; /* position of text being shown */
32 int cursorPosition
; /* position of the insertion cursor */
35 short offsetWidth
; /* offset of text from border */
41 WMTextFieldDelegate
*delegate
;
44 WMHandlerID timerID
; /* for cursor blinking */
47 WMAlignment alignment
:2;
49 unsigned int bordered
:1;
51 unsigned int beveled
:1;
53 unsigned int enabled
:1;
55 unsigned int focused
:1;
57 unsigned int cursorOn
:1;
59 unsigned int secure
:1; /* password entry style */
61 unsigned int pointerGrabbed
:1;
63 unsigned int ownsSelection
:1;
65 unsigned int waitingSelection
:1; /* requested selection, but
68 unsigned int notIllegalMovement
:1;
72 #define NOTIFY(T,C,N,A) { WMNotification *notif = WMCreateNotification(N,T,A);\
73 if ((T)->delegate && (T)->delegate->C)\
74 (*(T)->delegate->C)((T)->delegate,notif);\
75 WMPostNotification(notif);\
76 WMReleaseNotification(notif);}
78 #define MIN_TEXT_BUFFER 2
79 #define TEXT_BUFFER_INCR 8
81 #define WM_EMACSKEYMASK ControlMask
83 #define WM_EMACSKEY_LEFT XK_b
84 #define WM_EMACSKEY_RIGHT XK_f
85 #define WM_EMACSKEY_HOME XK_a
86 #define WM_EMACSKEY_END XK_e
87 #define WM_EMACSKEY_BS XK_h
88 #define WM_EMACSKEY_DEL XK_d
90 #define DEFAULT_WIDTH 60
91 #define DEFAULT_HEIGHT 20
92 #define DEFAULT_BORDERED True
93 #define DEFAULT_ALIGNMENT WALeft
95 static void destroyTextField(TextField
* tPtr
);
96 static void paintTextField(TextField
* tPtr
);
98 static void handleEvents(XEvent
* event
, void *data
);
99 static void handleTextFieldActionEvents(XEvent
* event
, void *data
);
100 static void didResizeTextField();
102 struct W_ViewDelegate _TextFieldViewDelegate
= {
110 static void lostSelection(WMView
* view
, Atom selection
, void *cdata
);
112 static WMData
*requestHandler(WMView
* view
, Atom selection
, Atom target
, void *cdata
, Atom
* type
);
114 static WMSelectionProcs selectionHandler
= {
120 #define TEXT_WIDTH(tPtr, start) (WMWidthOfString((tPtr)->font, \
121 &((tPtr)->text[(start)]), (tPtr)->textLen - (start)))
123 #define TEXT_WIDTH2(tPtr, start, end) (WMWidthOfString((tPtr)->font, \
124 &((tPtr)->text[(start)]), (end) - (start)))
126 static INLINE
int oneUTF8CharBackward(char *str
, int len
)
128 unsigned char *ustr
= (unsigned char *)str
;
131 while (len
-- > 0 && ustr
[--pos
] >= 0x80 && ustr
[pos
] <= 0xbf) ;
135 static INLINE
int oneUTF8CharForward(char *str
, int len
)
137 unsigned char *ustr
= (unsigned char *)str
;
140 while (len
-- > 0 && ustr
[++pos
] >= 0x80 && ustr
[pos
] <= 0xbf) ;
144 // find the beginning of the UTF8 char pointed by str
145 static INLINE
int seekUTF8CharStart(char *str
, int len
)
147 unsigned char *ustr
= (unsigned char *)str
;
150 while (len
-- > 0 && ustr
[pos
] >= 0x80 && ustr
[pos
] <= 0xbf)
155 static void normalizeRange(TextField
* tPtr
, WMRange
* range
)
157 if (range
->position
< 0 && range
->count
< 0)
160 if (range
->count
== 0) {
161 /*range->position = 0; why is this? */
165 /* (1,-2) ~> (0,1) ; (1,-1) ~> (0,1) ; (2,-1) ~> (1,1) */
166 if (range
->count
< 0) { /* && range->position >= 0 */
167 if (range
->position
+ range
->count
< 0) {
168 range
->count
= range
->position
;
171 range
->count
= -range
->count
;
172 range
->position
-= range
->count
;
174 /* (-2,1) ~> (0,0) ; (-1,1) ~> (0,0) ; (-1,2) ~> (0,1) */
175 } else if (range
->position
< 0) { /* && range->count > 0 */
176 if (range
->position
+ range
->count
< 0) {
177 range
->position
= range
->count
= 0;
179 range
->count
+= range
->position
;
184 if (range
->position
+ range
->count
> tPtr
->textLen
)
185 range
->count
= tPtr
->textLen
- range
->position
;
188 static void memmv(char *dest
, char *src
, int size
)
193 for (i
= size
- 1; i
>= 0; i
--) {
196 } else if (dest
< src
) {
197 for (i
= 0; i
< size
; i
++) {
203 static int incrToFit(TextField
* tPtr
)
205 int vp
= tPtr
->viewPosition
;
207 while (TEXT_WIDTH(tPtr
, tPtr
->viewPosition
) > tPtr
->usableWidth
) {
208 tPtr
->viewPosition
+= oneUTF8CharForward(&tPtr
->text
[tPtr
->viewPosition
],
209 tPtr
->textLen
- tPtr
->viewPosition
);
211 return vp
!= tPtr
->viewPosition
;
214 static int incrToFit2(TextField
* tPtr
)
216 int vp
= tPtr
->viewPosition
;
218 while (TEXT_WIDTH2(tPtr
, tPtr
->viewPosition
, tPtr
->cursorPosition
)
219 >= tPtr
->usableWidth
)
220 tPtr
->viewPosition
+= oneUTF8CharForward(&tPtr
->text
[tPtr
->viewPosition
],
221 tPtr
->cursorPosition
- tPtr
->viewPosition
);
222 return vp
!= tPtr
->viewPosition
;
225 static void decrToFit(TextField
* tPtr
)
227 int vp
= tPtr
->viewPosition
;
229 while (vp
> 0 && (vp
+= oneUTF8CharBackward(&tPtr
->text
[vp
], vp
),
230 TEXT_WIDTH(tPtr
, vp
)) < tPtr
->usableWidth
) {
231 tPtr
->viewPosition
= vp
;
238 static WMData
*requestHandler(WMView
* view
, Atom selection
, Atom target
, void *cdata
, Atom
* type
)
240 TextField
*tPtr
= view
->self
;
242 Display
*dpy
= tPtr
->view
->screen
->display
;
244 Atom TEXT
= XInternAtom(dpy
, "TEXT", False
);
245 Atom COMPOUND_TEXT
= XInternAtom(dpy
, "COMPOUND_TEXT", False
);
248 count
= tPtr
->selection
.count
< 0
249 ? tPtr
->selection
.position
+ tPtr
->selection
.count
: tPtr
->selection
.position
;
251 if (target
== XA_STRING
|| target
== TEXT
|| target
== COMPOUND_TEXT
) {
253 data
= WMCreateDataWithBytes(&(tPtr
->text
[count
]), abs(tPtr
->selection
.count
));
254 WMSetDataFormat(data
, 8);
260 _TARGETS
= XInternAtom(dpy
, "TARGETS", False
);
261 if (target
== _TARGETS
) {
264 ptr
= wmalloc(4 * sizeof(Atom
));
268 ptr
[3] = COMPOUND_TEXT
;
270 data
= WMCreateDataWithBytes(ptr
, 4 * 4);
271 WMSetDataFormat(data
, 32);
281 static void lostSelection(WMView
* view
, Atom selection
, void *cdata
)
283 TextField
*tPtr
= (WMTextField
*) view
->self
;
285 if (tPtr
->flags
.ownsSelection
) {
286 WMDeleteSelectionHandler(view
, selection
, CurrentTime
);
287 tPtr
->flags
.ownsSelection
= 0;
289 if (tPtr
->selection
.count
!= 0) {
290 tPtr
->selection
.count
= 0;
291 paintTextField(tPtr
);
295 static void selectionNotification(void *observerData
, WMNotification
* notification
)
297 WMView
*observerView
= (WMView
*) observerData
;
298 WMView
*newOwnerView
= (WMView
*) WMGetNotificationClientData(notification
);
300 if (observerView
!= newOwnerView
) {
302 //if (tPtr->flags.ownsSelection)
303 // WMDeleteSelectionHandler(observerView, XA_PRIMARY, CurrentTime);
305 lostSelection(observerView
, XA_PRIMARY
, NULL
);
309 static void realizeObserver(void *self
, WMNotification
* not)
311 W_CreateIC(((TextField
*) self
)->view
);
314 WMTextField
*WMCreateTextField(WMWidget
* parent
)
318 tPtr
= wmalloc(sizeof(TextField
));
319 memset(tPtr
, 0, sizeof(TextField
));
321 tPtr
->widgetClass
= WC_TextField
;
323 tPtr
->view
= W_CreateView(W_VIEW(parent
));
328 tPtr
->view
->self
= tPtr
;
330 tPtr
->view
->delegate
= &_TextFieldViewDelegate
;
332 tPtr
->view
->attribFlags
|= CWCursor
;
333 tPtr
->view
->attribs
.cursor
= tPtr
->view
->screen
->textCursor
;
335 W_SetViewBackgroundColor(tPtr
->view
, tPtr
->view
->screen
->white
);
337 tPtr
->text
= wmalloc(MIN_TEXT_BUFFER
);
340 tPtr
->bufferSize
= MIN_TEXT_BUFFER
;
342 tPtr
->flags
.enabled
= 1;
344 WMCreateEventHandler(tPtr
->view
, ExposureMask
| StructureNotifyMask
| FocusChangeMask
, handleEvents
, tPtr
);
346 tPtr
->font
= WMRetainFont(tPtr
->view
->screen
->normalFont
);
348 tPtr
->flags
.bordered
= DEFAULT_BORDERED
;
349 tPtr
->flags
.beveled
= True
;
350 tPtr
->flags
.alignment
= DEFAULT_ALIGNMENT
;
351 tPtr
->offsetWidth
= WMAX((tPtr
->view
->size
.height
- WMFontHeight(tPtr
->font
)) / 2, 1);
353 W_ResizeView(tPtr
->view
, DEFAULT_WIDTH
, DEFAULT_HEIGHT
);
355 WMCreateEventHandler(tPtr
->view
, EnterWindowMask
| LeaveWindowMask
356 | ButtonReleaseMask
| ButtonPressMask
| KeyPressMask
| Button1MotionMask
,
357 handleTextFieldActionEvents
, tPtr
);
359 WMAddNotificationObserver(selectionNotification
, tPtr
->view
,
360 WMSelectionOwnerDidChangeNotification
, (void *)XA_PRIMARY
);
362 WMAddNotificationObserver(realizeObserver
, tPtr
, WMViewRealizedNotification
, tPtr
->view
);
364 tPtr
->flags
.cursorOn
= 1;
369 void WMSetTextFieldDelegate(WMTextField
* tPtr
, WMTextFieldDelegate
* delegate
)
371 CHECK_CLASS(tPtr
, WC_TextField
);
373 tPtr
->delegate
= delegate
;
376 WMTextFieldDelegate
*WMGetTextFieldDelegate(WMTextField
* tPtr
)
378 CHECK_CLASS(tPtr
, WC_TextField
);
380 return tPtr
->delegate
;
383 void WMInsertTextFieldText(WMTextField
* tPtr
, char *text
, int position
)
387 CHECK_CLASS(tPtr
, WC_TextField
);
394 /* check if buffer will hold the text */
395 if (len
+ tPtr
->textLen
>= tPtr
->bufferSize
) {
396 tPtr
->bufferSize
= tPtr
->textLen
+ len
+ TEXT_BUFFER_INCR
;
397 tPtr
->text
= wrealloc(tPtr
->text
, tPtr
->bufferSize
);
400 if (position
< 0 || position
>= tPtr
->textLen
) {
401 /* append the text at the end */
402 strcat(tPtr
->text
, text
);
403 tPtr
->textLen
+= len
;
404 tPtr
->cursorPosition
+= len
;
407 /* insert text at position */
408 memmv(&(tPtr
->text
[position
+ len
]), &(tPtr
->text
[position
]), tPtr
->textLen
- position
+ 1);
410 memcpy(&(tPtr
->text
[position
]), text
, len
);
412 tPtr
->textLen
+= len
;
413 if (position
>= tPtr
->cursorPosition
) {
414 tPtr
->cursorPosition
+= len
;
421 paintTextField(tPtr
);
424 void WMDeleteTextFieldRange(WMTextField
* tPtr
, WMRange range
)
426 CHECK_CLASS(tPtr
, WC_TextField
);
428 normalizeRange(tPtr
, &range
);
433 memmv(&(tPtr
->text
[range
.position
]), &(tPtr
->text
[range
.position
+ range
.count
]),
434 tPtr
->textLen
- (range
.position
+ range
.count
) + 1);
436 /* better than nothing ;) */
437 if (tPtr
->cursorPosition
> range
.position
)
438 tPtr
->viewPosition
+= oneUTF8CharBackward(&tPtr
->text
[tPtr
->viewPosition
], tPtr
->viewPosition
);
439 tPtr
->textLen
-= range
.count
;
440 tPtr
->cursorPosition
= range
.position
;
444 paintTextField(tPtr
);
447 char *WMGetTextFieldText(WMTextField
* tPtr
)
449 CHECK_CLASS(tPtr
, WC_TextField
);
451 return wstrdup(tPtr
->text
);
454 void WMSetTextFieldText(WMTextField
* tPtr
, char *text
)
456 CHECK_CLASS(tPtr
, WC_TextField
);
458 if ((text
&& strcmp(tPtr
->text
, text
) == 0) || (!text
&& tPtr
->textLen
== 0))
465 tPtr
->textLen
= strlen(text
);
467 if (tPtr
->textLen
>= tPtr
->bufferSize
) {
468 tPtr
->bufferSize
= tPtr
->textLen
+ TEXT_BUFFER_INCR
;
469 tPtr
->text
= wrealloc(tPtr
->text
, tPtr
->bufferSize
);
471 strcpy(tPtr
->text
, text
);
474 tPtr
->cursorPosition
= tPtr
->selection
.position
= tPtr
->textLen
;
475 tPtr
->viewPosition
= 0;
476 tPtr
->selection
.count
= 0;
478 if (tPtr
->view
->flags
.realized
)
479 paintTextField(tPtr
);
482 void WMSetTextFieldAlignment(WMTextField
* tPtr
, WMAlignment alignment
)
484 CHECK_CLASS(tPtr
, WC_TextField
);
486 tPtr
->flags
.alignment
= alignment
;
488 if (alignment
!= WALeft
) {
489 wwarning("only left alignment is supported in textfields");
493 if (tPtr
->view
->flags
.realized
) {
494 paintTextField(tPtr
);
498 void WMSetTextFieldBordered(WMTextField
* tPtr
, Bool bordered
)
500 CHECK_CLASS(tPtr
, WC_TextField
);
502 tPtr
->flags
.bordered
= bordered
;
504 if (tPtr
->view
->flags
.realized
) {
505 paintTextField(tPtr
);
509 void WMSetTextFieldBeveled(WMTextField
* tPtr
, Bool flag
)
511 CHECK_CLASS(tPtr
, WC_TextField
);
513 tPtr
->flags
.beveled
= ((flag
== 0) ? 0 : 1);
515 if (tPtr
->view
->flags
.realized
) {
516 paintTextField(tPtr
);
520 void WMSetTextFieldSecure(WMTextField
* tPtr
, Bool flag
)
522 CHECK_CLASS(tPtr
, WC_TextField
);
524 tPtr
->flags
.secure
= ((flag
== 0) ? 0 : 1);
526 if (tPtr
->view
->flags
.realized
) {
527 paintTextField(tPtr
);
531 Bool
WMGetTextFieldEditable(WMTextField
* tPtr
)
533 CHECK_CLASS(tPtr
, WC_TextField
);
535 return tPtr
->flags
.enabled
;
538 void WMSetTextFieldEditable(WMTextField
* tPtr
, Bool flag
)
540 CHECK_CLASS(tPtr
, WC_TextField
);
542 tPtr
->flags
.enabled
= ((flag
== 0) ? 0 : 1);
544 if (tPtr
->view
->flags
.realized
) {
545 paintTextField(tPtr
);
549 void WMSelectTextFieldRange(WMTextField
* tPtr
, WMRange range
)
551 CHECK_CLASS(tPtr
, WC_TextField
);
553 if (tPtr
->flags
.enabled
) {
554 normalizeRange(tPtr
, &range
);
556 tPtr
->selection
= range
;
558 tPtr
->cursorPosition
= range
.position
+ range
.count
;
560 if (tPtr
->view
->flags
.realized
) {
561 paintTextField(tPtr
);
566 void WMSetTextFieldCursorPosition(WMTextField
* tPtr
, unsigned int position
)
568 CHECK_CLASS(tPtr
, WC_TextField
);
570 if (tPtr
->flags
.enabled
) {
571 if (position
> tPtr
->textLen
)
572 position
= tPtr
->textLen
;
574 tPtr
->cursorPosition
= position
;
575 if (tPtr
->view
->flags
.realized
) {
576 paintTextField(tPtr
);
581 void WMSetTextFieldNextTextField(WMTextField
* tPtr
, WMTextField
* next
)
583 CHECK_CLASS(tPtr
, WC_TextField
);
585 if (tPtr
->view
->nextFocusChain
)
586 tPtr
->view
->nextFocusChain
->prevFocusChain
= NULL
;
587 tPtr
->view
->nextFocusChain
= NULL
;
591 CHECK_CLASS(next
, WC_TextField
);
593 if (tPtr
->view
->nextFocusChain
)
594 tPtr
->view
->nextFocusChain
->prevFocusChain
= NULL
;
595 if (next
->view
->prevFocusChain
)
596 next
->view
->prevFocusChain
->nextFocusChain
= NULL
;
598 tPtr
->view
->nextFocusChain
= next
->view
;
599 next
->view
->prevFocusChain
= tPtr
->view
;
602 void WMSetTextFieldPrevTextField(WMTextField
* tPtr
, WMTextField
* prev
)
604 CHECK_CLASS(tPtr
, WC_TextField
);
606 if (tPtr
->view
->prevFocusChain
)
607 tPtr
->view
->prevFocusChain
->nextFocusChain
= NULL
;
608 tPtr
->view
->prevFocusChain
= NULL
;
612 CHECK_CLASS(prev
, WC_TextField
);
614 if (tPtr
->view
->prevFocusChain
)
615 tPtr
->view
->prevFocusChain
->nextFocusChain
= NULL
;
616 if (prev
->view
->nextFocusChain
)
617 prev
->view
->nextFocusChain
->prevFocusChain
= NULL
;
619 tPtr
->view
->prevFocusChain
= prev
->view
;
620 prev
->view
->nextFocusChain
= tPtr
->view
;
623 void WMSetTextFieldFont(WMTextField
* tPtr
, WMFont
* font
)
625 CHECK_CLASS(tPtr
, WC_TextField
);
628 WMReleaseFont(tPtr
->font
);
629 tPtr
->font
= WMRetainFont(font
);
631 tPtr
->offsetWidth
= WMAX((tPtr
->view
->size
.height
- WMFontHeight(tPtr
->font
)) / 2, 1);
633 if (tPtr
->view
->flags
.realized
) {
634 paintTextField(tPtr
);
638 WMFont
*WMGetTextFieldFont(WMTextField
* tPtr
)
643 static void didResizeTextField(W_ViewDelegate
* self
, WMView
* view
)
645 WMTextField
*tPtr
= (WMTextField
*) view
->self
;
647 tPtr
->offsetWidth
= WMAX((tPtr
->view
->size
.height
- WMFontHeight(tPtr
->font
)) / 2, 1);
649 tPtr
->usableWidth
= tPtr
->view
->size
.width
- 2 * tPtr
->offsetWidth
/*+ 2 */ ;
652 static char *makeHiddenString(int length
)
654 char *data
= wmalloc(length
+ 1);
656 memset(data
, '*', length
);
662 static void paintCursor(TextField
* tPtr
)
665 WMScreen
*screen
= tPtr
->view
->screen
;
669 if (tPtr
->flags
.secure
)
670 text
= makeHiddenString(strlen(tPtr
->text
));
674 cx
= WMWidthOfString(tPtr
->font
, &(text
[tPtr
->viewPosition
]), tPtr
->cursorPosition
- tPtr
->viewPosition
);
676 switch (tPtr
->flags
.alignment
) {
678 textWidth
= WMWidthOfString(tPtr
->font
, text
, tPtr
->textLen
);
679 if (textWidth
< tPtr
->usableWidth
)
680 cx
+= tPtr
->offsetWidth
+ tPtr
->usableWidth
- textWidth
+ 1;
682 cx
+= tPtr
->offsetWidth
+ 1;
685 cx
+= tPtr
->offsetWidth
+ 1;
690 textWidth
= WMWidthOfString(tPtr
->font
, text
, tPtr
->textLen
);
691 if (textWidth
< tPtr
->usableWidth
)
692 cx
+= tPtr
->offsetWidth
+ (tPtr
->usableWidth
- textWidth
) / 2;
694 cx
+= tPtr
->offsetWidth
;
698 XDrawRectangle(screen->display, tPtr->view->window, screen->xorGC,
699 cx, tPtr->offsetWidth, 1,
700 tPtr->view->size.height - 2*tPtr->offsetWidth - 1);
701 printf("%d %d\n",cx,tPtr->cursorPosition);
704 XDrawLine(screen
->display
, tPtr
->view
->window
, screen
->xorGC
,
705 cx
, tPtr
->offsetWidth
, cx
, tPtr
->view
->size
.height
- tPtr
->offsetWidth
- 1);
707 W_SetPreeditPositon(tPtr
->view
, cx
, 0);
709 if (tPtr
->flags
.secure
) {
714 static void drawRelief(WMView
* view
, Bool beveled
)
716 WMScreen
*scr
= view
->screen
;
717 Display
*dpy
= scr
->display
;
721 int width
= view
->size
.width
;
722 int height
= view
->size
.height
;
724 dgc
= WMColorGC(scr
->darkGray
);
727 XDrawRectangle(dpy
, view
->window
, dgc
, 0, 0, width
- 1, height
- 1);
731 wgc
= WMColorGC(scr
->white
);
732 lgc
= WMColorGC(scr
->gray
);
735 XDrawLine(dpy
, view
->window
, dgc
, 0, 0, width
- 1, 0);
736 XDrawLine(dpy
, view
->window
, dgc
, 0, 1, width
- 2, 1);
738 XDrawLine(dpy
, view
->window
, dgc
, 0, 0, 0, height
- 2);
739 XDrawLine(dpy
, view
->window
, dgc
, 1, 0, 1, height
- 3);
742 XDrawLine(dpy
, view
->window
, wgc
, 0, height
- 1, width
- 1, height
- 1);
743 XDrawLine(dpy
, view
->window
, lgc
, 1, height
- 2, width
- 2, height
- 2);
745 XDrawLine(dpy
, view
->window
, wgc
, width
- 1, 0, width
- 1, height
- 1);
746 XDrawLine(dpy
, view
->window
, lgc
, width
- 2, 1, width
- 2, height
- 3);
749 static void paintTextField(TextField
* tPtr
)
751 W_Screen
*screen
= tPtr
->view
->screen
;
752 W_View
*view
= tPtr
->view
;
762 if (!view
->flags
.realized
|| !view
->flags
.mapped
)
765 if (!tPtr
->flags
.bordered
) {
771 if (tPtr
->flags
.secure
) {
772 text
= makeHiddenString(strlen(tPtr
->text
));
777 totalWidth
= tPtr
->view
->size
.width
- 2 * bd
;
779 drawbuffer
= XCreatePixmap(screen
->display
, view
->window
,
780 view
->size
.width
, view
->size
.height
, screen
->depth
);
781 XFillRectangle(screen
->display
, drawbuffer
, WMColorGC(screen
->white
),
782 0, 0, view
->size
.width
, view
->size
.height
);
783 /* this is quite dirty */
784 viewbuffer
.screen
= view
->screen
;
785 viewbuffer
.size
= view
->size
;
786 viewbuffer
.window
= drawbuffer
;
788 if (tPtr
->textLen
> 0) {
789 tw
= WMWidthOfString(tPtr
->font
, &(text
[tPtr
->viewPosition
]), tPtr
->textLen
- tPtr
->viewPosition
);
791 th
= WMFontHeight(tPtr
->font
);
793 ty
= tPtr
->offsetWidth
;
794 switch (tPtr
->flags
.alignment
) {
796 tx
= tPtr
->offsetWidth
+ 1;
797 if (tw
< tPtr
->usableWidth
)
798 XFillRectangle(screen
->display
, drawbuffer
,
799 WMColorGC(screen
->white
),
800 bd
+ tw
, bd
, totalWidth
- tw
, view
->size
.height
- 2 * bd
);
804 tx
= tPtr
->offsetWidth
+ (tPtr
->usableWidth
- tw
) / 2;
805 if (tw
< tPtr
->usableWidth
)
806 XClearArea(screen
->display
, view
->window
, bd
, bd
,
807 totalWidth
, view
->size
.height
- 2 * bd
, False
);
812 tx
= tPtr
->offsetWidth
+ tPtr
->usableWidth
- tw
- 1;
813 if (tw
< tPtr
->usableWidth
)
814 XClearArea(screen
->display
, view
->window
, bd
, bd
,
815 totalWidth
- tw
, view
->size
.height
- 2 * bd
, False
);
819 color
= tPtr
->flags
.enabled
? screen
->black
: screen
->darkGray
;
821 WMDrawImageString(screen
, drawbuffer
, color
, screen
->white
,
822 tPtr
->font
, tx
, ty
, &(text
[tPtr
->viewPosition
]),
823 tPtr
->textLen
- tPtr
->viewPosition
);
825 if (tPtr
->selection
.count
) {
828 count
= tPtr
->selection
.count
< 0
829 ? tPtr
->selection
.position
+ tPtr
->selection
.count
: tPtr
->selection
.position
;
830 count2
= abs(tPtr
->selection
.count
);
831 if (count
< tPtr
->viewPosition
) {
832 count2
= abs(count2
- abs(tPtr
->viewPosition
- count
));
833 count
= tPtr
->viewPosition
;
836 rx
= tPtr
->offsetWidth
+ 1 + WMWidthOfString(tPtr
->font
, text
, count
)
837 - WMWidthOfString(tPtr
->font
, text
, tPtr
->viewPosition
);
839 WMDrawImageString(screen
, drawbuffer
, color
, screen
->gray
,
840 tPtr
->font
, rx
, ty
, &(text
[count
]), count2
);
843 XFillRectangle(screen
->display
, drawbuffer
, WMColorGC(screen
->white
),
844 bd
, bd
, totalWidth
, view
->size
.height
- 2 * bd
);
848 if (tPtr
->flags
.bordered
) {
849 drawRelief(&viewbuffer
, tPtr
->flags
.beveled
);
852 if (tPtr
->flags
.secure
)
854 XCopyArea(screen
->display
, drawbuffer
, view
->window
,
855 screen
->copyGC
, 0, 0, view
->size
.width
, view
->size
.height
, 0, 0);
856 XFreePixmap(screen
->display
, drawbuffer
);
859 if (tPtr
->flags
.focused
&& tPtr
->flags
.enabled
&& tPtr
->flags
.cursorOn
) {
865 static void blinkCursor(void *data
)
867 TextField
*tPtr
= (TextField
*) data
;
869 if (tPtr
->flags
.cursorOn
) {
870 tPtr
->timerID
= WMAddTimerHandler(CURSOR_BLINK_OFF_DELAY
, blinkCursor
, data
);
872 tPtr
->timerID
= WMAddTimerHandler(CURSOR_BLINK_ON_DELAY
, blinkCursor
, data
);
875 tPtr
->flags
.cursorOn
= !tPtr
->flags
.cursorOn
;
879 static void handleEvents(XEvent
* event
, void *data
)
881 TextField
*tPtr
= (TextField
*) data
;
883 CHECK_CLASS(data
, WC_TextField
);
885 switch (event
->type
) {
887 W_FocusIC(tPtr
->view
);
888 if (W_FocusedViewOfToplevel(W_TopLevelOfView(tPtr
->view
)) != tPtr
->view
)
890 tPtr
->flags
.focused
= 1;
892 if (!tPtr
->timerID
) {
893 tPtr
->timerID
= WMAddTimerHandler(CURSOR_BLINK_ON_DELAY
, blinkCursor
, tPtr
);
896 paintTextField(tPtr
);
898 NOTIFY(tPtr
, didBeginEditing
, WMTextDidBeginEditingNotification
, NULL
);
900 tPtr
->flags
.notIllegalMovement
= 0;
904 W_UnFocusIC(tPtr
->view
);
905 tPtr
->flags
.focused
= 0;
908 WMDeleteTimerHandler(tPtr
->timerID
);
909 tPtr
->timerID
= NULL
;
912 paintTextField(tPtr
);
913 if (!tPtr
->flags
.notIllegalMovement
) {
914 NOTIFY(tPtr
, didEndEditing
, WMTextDidEndEditingNotification
,
915 (void *)WMIllegalTextMovement
);
920 if (event
->xexpose
.count
!= 0)
922 paintTextField(tPtr
);
926 destroyTextField(tPtr
);
931 static void handleTextFieldKeyPress(TextField
* tPtr
, XEvent
* event
)
935 char *textEvent
= NULL
;
937 int count
, refresh
= 0;
938 int control_pressed
= 0;
939 int cancelSelection
= 1;
940 Bool shifted
, controled
, modified
;
943 /*printf("(%d,%d) -> ", tPtr->selection.position, tPtr->selection.count); */
944 if (((XKeyEvent
*) event
)->state
& WM_EMACSKEYMASK
)
947 shifted
= (event
->xkey
.state
& ShiftMask
? True
: False
);
948 controled
= (event
->xkey
.state
& ControlMask
? True
: False
);
949 modified
= shifted
|| controled
;
951 count
= W_LookupString(tPtr
->view
, &event
->xkey
, buffer
, 63, &ksym
, NULL
);
952 //count = XLookupString(&event->xkey, buffer, 63, &ksym, NULL);
953 buffer
[count
] = '\0';
957 #ifdef XK_ISO_Left_Tab
958 case XK_ISO_Left_Tab
:
962 if (tPtr
->view
->prevFocusChain
) {
963 W_SetFocusOfTopLevel(W_TopLevelOfView(tPtr
->view
),
964 tPtr
->view
->prevFocusChain
);
965 tPtr
->flags
.notIllegalMovement
= 1;
967 data
= (void *)WMBacktabTextMovement
;
969 if (tPtr
->view
->nextFocusChain
) {
970 W_SetFocusOfTopLevel(W_TopLevelOfView(tPtr
->view
),
971 tPtr
->view
->nextFocusChain
);
972 tPtr
->flags
.notIllegalMovement
= 1;
974 data
= (void *)WMTabTextMovement
;
976 textEvent
= WMTextDidEndEditingNotification
;
986 data
= (void *)WMEscapeTextMovement
;
987 textEvent
= WMTextDidEndEditingNotification
;
995 data
= (void *)WMReturnTextMovement
;
996 textEvent
= WMTextDidEndEditingNotification
;
1002 case WM_EMACSKEY_LEFT
:
1003 if (!control_pressed
)
1012 if (tPtr
->cursorPosition
> 0) {
1016 i
= tPtr
->cursorPosition
;
1017 i
+= oneUTF8CharBackward(&tPtr
->text
[i
], i
);
1019 while (i
> 0 && tPtr
->text
[i
] != ' ')
1021 while (i
> 0 && tPtr
->text
[i
] == ' ')
1024 tPtr
->cursorPosition
= (i
> 0) ? i
+ 1 : 0;
1026 tPtr
->cursorPosition
= i
;
1028 if (tPtr
->cursorPosition
< tPtr
->viewPosition
) {
1029 tPtr
->viewPosition
= tPtr
->cursorPosition
;
1035 cancelSelection
= 0;
1041 case WM_EMACSKEY_RIGHT
:
1042 if (!control_pressed
)
1051 if (tPtr
->cursorPosition
< tPtr
->textLen
) {
1055 i
= tPtr
->cursorPosition
;
1057 while (tPtr
->text
[i
] && tPtr
->text
[i
] != ' ')
1059 while (tPtr
->text
[i
] == ' ')
1062 i
+= oneUTF8CharForward(&tPtr
->text
[i
], tPtr
->textLen
- i
);
1064 tPtr
->cursorPosition
= i
;
1066 refresh
= incrToFit2(tPtr
);
1072 cancelSelection
= 0;
1078 case WM_EMACSKEY_HOME
:
1079 if (!control_pressed
)
1089 if (tPtr
->cursorPosition
> 0) {
1091 tPtr
->cursorPosition
= 0;
1092 if (tPtr
->viewPosition
> 0) {
1093 tPtr
->viewPosition
= 0;
1099 cancelSelection
= 0;
1105 case WM_EMACSKEY_END
:
1106 if (!control_pressed
)
1116 if (tPtr
->cursorPosition
< tPtr
->textLen
) {
1118 tPtr
->cursorPosition
= tPtr
->textLen
;
1119 tPtr
->viewPosition
= 0;
1121 refresh
= incrToFit(tPtr
);
1127 cancelSelection
= 0;
1133 case WM_EMACSKEY_BS
:
1134 if (!control_pressed
)
1141 if (tPtr
->selection
.count
) {
1142 WMDeleteTextFieldRange(tPtr
, tPtr
->selection
);
1143 data
= (void *)WMDeleteTextEvent
;
1144 textEvent
= WMTextDidChangeNotification
;
1145 } else if (tPtr
->cursorPosition
> 0) {
1146 int i
= oneUTF8CharBackward(&tPtr
->text
[tPtr
->cursorPosition
],
1147 tPtr
->cursorPosition
);
1149 range
.position
= tPtr
->cursorPosition
+ i
;
1151 WMDeleteTextFieldRange(tPtr
, range
);
1152 data
= (void *)WMDeleteTextEvent
;
1153 textEvent
= WMTextDidChangeNotification
;
1160 case WM_EMACSKEY_DEL
:
1161 if (!control_pressed
)
1171 if (tPtr
->selection
.count
) {
1172 WMDeleteTextFieldRange(tPtr
, tPtr
->selection
);
1173 data
= (void *)WMDeleteTextEvent
;
1174 textEvent
= WMTextDidChangeNotification
;
1175 } else if (tPtr
->cursorPosition
< tPtr
->textLen
) {
1177 range
.position
= tPtr
->cursorPosition
;
1178 range
.count
= oneUTF8CharForward(&tPtr
->text
[tPtr
->cursorPosition
],
1179 tPtr
->textLen
- tPtr
->cursorPosition
);
1180 WMDeleteTextFieldRange(tPtr
, range
);
1181 data
= (void *)WMDeleteTextEvent
;
1182 textEvent
= WMTextDidChangeNotification
;
1192 if (count
> 0 && !iscntrl(buffer
[0])) {
1193 if (tPtr
->selection
.count
)
1194 WMDeleteTextFieldRange(tPtr
, tPtr
->selection
);
1195 WMInsertTextFieldText(tPtr
, buffer
, tPtr
->cursorPosition
);
1196 data
= (void *)WMInsertTextEvent
;
1197 textEvent
= WMTextDidChangeNotification
;
1206 WMRelayToNextResponder(W_VIEW(tPtr
), event
);
1210 /* Do not allow text selection in secure text fields */
1211 if (cancelSelection
|| tPtr
->flags
.secure
) {
1212 lostSelection(tPtr
->view
, XA_PRIMARY
, NULL
);
1214 if (tPtr
->selection
.count
) {
1215 tPtr
->selection
.count
= 0;
1218 tPtr
->selection
.position
= tPtr
->cursorPosition
;
1220 if (tPtr
->selection
.count
!= tPtr
->cursorPosition
- tPtr
->selection
.position
) {
1222 tPtr
->selection
.count
= tPtr
->cursorPosition
- tPtr
->selection
.position
;
1228 /*printf("(%d,%d)\n", tPtr->selection.position, tPtr->selection.count); */
1231 WMNotification
*notif
= WMCreateNotification(textEvent
, tPtr
, data
);
1233 if (tPtr
->delegate
) {
1234 if (textEvent
== WMTextDidBeginEditingNotification
&& tPtr
->delegate
->didBeginEditing
)
1235 (*tPtr
->delegate
->didBeginEditing
) (tPtr
->delegate
, notif
);
1237 else if (textEvent
== WMTextDidEndEditingNotification
&& tPtr
->delegate
->didEndEditing
)
1238 (*tPtr
->delegate
->didEndEditing
) (tPtr
->delegate
, notif
);
1240 else if (textEvent
== WMTextDidChangeNotification
&& tPtr
->delegate
->didChange
)
1241 (*tPtr
->delegate
->didChange
) (tPtr
->delegate
, notif
);
1244 WMPostNotification(notif
);
1245 WMReleaseNotification(notif
);
1249 paintTextField(tPtr
);
1251 /*printf("(%d,%d)\n", tPtr->selection.position, tPtr->selection.count); */
1254 static int pointToCursorPosition(TextField
* tPtr
, int x
)
1256 int a
, b
, pos
, prev
, tw
;
1258 if (tPtr
->flags
.bordered
)
1261 if (WMWidthOfString(tPtr
->font
, &(tPtr
->text
[tPtr
->viewPosition
]),
1262 tPtr
->textLen
- tPtr
->viewPosition
) <= x
)
1263 return tPtr
->textLen
;
1265 a
= tPtr
->viewPosition
;
1268 /* we halve the text until we get into a 10 byte vicinity of x */
1269 while (b
- a
> 10) {
1271 pos
+= seekUTF8CharStart(&tPtr
->text
[pos
], pos
- a
);
1272 tw
= WMWidthOfString(tPtr
->font
, &(tPtr
->text
[tPtr
->viewPosition
]), pos
- tPtr
->viewPosition
);
1275 } else if (tw
< x
) {
1282 /* at this point x can be positioned on any glyph between 'a' and 'b-1'
1283 * inclusive, with the exception of the left border of the 'a' glyph and
1284 * the right border or the 'b-1' glyph
1286 * ( <--- range for x's position ---> )
1287 * a a+1 .......................... b-1 b
1291 tw
= WMWidthOfString(tPtr
->font
, &(tPtr
->text
[tPtr
->viewPosition
]), pos
- tPtr
->viewPosition
);
1294 } else if (pos
== b
) {
1298 pos
+= oneUTF8CharForward(&tPtr
->text
[pos
], b
- pos
);
1304 static void pasteText(WMView
* view
, Atom selection
, Atom target
, Time timestamp
, void *cdata
, WMData
* data
)
1306 TextField
*tPtr
= (TextField
*) view
->self
;
1309 tPtr
->flags
.waitingSelection
= 0;
1312 str
= (char *)WMDataBytes(data
);
1314 WMInsertTextFieldText(tPtr
, str
, tPtr
->cursorPosition
);
1315 NOTIFY(tPtr
, didChange
, WMTextDidChangeNotification
, (void *)WMInsertTextEvent
);
1319 str
= XFetchBuffer(tPtr
->view
->screen
->display
, &n
, 0);
1323 WMInsertTextFieldText(tPtr
, str
, tPtr
->cursorPosition
);
1325 NOTIFY(tPtr
, didChange
, WMTextDidChangeNotification
, (void *)WMInsertTextEvent
);
1330 static void handleTextFieldActionEvents(XEvent
* event
, void *data
)
1332 TextField
*tPtr
= (TextField
*) data
;
1333 static int move
= 0;
1334 static Time lastButtonReleasedEvent
= 0;
1335 static Time lastButtonReleasedEvent2
= 0;
1336 Display
*dpy
= event
->xany
.display
;
1338 CHECK_CLASS(data
, WC_TextField
);
1340 switch (event
->type
) {
1342 if (tPtr
->flags
.waitingSelection
) {
1345 if (tPtr
->flags
.enabled
&& tPtr
->flags
.focused
) {
1346 handleTextFieldKeyPress(tPtr
, event
);
1347 XDefineCursor(dpy
, W_VIEW(tPtr
)->window
, W_VIEW(tPtr
)->screen
->invisibleCursor
);
1348 tPtr
->flags
.pointerGrabbed
= 1;
1354 if (tPtr
->flags
.pointerGrabbed
) {
1355 tPtr
->flags
.pointerGrabbed
= 0;
1356 XDefineCursor(dpy
, W_VIEW(tPtr
)->window
, W_VIEW(tPtr
)->screen
->textCursor
);
1358 if (tPtr
->flags
.waitingSelection
) {
1362 if (tPtr
->flags
.enabled
&& (event
->xmotion
.state
& Button1Mask
)) {
1364 if (tPtr
->viewPosition
< tPtr
->textLen
&& event
->xmotion
.x
> tPtr
->usableWidth
) {
1365 if (WMWidthOfString(tPtr
->font
,
1366 &(tPtr
->text
[tPtr
->viewPosition
]),
1367 tPtr
->cursorPosition
- tPtr
->viewPosition
)
1368 > tPtr
->usableWidth
) {
1369 tPtr
->viewPosition
+= oneUTF8CharForward(&tPtr
->text
[tPtr
->viewPosition
],
1371 tPtr
->viewPosition
);
1373 } else if (tPtr
->viewPosition
> 0 && event
->xmotion
.x
< 0) {
1375 tPtr
->viewPosition
+= oneUTF8CharBackward(&tPtr
->text
[tPtr
->viewPosition
],
1376 tPtr
->viewPosition
);
1379 tPtr
->cursorPosition
= pointToCursorPosition(tPtr
, event
->xmotion
.x
);
1381 /* Do not allow text selection in secure textfields */
1382 if (tPtr
->flags
.secure
) {
1383 tPtr
->selection
.position
= tPtr
->cursorPosition
;
1386 tPtr
->selection
.count
= tPtr
->cursorPosition
- tPtr
->selection
.position
;
1389 paintTextField(tPtr
);
1395 if (tPtr
->flags
.pointerGrabbed
) {
1396 tPtr
->flags
.pointerGrabbed
= 0;
1397 XDefineCursor(dpy
, W_VIEW(tPtr
)->window
, W_VIEW(tPtr
)->screen
->textCursor
);
1401 if (tPtr
->flags
.waitingSelection
) {
1406 switch (tPtr
->flags
.alignment
) {
1409 textWidth
= WMWidthOfString(tPtr
->font
, tPtr
->text
, tPtr
->textLen
);
1410 if (tPtr
->flags
.enabled
&& !tPtr
->flags
.focused
) {
1411 WMSetFocusToWidget(tPtr
);
1413 if (tPtr
->flags
.focused
) {
1414 tPtr
->selection
.position
= tPtr
->cursorPosition
;
1415 tPtr
->selection
.count
= 0;
1417 if (textWidth
< tPtr
->usableWidth
) {
1418 tPtr
->cursorPosition
= pointToCursorPosition(tPtr
,
1419 event
->xbutton
.x
- tPtr
->usableWidth
1422 tPtr
->cursorPosition
= pointToCursorPosition(tPtr
, event
->xbutton
.x
);
1424 paintTextField(tPtr
);
1428 if (tPtr
->flags
.enabled
&& !tPtr
->flags
.focused
) {
1429 WMSetFocusToWidget(tPtr
);
1431 if (tPtr
->flags
.focused
&& event
->xbutton
.button
== Button1
) {
1432 tPtr
->cursorPosition
= pointToCursorPosition(tPtr
, event
->xbutton
.x
);
1433 tPtr
->selection
.position
= tPtr
->cursorPosition
;
1434 tPtr
->selection
.count
= 0;
1435 paintTextField(tPtr
);
1437 if (event
->xbutton
.button
== Button2
&& tPtr
->flags
.enabled
) {
1441 if (!WMRequestSelection(tPtr
->view
, XA_PRIMARY
, XA_STRING
,
1442 event
->xbutton
.time
, pasteText
, NULL
)) {
1443 text
= XFetchBuffer(tPtr
->view
->screen
->display
, &n
, 0);
1447 WMInsertTextFieldText(tPtr
, text
, tPtr
->cursorPosition
);
1449 NOTIFY(tPtr
, didChange
, WMTextDidChangeNotification
,
1450 (void *)WMInsertTextEvent
);
1453 tPtr
->flags
.waitingSelection
= 1;
1463 if (tPtr
->flags
.pointerGrabbed
) {
1464 tPtr
->flags
.pointerGrabbed
= 0;
1465 XDefineCursor(dpy
, W_VIEW(tPtr
)->window
, W_VIEW(tPtr
)->screen
->textCursor
);
1467 if (tPtr
->flags
.waitingSelection
) {
1471 if (!tPtr
->flags
.secure
&& tPtr
->selection
.count
!= 0) {
1473 XRotateBuffers(dpy
, 1);
1475 count
= abs(tPtr
->selection
.count
);
1476 if (tPtr
->selection
.count
< 0)
1477 start
= tPtr
->selection
.position
- count
;
1479 start
= tPtr
->selection
.position
;
1481 XStoreBuffer(dpy
, &tPtr
->text
[start
], count
, 0);
1486 if (!tPtr
->flags
.secure
&&
1487 event
->xbutton
.time
- lastButtonReleasedEvent
<= WINGsConfiguration
.doubleClickDelay
) {
1489 if (event
->xbutton
.time
- lastButtonReleasedEvent2
<=
1490 2 * WINGsConfiguration
.doubleClickDelay
) {
1491 tPtr
->selection
.position
= 0;
1492 tPtr
->selection
.count
= tPtr
->textLen
;
1496 pos
= tPtr
->selection
.position
;
1497 cnt
= tPtr
->selection
.count
;
1500 if (txt
[pos
] == ' ' || txt
[pos
] == '\t')
1506 while (pos
+ cnt
< tPtr
->textLen
) {
1507 if (txt
[pos
+ cnt
] == ' ' || txt
[pos
+ cnt
] == '\t')
1511 tPtr
->selection
.position
= pos
;
1512 tPtr
->selection
.count
= cnt
;
1514 paintTextField(tPtr
);
1516 if (!tPtr
->flags
.ownsSelection
) {
1517 tPtr
->flags
.ownsSelection
=
1518 WMCreateSelectionHandler(tPtr
->view
,
1520 event
->xbutton
.time
, &selectionHandler
, NULL
);
1522 } else if (!tPtr
->flags
.secure
&& tPtr
->selection
.count
!= 0 && !tPtr
->flags
.ownsSelection
) {
1523 tPtr
->flags
.ownsSelection
=
1524 WMCreateSelectionHandler(tPtr
->view
,
1525 XA_PRIMARY
, event
->xbutton
.time
, &selectionHandler
, NULL
);
1528 lastButtonReleasedEvent2
= lastButtonReleasedEvent
;
1529 lastButtonReleasedEvent
= event
->xbutton
.time
;
1535 static void destroyTextField(TextField
* tPtr
)
1539 WMDeleteTimerHandler(tPtr
->timerID
);
1542 W_DestroyIC(tPtr
->view
);
1544 WMReleaseFont(tPtr
->font
);
1545 /*// use lostSelection() instead of WMDeleteSelectionHandler here? */
1546 WMDeleteSelectionHandler(tPtr
->view
, XA_PRIMARY
, CurrentTime
);
1547 WMRemoveNotificationObserver(tPtr
);