?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
some fixes to accented characters
[tangerine.git] / rom / intuition / strgadgets.c
blob129666e66815a7e947737ef7d660524329f075c7
1 /*
2 Copyright © 1995-2003, The AROS Development Team. All rights reserved.
3 Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
4 $Id$
5 */
6
7 #include <proto/exec.h>
8 #include <proto/intuition.h>
9 #include <proto/graphics.h>
10 #include <proto/utility.h>
11 #include <proto/keymap.h>
12 #include <intuition/screens.h>
13 #include <intuition/cghooks.h>
14 #include <graphics/gfxmacros.h>
15 #include <devices/inputevent.h>
16 #include <aros/asmcall.h>
17 #include <stdlib.h> /* atol() */
18 #include <stdio.h> /* snprintf() */
19 #include <string.h>
20
21 #include "intuition_intern.h"
22 #include "strgadgets.h"
23
24 #ifdef __MORPHOS__
25 size_t stccpy(char *s1, const char *s2, size_t n);
26 #endif
27
28 #undef DEBUG
29 #define SDEBUG 0
30 #define DEBUG 0
31 #include <aros/debug.h>
32
33 /*****************************************************************************************/
34
35 #define CURSORPEN 0
36 #define STRBACKPEN 1
37 #define STRTEXTPEN 2
38
39 #define NUMPENS 3
40 #define STRALIGNMASK (GACT_STRINGLEFT|GACT_STRINGCENTER|GACT_STRINGRIGHT)
41
42 #define KEYBUFSIZE 10
43 #define SHIFT (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)
44
45 #define HELPRAW 95 /* Raw */
46 #define CTRL_A 1
47 #define CTRL_B 2
48 #define CTRL_C 3
49 #define CTRL_D 4
50 #define CTRL_E 5
51 #define CTRL_F 6
52 #define CTRL_G 7
53 #define CTRL_H 8
54 #define CTRL_I 9
55 #define CTRL_J 10
56 #define CTRL_K 11
57 #define CTRL_L 12
58 #define CTRL_M 13
59 #define CTRL_N 14
60 #define CTRL_O 15
61 #define CTRL_P 16
62 #define CTRL_Q 17
63 #define CTRL_R 18
64 #define CTRL_S 19
65 #define CTRL_T 20
66 #define CTRL_U 21
67 #define CTRL_V 22
68 #define CTRL_W 23
69 #define CTRL_X 24
70 #define CTRL_Y 25
71 #define CTRL_Z 26
72
73 #define BACKSPACE 8 /* Vanilla */
74 #define TAB 9 /* Vanilla */
75 #define TABRAW 66 /* Raw */
76 #define RETURN 13 /* Vanilla */
77 #define DELETE 127 /* Vanilla */
78 #define HOMERAW 112 /* Raw */
79 #define ENDRAW 113 /* Raw */
80
81 /*****************************************************************************************/
82
83 VOID UpdateStringInfo(struct Gadget *);
84
85 /*****************************************************************************************/
86
87 #define CharXSize(char, rp) ((rp->Font->tf_Flags & FPF_PROPORTIONAL) ? \
88 rp->Font->tf_XSize : TextLength(rp, &(char), 1))
89
90
91 #undef MIN
92 #define MIN(a, b) ((a < b) ? a : b)
93
94 /*****************************************************************************************/
95
96 char cursorkey[] = "_";
97 #define CURSORKEYLEN 1
98
99 /*****************************************************************************************/
100
101 STATIC WORD MaxDispPos(struct StringInfo *strinfo, struct BBox *bbox,
102 struct RastPort *rp, struct IntuitionBase *IntuitionBase)
103 {
104
105 WORD numfit, max_disppos, numchars;
106 struct TextExtent te;
107 BOOL cursor_at_end;
108
109 cursor_at_end = (strinfo->BufferPos == strinfo->NumChars);
110
111 EnterFunc(bug("MaxDispPos(current length: %d, bufferpos=%d)\n", strinfo->NumChars, strinfo->BufferPos));
112
113 D(bug("cursor_at_end: %d\n", cursor_at_end));
114
115 if (cursor_at_end) /* Cursor at end of string ? */
116 {
117 D(bug("Making cursor last char\n"));
118 numchars = strinfo->NumChars + 1; /* Take cursor into account */
119
120 /* This has allready been done by UpdateDisp() which called us
121 strinfo->Buffer[strinfo->NumChars] = 0x20;
122
123 */
124 }
125 else
126 {
127
128 numchars = strinfo->NumChars;
129 }
130
131
132 /* Find the amount of characters that fit into the bbox, counting
133 ** from the last character in the buffer and forward,
134 */
135 numfit = TextFit(rp,
136 &(strinfo->Buffer[numchars - 1]),
137 numchars, &te, NULL,
138 -1, bbox->Width, rp->Font->tf_YSize);
139
140
141 max_disppos = numchars - numfit;
142
143 /* if ((max_disppos > 0) && (!cursor_at_end))
144 max_disppos --;
145 */
146
147 D(bug("Numchars w/cursor: %d, Numfit: %d, maxdisppos=%d bbox->Width = %d te->te_Width = %d\n",
148 numchars, numfit, max_disppos, bbox->Width, te.te_Width));
149
150 ReturnInt("MaxDispPos", WORD, max_disppos);
151 }
152
153 /*****************************************************************************************/
154
155 void UpdateDisp(struct Gadget *gad,
156 struct BBox *bbox,
157 struct RastPort *rp,
158 struct IntuitionBase *IntuitionBase)
159 {
160
161
162 struct TextExtent te;
163 struct StringInfo *strinfo = (struct StringInfo *)gad->SpecialInfo;
164 STRPTR dispstr;
165
166 EnterFunc(bug("UpdateDisp(gad=%p, bbox=%p, rp=%p)\n",
167 gad, bbox, rp));
168
169 /* If the cursor is at the trailing \0, insert a SPACE instead */
170 if (strinfo->BufferPos == strinfo->NumChars)
171 strinfo->Buffer[strinfo->NumChars] = 0x20;
172
173 /* In this function we check if the cursor has gone outside
174 ** of the visible area (because of application setting
175 ** strinfo->BufferPos or strinfo->DispPos to a different value, or
176 ** because of user input).
177 ** This is made a bit difficult by the rule (R), that there
178 ** should NOT be available space on the right, and characters
179 ** scrolled out at the left, at the same time.
180 ** We have 3 possible scenarios:
181 ** 1) Cursor to the left of DispPos:
182 ** Set DispPos to the lowest of BufferPos and the
183 ** maximum allowed disppos (according to (R) ).
184 ** 2) Cursor to the right of visible area:
185 ** Set dispose sou that the cursor is the last visible character.
186 ** This afheres to (R).
187 ** 3) Cursor inside visible area. Do a check on rule (R),
188 ** and if DispPos > max allowed, then adjust it down,
189 ** so that the last character in the buffer becomes last character
190 ** displayed. (The cursor will still be visible after adjustion)
191 */
192
193
194 /* 1) Cursor to the left of visible area */
195 if (strinfo->BufferPos < strinfo->DispPos)
196 {
197 WORD max_disppos;
198
199 max_disppos = MaxDispPos(strinfo, bbox, rp, IntuitionBase);
200 strinfo->DispPos = MIN(strinfo->BufferPos, max_disppos);
201 }
202 else /* Cursor equal to the right of disppos [ 2) or 3) ] */
203 {
204 UWORD strsize;
205
206 /* How many pixels are there from current 1st displayed to the cursor ? */
207 strsize = TextLength(rp,
208 strinfo->Buffer + strinfo->DispPos,
209 strinfo->BufferPos - strinfo->DispPos + 1);
210
211 /* 2) More than fits into the gadget ? */
212 if (strsize > bbox->Width)
213 {
214 /* Compute new DispPos such that the cursor is at the right */
215 strinfo->DispPos = strinfo->BufferPos
216 - TextFit(rp,
217 &(strinfo->Buffer[strinfo->BufferPos]),
218 strinfo->NumChars, &te, NULL, -1,
219 bbox->Width, rp->Font->tf_YSize)
220 + 1;
221
222 D(bug("cursor right of visible area, new disppos: %d\n", strinfo->DispPos));
223 }
224 else /* 3). Cursor inside gadget */
225 {
226 WORD max_disppos;
227
228 max_disppos = MaxDispPos(strinfo, bbox, rp, IntuitionBase);
229 if (strinfo->DispPos > max_disppos)
230 strinfo->DispPos = max_disppos;
231
232 } /* if (cursor inside or to the right of visible area )*/
233
234 }
235
236 /* Update the DispCount */
237 /* It might be necessary with special handling for centre aligned gads */
238 dispstr = &(strinfo->Buffer[strinfo->DispPos]);
239 strinfo->DispCount = TextFit(rp, dispstr,
240 strinfo->NumChars - strinfo->DispPos,
241 &te, NULL, 1,
242 bbox->Width,
243 rp->Font->tf_YSize);
244
245 /* 0-terminate string */
246 strinfo->Buffer[strinfo->NumChars] = 0x00;
247 ReturnVoid("UpdateDisp");
248 }
249
250 /*****************************************************************************************/
251
252 STATIC UWORD GetTextLeft(struct Gadget *gad,
253 struct BBox *bbox,
254 struct RastPort *rp,
255 struct IntuitionBase *IntuitionBase)
256 {
257 /* Gets left position of text in the string gadget */
258
259 struct StringInfo *strinfo = (struct StringInfo *)gad->SpecialInfo;
260 UWORD text_left = 0;
261 STRPTR dispstr = &(strinfo->Buffer[strinfo->DispPos]);
262 UWORD dispstrlen;
263 BOOL cursor_at_end;
264
265 cursor_at_end = (strinfo->BufferPos == strinfo->NumChars);
266
267 dispstrlen = strinfo->NumChars - strinfo->DispPos;
268
269 /* Calcluate start offset of gadget text */
270 switch (gad->Activation & STRALIGNMASK)
271 {
272 case GACT_STRINGLEFT:
273 #warning FIXME: is this default: correct?
274 default:
275 text_left = bbox->Left;
276 break;
277
278 case GACT_STRINGCENTER:
279 {
280 WORD textwidth = TextLength(rp, dispstr, dispstrlen);
281
282 if (cursor_at_end) textwidth += TextLength(rp, cursorkey, CURSORKEYLEN);
283 text_left = bbox->Left + ((bbox->Width - textwidth) / 2);
284 }
285 break;
286
287 case GACT_STRINGRIGHT:
288 {
289 WORD textwidth = TextLength(rp, dispstr, dispstrlen);
290
291 if (cursor_at_end) textwidth += TextLength(rp, cursorkey, CURSORKEYLEN);
292 text_left = bbox->Left + (bbox->Width - 1 - textwidth);
293 }
294 break;
295 }
296 return (text_left);
297 }
298
299 /*****************************************************************************************/
300
301 STATIC UWORD GetTextRight(struct Gadget *gad,
302 struct BBox *bbox,
303 struct RastPort *rp,
304 struct IntuitionBase *IntuitionBase)
305 {
306 /* Gets right offset of text in the string gadget */
307
308 struct StringInfo *strinfo = (struct StringInfo *)gad->SpecialInfo;
309 UWORD text_right = 0;
310 STRPTR dispstr = &(strinfo->Buffer[strinfo->DispPos]);
311 UWORD dispstrlen;
312 BOOL cursor_at_end;
313
314 cursor_at_end = (strinfo->BufferPos == strinfo->NumChars);
315
316 dispstrlen = strinfo->NumChars - strinfo->DispPos;
317
318 /* Calcluate start offset of gadget text */
319 switch (gad->Activation & STRALIGNMASK)
320 {
321 case GACT_STRINGLEFT:
322 #warning FIXME: is this default: correct?
323 default:
324 text_right = bbox->Left + TextLength(rp, dispstr, dispstrlen);
325 break;
326
327 case GACT_STRINGCENTER:
328 {
329 WORD textwidth = TextLength(rp, dispstr, dispstrlen);
330
331 if (cursor_at_end) textwidth += TextLength(rp, cursorkey, CURSORKEYLEN);
332 text_right = bbox->Left + bbox->Width - 1 - ((bbox->Width - textwidth) / 2);
333 }
334 break;
335
336 case GACT_STRINGRIGHT:
337 text_right = bbox->Left + bbox->Width - 1;
338 break;
339 }
340 return (text_right);
341 }
342
343 /*****************************************************************************************/
344
345 STATIC VOID GetPensAndFont(struct Gadget *gad,
346 UWORD *pens,
347 struct Window *win,
348 struct RastPort *rp,
349 struct IntuitionBase *IntuitionBase)
350 {
351
352 struct DrawInfo *dri = GetScreenDrawInfo(win->WScreen);
353 BOOL docursor = FALSE;
354
355 SetFont(rp, dri->dri_Font);
356
357 if (gad->Flags & GFLG_STRINGEXTEND)
358 {
359 struct StringExtend *strext;
360
361 strext = ((struct StringInfo *)gad->SpecialInfo)->Extension;
362
363 if (strext->Font)
364 {
365 SetFont(rp, strext->Font);
366 }
367
368 if ((gad->Flags & GFLG_SELECTED) == GFLG_SELECTED)
369 {
370 pens[STRTEXTPEN] = strext->ActivePens[0];
371 pens[STRBACKPEN] = strext->ActivePens[1];
372 }
373 else
374 {
375 pens[STRTEXTPEN] = strext->Pens[0];
376 pens[STRBACKPEN] = strext->Pens[1];
377 }
378
379 }
380 else
381 {
382 /* We don't care to lock the screen because the window we're
383 ** drawn on does this. If the window is moved to another
384 ** public screen we will be called again to rerender (and get new
385 ** valid pens). If the window is closed, and the screen is closed
386 ** we won't be here anymore.
387 */
388
389 /* jDc: set the font to Topaz,8! */
390 if (GetPrivIBase(IntuitionBase)->TopazFont)
391 {
392 SetFont(rp,GetPrivIBase(IntuitionBase)->TopazFont);
393 } else {
394 SetFont(rp,GfxBase->DefaultFont);
395 }
396
397 #if 0
398 if ((gad->Flags & GFLG_SELECTED) == GFLG_SELECTED)
399 {
400 pens[STRTEXTPEN] = dri->dri_Pens[TEXTPEN];
401 pens[STRBACKPEN] = dri->dri_Pens[BACKGROUNDPEN];
402
403 }
404 else
405 {
406 #endif
407 pens[STRTEXTPEN] = dri->dri_Pens[TEXTPEN];
408 pens[STRBACKPEN] = dri->dri_Pens[BACKGROUNDPEN];
409 #if 0
410 }
411 #endif
412
413 }
414 pens[CURSORPEN] = dri->dri_Pens[FILLPEN];
415
416 /* do some protection against stupid apps so we don't get into white text on white background pb */
417 if (pens[STRTEXTPEN] == pens[STRBACKPEN])
418 {
419 if (pens[STRTEXTPEN] != 0)
420 {
421 pens[STRBACKPEN] = 0;
422 if (pens[STRTEXTPEN] != 3) docursor = TRUE;
423 }
424 else
425 {
426 pens[STRTEXTPEN] = 1;
427 pens[STRBACKPEN] = 0;
428 docursor = TRUE;
429 }
430 }
431
432 if ((pens[CURSORPEN] == pens[STRTEXTPEN]) || (pens[CURSORPEN] == pens[STRBACKPEN]))
433 {
434 pens[CURSORPEN] = (docursor ? 3 : ((pens[STRTEXTPEN] == 2) ? 2 : 1));
435 }
436
437 FreeScreenDrawInfo(win->WScreen, dri);
438
439 return;
440 }
441
442 /*****************************************************************************************/
443
444 ULONG HandleStrInput( struct Gadget *gad,
445 struct GadgetInfo *ginfo,
446 struct InputEvent *ievent,
447 UWORD *imsgcode,
448 struct IntuitionBase *IntuitionBase)
449 {
450 struct SGWork sgw;
451 struct StringInfo *strinfo = (struct StringInfo *)gad->SpecialInfo;
452 struct StringExtend *strext = NULL;
453 ULONG command = 0;
454
455 EnterFunc(bug("HandleStrInput(gad=%p, ginfo=%p, ievent=%p)\n",
456 gad, ginfo, ievent));
457
458 if ((ievent->ie_Class == IECLASS_TIMER)) return 0;
459
460 D(bug("Gadget text: %s\n", strinfo->Buffer));
461
462 if (!ginfo)
463 ReturnInt("HandleStrInput", ULONG, 0UL);
464
465 UpdateStringInfo(gad);
466
467 /* Initialize SGWork */
468 sgw.Gadget = gad;
469 sgw.StringInfo = strinfo;
470 sgw.WorkBuffer = strinfo->Buffer; /* default */
471 sgw.PrevBuffer = strinfo->Buffer;
472 sgw.Modes = 0;
473 sgw.IEvent = ievent;
474 sgw.Code = 0;
475 sgw.BufferPos = strinfo->BufferPos;
476 sgw.NumChars = strinfo->NumChars;
477 sgw.Actions = 0;
478 sgw.LongInt = strinfo->LongInt;
479 sgw.GadgetInfo = ginfo;
480 sgw.EditOp = EO_NOOP;
481
482 if (gad->Flags & GFLG_STRINGEXTEND)
483 {
484 D(bug("HandleStrInput: Extended gadget\n"));
485 strext = strinfo->Extension;
486 if (strext->WorkBuffer)
487 {
488 sgw.WorkBuffer = strext->WorkBuffer;
489 /* The edit hook gets *copy* of the current buffer contents */
490 strcpy(sgw.WorkBuffer, strinfo->Buffer);
491 }
492 sgw.Modes = strext->InitialModes;
493 }
494
495 switch (ievent->ie_Class)
496 {
497 case IECLASS_RAWMOUSE:
498 if (ievent->ie_Code == SELECTDOWN)
499 {
500 command = SGH_CLICK;
501 sgw.Actions = SGA_USE | SGA_REDISPLAY;
502 D(bug("HandleStrInput: RAWMOUSE event\n"));
503 }
504 break;
505
506 case IECLASS_RAWKEY:
507 {
508 UBYTE buf;
509
510 D(bug("HandleStrInput: RAWKEY event\n"));
511 if (ievent->ie_Code & IECODE_UP_PREFIX)
512 {
513 D(bug("HandleStrInput: filter UP event\n"));
514 }
515 else
516 {
517 command = SGH_KEY;
518 sgw.Actions = SGA_USE;
519 if (1 == MapRawKey(sgw.IEvent, &buf, 1, strinfo->AltKeyMap))
520 {
521 D(bug("HandleStrInput: sgw.Code 0x%lx\n",buf));
522 sgw.Code = (UWORD)buf;
523 }
524 }
525 break;
526 }
527
528 }
529
530 if (!command)
531 ReturnInt("HandleStrInput", ULONG , 0UL);
532
533 /* Call the global editing hook */
534
535 D(bug("calling global hook, Buffer=%s, WorkBuffer=%s\n",
536 strinfo->Buffer, sgw.WorkBuffer));
537 CallHookPkt(GetPrivIBase(IntuitionBase)->GlobalEditHook, &sgw, &command);
538
539 /* If there is a local edit hook, run it */
540 if (strext)
541 {
542 if (strext->EditHook)
543 {
544 D(bug("calling local edit hook\n"));
545 CallHookPkt(strext->EditHook, &sgw, &command);
546 }
547 }
548
549 /* Copy possibly changed stuff into stringgad */
550 if (sgw.Actions & SGA_USE)
551 {
552 if (strext)
553 {
554 if (strext->WorkBuffer)
555 strcpy(strinfo->Buffer, strext->WorkBuffer);
556 }
557
558 strinfo->BufferPos = sgw.BufferPos;
559 strinfo->NumChars = sgw.NumChars;
560 strinfo->LongInt = sgw.LongInt;
561
562 #if 0
563 if (gad->Activation & GACT_LONGINT)
564 {
565 kprintf("strinfo->LongInt = %d\n",strinfo->LongInt);
566 */
567 }
568 else
569 {
570 kprintf("strinfo->Buffer = \"%s\"\n",strinfo->Buffer);
571 */
572 }
573 #endif
574 }
575
576 if (sgw.Actions & SGA_BEEP)
577 {
578 D(bug("SGA_BEEP not yet implemented. (lack of DisplayBeep())\n"));
579 }
580
581 if (sgw.Actions & (SGA_END | SGA_NEXTACTIVE | SGA_PREVACTIVE))
582 {
583 gad->Flags &= ~GFLG_SELECTED;
584 *imsgcode = sgw.Code;
585 D(bug("HandleStrInput: SGA_END\n"));
586 }
587
588 if (sgw.Actions & SGA_REDISPLAY)
589 {
590 D(bug("HandleStrInput: SGA_REDISPLAY\n"));
591 /* Hack for making strgclass work */
592 if ((gad->GadgetType & GTYP_GTYPEMASK) == GTYP_CUSTOMGADGET)
593 {
594 struct RastPort *rp;
595 D(bug("HandleStrInput: Rerendering boopsi gadget\n"));
596
597 if ((rp = ObtainGIRPort(ginfo)) != NULL)
598 {
599 struct gpRender method;
600
601 method.MethodID = GM_RENDER;
602 method.gpr_GInfo = ginfo;
603 method.gpr_RPort = rp;
604 method.gpr_Redraw = GREDRAW_UPDATE;
605
606 Custom_DoMethodA(gad, (Msg)&method);
607
608 ReleaseGIRPort(rp);
609 }
610 } /* if gadget is a strgclass object */
611 else
612 {
613 D(bug("HandleStrInput: Rerendering intuition gadget\n"));
614 RefreshStrGadget(gad, ginfo->gi_Window, ginfo->gi_Requester, IntuitionBase);
615 }
616 }
617
618 ReturnInt("HandleStrInput", ULONG, sgw.Actions);
619 }
620
621 /*****************************************************************************************/
622
623 STATIC ULONG DoSGHClick(struct SGWork *sgw, struct IntuitionBase *IntuitionBase)
624 {
625
626 struct Gadget *gad;
627 struct StringInfo *strinfo;
628 struct BBox bbox;
629
630 struct TextFont *oldfont;
631 struct RastPort *rp;
632 struct Window *window;
633 struct Requester *req;
634
635 UWORD text_left, text_right;
636 WORD mousex;
637
638 window = sgw->GadgetInfo->gi_Window;
639 req = sgw->GadgetInfo->gi_Requester;
640
641 GetGadgetDomain(sgw->Gadget, window->WScreen, window, NULL, (struct IBox *)&bbox);
642 mousex = window->MouseX - bbox.Left;
643
644 EnterFunc(bug("DoSGHClick(sgw=%p)\n", sgw));
645
646 D(bug("Gadget text: %s\n", sgw->WorkBuffer));
647
648 rp = sgw->GadgetInfo->gi_RastPort;
649 oldfont = rp->Font;
650 gad = sgw->Gadget;
651 strinfo = (struct StringInfo *)gad->SpecialInfo;
652
653 CalcBBox(window, req, gad, &bbox);
654
655 {
656 struct DrawInfo *dri;
657
658 dri = GetScreenDrawInfo(window->WScreen);
659 SetFont(rp, dri->dri_Font);
660 FreeScreenDrawInfo(window->WScreen, dri);
661 }
662
663 if (gad->Flags & GFLG_STRINGEXTEND)
664 {
665 struct StringExtend *strext = strinfo->Extension;
666
667 if (strext->Font)
668 {
669 SetFont(rp, strext->Font);
670 }
671 }
672
673 /* If we are made active, save contents to undobuffer (if any exists) */
674 if (!(gad->Flags & GFLG_SELECTED))
675 {
676
677 if (strinfo->UndoBuffer)
678 {
679 D(bug("sghclick: saving into undo buffer\n"));
680 strcpy(strinfo->UndoBuffer, strinfo->Buffer);
681 }
682 gad->Flags |= GFLG_SELECTED;
683 }
684
685 /* Get left & righ offsets of strgad text */
686 text_left = GetTextLeft (gad, &bbox, rp, IntuitionBase);
687 text_right = GetTextRight(gad, &bbox, rp, IntuitionBase);
688
689 D(bug("sghclick: text_left=%d, text_right=%d\n", text_left, text_right));
690 D(bug("sghclick: disppos=%d, dispcount=%d, cursor=%d\n",
691 strinfo->DispPos, strinfo->DispCount, sgw->BufferPos));
692 D(bug("Gadget text: %s\n", sgw->WorkBuffer));
693
694 /* Check if mouseclick is inside displayed text */
695 if ((mousex >= text_left) && (mousex <= text_right))
696 {
697 /* Find new cursor pos. Uses TextFit() to handle proportional fonts. */
698
699 struct TextExtent te;
700 STRPTR dispstr = strinfo->Buffer + strinfo->DispPos;
701
702 sgw->BufferPos = strinfo->DispPos
703 + TextFit(rp, dispstr, sgw->NumChars - strinfo->DispPos,
704 &te, NULL, 1,
705 mousex - text_left, rp->Font->tf_YSize);
706 D(bug("sghclick: click inside text.\n"));
707 }
708 else /* Click not inside text */
709 {
710 if (mousex < text_left)
711 {
712 /* Click on empty space at left. Set cursor to first visible */
713 sgw->BufferPos = strinfo->DispPos;
714 D(bug("sghclick: click left of text.\n"));
715 }
716 else
717 {
718 /* Click on empty space at right. Set cursor to last visible */
719 sgw->BufferPos = strinfo->DispPos + strinfo->DispCount;
720 D(bug("sghclick: click right of text.\n"));
721 }
722
723 } /* if (click is on text or not) */
724
725 D(bug("sghclick: new cursor position: %d\n", sgw->BufferPos));
726
727 sgw->Actions = (SGA_USE|SGA_REDISPLAY);
728 sgw->EditOp = EO_MOVECURSOR;
729
730 SetFont(rp, oldfont);
731
732 D(bug("Gadget text: %s\n", sgw->WorkBuffer));
733
734 ReturnInt ("DoSGHClick", ULONG, 1);
735 }
736
737 /*****************************************************************************************/
738
739 VOID MoveCharsLeft(STRPTR str, UWORD first, UWORD last, UWORD steps)
740 {
741 register UWORD i;
742
743 for (i = first; i <= last; i ++)
744 {
745 str[i - steps] = str[i];
746 }
747 str[last] = 0;
748 }
749
750 /*****************************************************************************************/
751
752 STATIC ULONG DoSGHKey(struct SGWork *sgw, struct IntuitionBase *IntuitionBase)
753 {
754
755 struct Gadget *gad;
756 struct StringInfo *strinfo;
757 UBYTE letter;
758 ULONG qual;
759
760 EnterFunc(bug("DoSGHKey(sgw=%p)\n", sgw));
761
762 gad = sgw->Gadget;
763 strinfo = sgw->StringInfo;
764
765 qual = sgw->IEvent->ie_Qualifier;
766
767 D(bug("sghkey: RawKey 0x%lx, sgw_Code 0x%lx\n",sgw->IEvent->ie_Code,sgw->Code));
768
769 sgw->EditOp = EO_NOOP;
770
771 D(bug("sghkey: qual 0x%lx ic_Flags 0x%lx Modes 0x%lx\n",
772 qual,
773 GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags,
774 sgw->Modes));
775
776 if (sgw->Code == 0)
777 {
778 /* RAW Keys */
779
780 letter = sgw->IEvent->ie_Code;
781
782 if ((letter == CURSORLEFT) && (!(qual & SHIFT)))
783 {
784 D(bug("sghkey: CURSOR_LEFT\n"));
785 if (sgw->BufferPos > 0)
786 {
787 sgw->EditOp = EO_MOVECURSOR;
788 sgw->BufferPos --;
789 }
790 }
791 else if ((letter == CURSORRIGHT) && (!(qual & SHIFT)))
792 {
793
794 D(bug("sghkey: CURSOR_RIGHT\n"));
795 if (sgw->BufferPos < sgw->NumChars)
796 {
797 sgw->EditOp = EO_MOVECURSOR;
798 sgw->BufferPos ++;
799
800 }
801 }
802 else if ( ((letter == CURSORLEFT) && (qual & SHIFT)) ||
803 (letter == HOMERAW) )
804 {
805 if (sgw->BufferPos > 0)
806 {
807 sgw->BufferPos = 0;
808 sgw->EditOp = EO_MOVECURSOR;
809 }
810 }
811 else if ( ((letter == CURSORRIGHT) && (qual & SHIFT)) ||
812 (letter == ENDRAW) )
813 {
814 if (sgw->BufferPos < sgw->NumChars)
815 {
816 sgw->BufferPos = sgw->NumChars;
817 sgw->EditOp = EO_MOVECURSOR;
818 }
819 }
820 else if ((letter == TABRAW) && (qual & SHIFT))
821 {
822 D(bug("sghkey: SHIFT TAB\n"));
823 sgw->EditOp = EO_SPECIAL; /* FIXME: ??? is this correct ??? */
824 sgw->Code = 9;
825 sgw->Actions = (SGA_USE|SGA_PREVACTIVE);
826 }
827 else if (letter == HELPRAW)
828 {}
829
830 }
831 else if (qual & IEQUALIFIER_RCOMMAND)
832 {
833 /* ANSI key but pressed together with right Amiga key */
834 #if 0
835 sgw->EditOp = EO_SPECIAL; /* FIXME: ??? is this correct ??? */
836 sgw->Actions = (SGA_USE|SGA_REUSE|SGA_END);
837 #endif
838 letter = ToUpper(sgw->Code);
839
840 /* stegerg: URGENTCHECMKE. Why disabled for AROS? */
841 #ifndef __MORPHOS__
842 #warning we need to handle RAMIGA-Q,RAMIGA-X here
843 #else
844 if(letter == 'Q')
845 {
846 sgw->EditOp = EO_RESET;
847
848 if (strinfo->UndoBuffer)
849 {
850 D(bug("sghclick: saving into undo buffer\n"));
851 stccpy(strinfo->UndoBuffer, sgw->WorkBuffer,strinfo->MaxChars);
852 sgw->BufferPos = strinfo->UndoPos;
853 sgw->NumChars = strlen(sgw->WorkBuffer);
854 }
855 }
856 else
857 if(letter == 'X')
858 {
859 /* RCmd-X clears the input buffer. In fixed field mode
860 * jump cursor to the start of the buffer
861 */
862 D(bug("sghkey: CTRL-X\n"));
863
864 if (sgw->Modes & SGM_FIXEDFIELD)
865 {
866 D(bug("sghkey: SGM_FIXEDFIELD\n"));
867 sgw->BufferPos = 0;
868 sgw->EditOp = EO_MOVECURSOR;
869 }
870 else
871 {
872 sgw->BufferPos = 0;
873 sgw->WorkBuffer[sgw->BufferPos] = '\0';
874 sgw->NumChars = sgw->BufferPos;
875 sgw->EditOp = EO_CLEAR;
876 }
877 }
878 #endif
879 }
880 else
881 {
882 /* ANSI key */
883
884 letter = sgw->Code;
885
886 if ((qual & IEQUALIFIER_CONTROL) &&
887 (GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_STRGAD_FILTER) &&
888 !(sgw->Modes & SGM_NOFILTER))
889 {
890 /* ANSI key but pressed together with the control key */
891
892 D(bug("sghkey: CTRL pressed..filtering on\n"));
893
894 if (letter == CTRL_A)
895 {
896 /* CTRL-A jump cursor to start of buffer */
897 D(bug("sghkey: CTRL-A\n"));
898 sgw->BufferPos = 0;
899 sgw->EditOp = EO_MOVECURSOR;
900 }
901 else
902 if (letter == CTRL_B)
903 {
904 /* CTRL-B move the cursor back one char */
905 D(bug("sghkey: CTRL-B\n"));
906 if (sgw->BufferPos > 0)
907 {
908 sgw->BufferPos--;
909 sgw->EditOp = EO_MOVECURSOR;
910 }
911 }
912 else
913 if (letter == CTRL_D)
914 {
915 /* CTRL-D delete current char */
916 D(bug("sghkey: CTRL-D\n"));
917 if (sgw->BufferPos != sgw->NumChars)
918 {
919 MoveCharsLeft(sgw->WorkBuffer, sgw->BufferPos + 1, sgw->NumChars - 1, 1);
920 sgw->NumChars --;
921 sgw->EditOp = EO_DELFORWARD;
922 }
923 }
924 else
925 if (letter == CTRL_E)
926 {
927 /* CTRL-E move the cursor to the end of the line */
928 D(bug("sghkey: CTRL-E\n"));
929 if (sgw->BufferPos != sgw->NumChars)
930 {
931 sgw->BufferPos = sgw->NumChars;
932 sgw->EditOp = EO_MOVECURSOR;
933 }
934 }
935 else
936 if (letter == CTRL_F)
937 {
938 /* CTRL-F move the cursor forward one char */
939 D(bug("sghkey: CTRL-F\n"));
940 if (sgw->BufferPos != sgw->NumChars)
941 {
942 sgw->BufferPos++;
943 sgw->EditOp = EO_MOVECURSOR;
944 }
945 }
946 else
947 if (letter == CTRL_H)
948 {
949 /* CTRL-H Delete the character to the left of the cursor
950 * In fixed field mode, move cursor to previous character
951 */
952 D(bug("sghkey: CTRL-A\n"));
953 if (sgw->Modes & SGM_FIXEDFIELD)
954 {
955 D(bug("sghkey: SGM_FIXEDFIELD\n"));
956 if (sgw->BufferPos > 0)
957 {
958 sgw->BufferPos--;
959 sgw->EditOp = EO_MOVECURSOR;
960 }
961 }
962 else
963 {
964 if (sgw->BufferPos > 0)
965 {
966 int len;
967 len = sgw->NumChars - sgw->BufferPos;
968 memcpy(&sgw->WorkBuffer[sgw->BufferPos-1],&sgw->WorkBuffer[sgw->BufferPos],len);
969
970 sgw->BufferPos--;
971 sgw->WorkBuffer[sgw->BufferPos + len] = 0;
972 sgw->NumChars--;
973 sgw->EditOp = EO_DELBACKWARD;
974 }
975 }
976 }
977 else
978 if (letter == CTRL_K)
979 {
980 /* CTRL-K Delete from the character under the cursor to the end
981 * of the string
982 */
983 D(bug("sghkey: CTRL-K\n"));
984 sgw->WorkBuffer[sgw->BufferPos] = 0;
985 sgw->NumChars = sgw->BufferPos;
986 sgw->EditOp = EO_DELFORWARD;
987 }
988 else
989 if (letter == CTRL_M)
990 {
991 /* CTRL-M Equivalent to Return or Enter
992 */
993 D(bug("sghkey: CTRL-M\n"));
994 sgw->EditOp = EO_ENTER;
995 sgw->Code = 0;
996 sgw->Actions = (SGA_USE|SGA_END);
997 }
998 else
999 if (letter == CTRL_W)
1000 {
1001 /* CTRL-W Delete the previous word. In fixed field mode, jump
1002 * cursor to the start of the previous word
1003 */
1004 D(bug("sghkey: CTRL-W\n"));
1005 if (sgw->Modes & SGM_FIXEDFIELD)
1006 {
1007 D(bug("sghkey: SGM_FIXEDFIELD\n"));
1008 }
1009 else
1010 {
1011 if (sgw->BufferPos > 0)
1012 {
1013 int len;
1014 int pos;
1015 /*
1016 * search space
1017 */
1018 for (pos=sgw->BufferPos-1;pos >= 0;pos--)
1019 {
1020 if (sgw->WorkBuffer[pos] == ' ')
1021 {
1022 break;
1023 }
1024 }
1025 len = sgw->NumChars - sgw->BufferPos;
1026 memcpy(&sgw->WorkBuffer[pos],&sgw->WorkBuffer[sgw->BufferPos],len);
1027
1028 sgw->NumChars -= sgw->BufferPos - pos;
1029 sgw->BufferPos = pos;
1030 sgw->WorkBuffer[sgw->BufferPos + len] = 0;
1031 sgw->EditOp = EO_DELBACKWARD;
1032 }
1033 }
1034 }
1035 else
1036 if (letter == CTRL_U)
1037 {
1038 /* CTRL-U Delete from the character to the left of the cursor
1039 * to the start of the buffer. In fixed field mode, jump cursor to the start
1040 * of the buffer
1041 */
1042 D(bug("sghkey: CTRL-U\n"));
1043 if (sgw->Modes & SGM_FIXEDFIELD)
1044 {
1045 D(bug("sghkey: SGM_FIXEDFIELD\n"));
1046 sgw->BufferPos = 0;
1047 sgw->EditOp = EO_MOVECURSOR;
1048 }
1049 else
1050 {
1051 if (sgw->BufferPos > 0)
1052 {
1053 int len;
1054 len = sgw->NumChars - sgw->BufferPos;
1055 memcpy(&sgw->WorkBuffer[0],&sgw->WorkBuffer[sgw->BufferPos],len);
1056
1057 sgw->BufferPos = 0;
1058 sgw->WorkBuffer[len] = 0;
1059 sgw->NumChars = len;
1060 sgw->EditOp = EO_DELBACKWARD;
1061 }
1062 }
1063 }
1064 else
1065 if (letter == CTRL_X)
1066 {
1067 /* CTRL-X clears the input buffer (like right amiga-x). In fixed field mode
1068 * jump cursor to the start of the buffer
1069 */
1070 D(bug("sghkey: CTRL-X\n"));
1071 if (sgw->Modes & SGM_FIXEDFIELD)
1072 {
1073 D(bug("sghkey: SGM_FIXEDFIELD\n"));
1074 sgw->BufferPos = 0;
1075 sgw->EditOp = EO_MOVECURSOR;
1076 }
1077 else
1078 {
1079 sgw->BufferPos = 0;
1080 sgw->WorkBuffer[sgw->BufferPos] = 0;
1081 sgw->NumChars = sgw->BufferPos;
1082 sgw->EditOp = EO_CLEAR;
1083 }
1084 }
1085 else
1086 if (letter == CTRL_Z)
1087 {
1088 /* CTRL-Z Jump cursor to the end of the buffer
1089 */
1090 D(bug("sghkey: CTRL-Z\n"));
1091 sgw->BufferPos = sgw->NumChars;
1092 sgw->EditOp = EO_MOVECURSOR;
1093 }
1094 }
1095 else
1096 if (letter == BACKSPACE)
1097 {
1098 if (sgw->BufferPos != 0)
1099 {
1100 UWORD first = sgw->BufferPos;
1101 UWORD last = sgw->NumChars - 1;
1102 UWORD steps;
1103 if (qual & SHIFT)
1104 {
1105 steps = sgw->BufferPos;
1106
1107 sgw->BufferPos = 0;
1108 sgw->NumChars -= steps;
1109 }
1110 else
1111 {
1112 sgw->NumChars --;
1113 sgw->BufferPos --;
1114 steps = 1;
1115 }
1116 MoveCharsLeft(sgw->WorkBuffer, first, last, steps);
1117 sgw->EditOp = EO_DELBACKWARD;
1118 }
1119 }
1120 else if (letter == DELETE)
1121 {
1122 /* Check whether cursor is at the trailing 0 */
1123 if (sgw->BufferPos != sgw->NumChars)
1124 {
1125 if (qual & SHIFT)
1126 {
1127 sgw->WorkBuffer[sgw->BufferPos] = 0;
1128 sgw->NumChars = sgw->BufferPos;
1129 }
1130 else
1131 {
1132 MoveCharsLeft(sgw->WorkBuffer, sgw->BufferPos + 1, sgw->NumChars - 1, 1);
1133 sgw->NumChars --;
1134 }
1135 sgw->EditOp = EO_DELFORWARD;
1136 }
1137 }
1138 else if (letter == RETURN)
1139 {
1140 D(bug("sghkey: ENTER\n"));
1141 sgw->EditOp = EO_ENTER;
1142 sgw->Code = 0;
1143 sgw->Actions = (SGA_USE|SGA_END);
1144 }
1145 else if (letter == TAB)
1146 {
1147 D(bug("sghkey: TAB\n"));
1148 sgw->EditOp = EO_SPECIAL; /* FIXME: ??? is this correct ??? */
1149 sgw->Actions = (SGA_USE|SGA_NEXTACTIVE);
1150 }
1151 else
1152 {
1153
1154 /* Validity check of letter */
1155 if (gad->Activation & GACT_LONGINT)
1156 {
1157 if (letter == '-')
1158 {
1159 if ((sgw->BufferPos != 0) || ((sgw->NumChars > 0) && (sgw->WorkBuffer[0] == '-')))
1160 sgw->EditOp = EO_BADFORMAT;
1161
1162 }
1163 else if ((letter < 0x30) || (letter > 0x39))
1164 {
1165 sgw->EditOp = EO_BADFORMAT;
1166 }
1167 else if (sgw->WorkBuffer[sgw->BufferPos] == '-')
1168 {
1169 sgw->EditOp = EO_BADFORMAT;
1170 }
1171 }
1172 else /* Integer gadget ? */
1173 {
1174 /* Is key a printable character ? */
1175 #warning Locale should be used here...
1176 if ((letter & 0x60) == 0)
1177 {
1178 sgw->EditOp = EO_BADFORMAT;
1179 }
1180 } /* if (integer or string gadget) */
1181
1182 if (sgw->EditOp != EO_BADFORMAT)
1183 {
1184
1185 if ((sgw->Modes & SGM_REPLACE) && (sgw->WorkBuffer[sgw->BufferPos]))
1186 {
1187 D(bug("sghkey: replacing char at pos %d\n", sgw->BufferPos));
1188
1189 sgw->WorkBuffer[sgw->BufferPos] = letter;
1190 sgw->EditOp = EO_REPLACECHAR;
1191
1192 if (sgw->BufferPos < strinfo->MaxChars - 1)
1193 sgw->BufferPos ++;
1194
1195 }
1196 else
1197 {
1198 /* Insert mode. Check if there is space for one more character
1199 ** NOTE: MaxChars inludes traing \0, so therefore the '- 1'
1200 */
1201 if (sgw->NumChars < (strinfo->MaxChars - 1))
1202 {
1203 register UWORD i;
1204
1205 D(bug("sghkey: inserting char at pos %d\n", sgw->BufferPos));
1206 /* Move characters to the right of insertion point one step to the right */
1207 for (i = sgw->NumChars; i > sgw->BufferPos; i --)
1208 {
1209 sgw->WorkBuffer[i] = sgw->WorkBuffer[i - 1];
1210 }
1211
1212 /* Insert letter */
1213 sgw->WorkBuffer[i] = letter;
1214 sgw->EditOp = EO_INSERTCHAR;
1215 sgw->NumChars ++;
1216 sgw->BufferPos ++;
1217
1218 }
1219 else
1220 {
1221 sgw->EditOp = EO_NOOP;
1222 } /* if (enough space for ione mor letter) */
1223 } /* if (Replace or Insert mode) */
1224 } /* If (user pressed valid letter) */
1225 } /* Vanilla key but not backspace, delete, ... */
1226 } /* if (key or scancode) */
1227
1228 /* Null-terminate the new string */
1229 sgw->WorkBuffer[sgw->NumChars] = 0;
1230
1231 if (sgw->EditOp != EO_NOOP)
1232 sgw->Actions |= (SGA_USE|SGA_REDISPLAY);
1233
1234 /* Integer gadget ? */
1235 if ((sgw->Actions & SGA_USE) && (gad->Activation & GACT_LONGINT))
1236 {
1237 sgw->LongInt = atol(sgw->WorkBuffer);
1238 D(bug("Updated string number to %d\n", sgw->LongInt));
1239 }
1240
1241 ReturnInt ("DoSGHKey", ULONG, 1);
1242 }
1243
1244 /*****************************************************************************************/
1245
1246 AROS_UFH3(ULONG, GlobalEditFunc,
1247 AROS_UFHA(struct Hook *, hook, A0),
1248 AROS_UFHA(struct SGWork *, sgw, A2),
1249 AROS_UFHA(ULONG *, command, A1)
1250 )
1251 {
1252 AROS_USERFUNC_INIT
1253
1254 ULONG retcode = 0;
1255
1256 switch (*command)
1257 {
1258 case SGH_CLICK:
1259 retcode = DoSGHClick(sgw, (struct IntuitionBase *)hook->h_Data);
1260 break;
1261
1262 case SGH_KEY:
1263 retcode = DoSGHKey (sgw, (struct IntuitionBase *)hook->h_Data);
1264 break;
1265 }
1266
1267 return retcode;
1268
1269 AROS_USERFUNC_EXIT
1270 }
1271
1272 /*****************************************************************************************/
1273
1274 VOID RefreshStrGadget(struct Gadget *gad,
1275 struct Window *win,
1276 struct Requester *req,
1277 struct IntuitionBase *IntuitionBase)
1278 {
1279 struct GadgetInfo gi;
1280 struct RastPort *rp;
1281
1282 EnterFunc(bug("RefreshStrGadget(gad=%p, win=%s)\n", gad, win->Title));
1283
1284 SetupGInfo(&gi, win, req, gad, IntuitionBase);
1285
1286 if ((rp = ObtainGIRPort(&gi)))
1287 {
1288 if (gad->GadgetRender)
1289 {
1290 if (gad->Flags & GFLG_GADGIMAGE)
1291 {
1292 DrawImage(rp,
1293 (struct Image *)gad->GadgetRender,
1294 gad->LeftEdge,
1295 gad->TopEdge);
1296 }
1297 else
1298 {
1299 DrawBorder(rp,
1300 (struct Border *)gad->GadgetRender,
1301 gad->LeftEdge,
1302 gad->TopEdge);
1303 }
1304 }
1305 ReleaseGIRPort(rp);
1306 }
1307 UpdateStrGadget(gad, win, req, IntuitionBase);
1308
1309 ReturnVoid("RefreshStrGadget");
1310 }
1311
1312 /*****************************************************************************************/
1313
1314 VOID UpdateStringInfo(struct Gadget *gad)
1315 {
1316 /* Updates the stringinfo in case user has set some fields */
1317
1318 struct StringInfo *strinfo = (struct StringInfo *)gad->SpecialInfo;
1319
1320 EnterFunc(bug("UpdateStringInfo(gad=%p)\n", gad));
1321
1322 #if 0
1323 if (gad->Activation & GACT_LONGINT)
1324 {
1325 if ((strinfo->NumChars != 0) || (strinfo->LongInt != 0))
1326 {
1327 /* NOTE: The max number of chars written INCLUDES trailing \0 */
1328 snprintf(strinfo->Buffer, strinfo->MaxChars, "%d", strinfo->LongInt);
1329 }
1330 }
1331 #endif
1332
1333 strinfo->NumChars = strlen(strinfo->Buffer);
1334
1335 if (strinfo->BufferPos > strinfo->NumChars)
1336 {
1337 strinfo->BufferPos = strinfo->NumChars;
1338 }
1339
1340 D(bug("%s gadget contains buffer %s of length %d\n",
1341 (gad->Activation & GACT_LONGINT) ? "Integer" : "String",
1342 strinfo->Buffer, strinfo->NumChars));
1343
1344 ReturnVoid("UpdateStringInfo");
1345 }
1346
1347 /*****************************************************************************************/
1348
1349 VOID UpdateStrGadget(struct Gadget *gad,
1350 struct Window *win,
1351 struct Requester *req,
1352 struct IntuitionBase *IntuitionBase)
1353 {
1354 struct GadgetInfo gi;
1355 struct BBox bbox;
1356 struct StringInfo *strinfo = (struct StringInfo *)gad->SpecialInfo;
1357 UWORD text_left;
1358 UWORD text_top;
1359 struct RastPort *rp;
1360 STRPTR dispstr;
1361 UWORD dispstrlen;
1362 UWORD pens[NUMPENS];
1363
1364 EnterFunc(bug("UpdateStrGadget(current text=%s)\n", strinfo->Buffer));
1365
1366 SetupGInfo(&gi, win, req, gad, IntuitionBase);
1367
1368 rp = ObtainGIRPort(&gi);
1369 if (!rp) return;
1370
1371 GetPensAndFont(gad, pens, win, rp, IntuitionBase);
1372
1373 CalcBBox(win, req, gad, &bbox);
1374
1375 /* Update the stringinfo struct in case of user change */
1376 UpdateStringInfo(gad);
1377
1378 /* Update the DispPos and DispCount fields so that the gadget renders properly */
1379 UpdateDisp(gad, &bbox, rp, IntuitionBase);
1380
1381
1382 dispstr = strinfo->Buffer + strinfo->DispPos;
1383 dispstrlen = MIN(strinfo->DispCount, strinfo->NumChars - strinfo->DispPos);
1384
1385 /* Clear the background */
1386 SetAPen(rp, pens[STRBACKPEN]);
1387 SetDrMd(rp, JAM1);
1388
1389 RectFill(rp,
1390 bbox.Left,
1391 bbox.Top,
1392 bbox.Left + bbox.Width - 1,
1393 bbox.Top + bbox.Height - 1);
1394
1395 text_left = GetTextLeft(gad, &bbox, rp, IntuitionBase);
1396
1397
1398 /* Write the text into the gadget */
1399 SetABPenDrMd(rp, pens[STRTEXTPEN], pens[STRBACKPEN], JAM2);
1400
1401 text_top = bbox.Top
1402 + ((bbox.Height - rp->Font->tf_YSize) >> 1)
1403 + rp->Font->tf_Baseline;
1404
1405 Move(rp, text_left, text_top);
1406
1407 D(bug("usg: Writing text %s of length %d at (%d, %d)\n",
1408 dispstr, strinfo->DispCount, text_left, text_top));
1409
1410 Text(rp, dispstr, strinfo->DispCount);
1411
1412 if (gad->Flags & GFLG_SELECTED)
1413 {
1414 UWORD cursoroffset = strinfo->BufferPos - strinfo->DispPos;
1415 /* Render cursor */
1416 // SetAfPt(rp,NULL,0);
1417 D(bug("usg: Number of characters: %d\n", strinfo->NumChars));
1418
1419
1420 text_left += TextLength(rp, dispstr, cursoroffset);
1421
1422 #if 1
1423 if (strinfo->BufferPos < strinfo->NumChars)
1424 {
1425 SetABPenDrMd(rp, pens[STRTEXTPEN], pens[CURSORPEN], JAM2);
1426 Move(rp, text_left, text_top);
1427 Text(rp,
1428 dispstr + cursoroffset,
1429 1 );
1430 }
1431 else
1432 {
1433 struct TextExtent te;
1434
1435 SetABPenDrMd(rp, pens[STRTEXTPEN], pens[CURSORPEN], JAM2|INVERSVID);
1436 TextExtent(rp, cursorkey, CURSORKEYLEN,&te);
1437
1438 RectFill(rp,
1439 text_left+te.te_Extent.MinX,
1440 text_top+te.te_Extent.MinY,
1441 text_left+te.te_Extent.MaxX,
1442 text_top+te.te_Extent.MaxY);
1443 }
1444 #else
1445 Move(rp, text_left, text_top);
1446 Text(rp,
1447 ((strinfo->BufferPos < strinfo->NumChars)
1448 ? dispstr + cursoroffset
1449 : cursorkey),
1450 1 );
1451 #endif
1452
1453 } /* if (gadget selected => render cursor) */
1454
1455 if (gad->Flags & GFLG_DISABLED )
1456 {
1457 struct DrawInfo *dri = GetScreenDrawInfo(win->WScreen);
1458
1459 RenderDisabledPattern(rp, dri, bbox.Left,
1460 bbox.Top,
1461 bbox.Left + bbox.Width - 1,
1462 bbox.Top + bbox.Height - 1,
1463 IntuitionBase );
1464
1465 if (dri) FreeScreenDrawInfo(win->WScreen, dri);
1466 }
1467
1468 ReleaseGIRPort(rp);
1469
1470 ReturnVoid("UpdateStrGadget");
1471 }
A totally sweet operating system