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