Logo ROOT  
Reference Guide
TGTextEntry.cxx
Go to the documentation of this file.
1// @(#)root/gui:$Id$
2// Author: Fons Rademakers 08/01/98
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11/**************************************************************************
12
13 This source is based on Xclass95, a Win95-looking GUI toolkit.
14 Copyright (C) 1996, 1997 David Barth, Ricky Ralston, Hector Peraza.
15
16 Xclass95 is free software; you can redistribute it and/or
17 modify it under the terms of the GNU Library General Public
18 License as published by the Free Software Foundation; either
19 version 2 of the License, or (at your option) any later version.
20
21**************************************************************************/
22
23//////////////////////////////////////////////////////////////////////////
24// //
25// TGTextEntry //
26// //
27// A TGTextEntry is a one line text input widget. //
28// //
29// Changing text in the text entry widget will generate the event: //
30// kC_TEXTENTRY, kTE_TEXTCHANGED, widget id, 0. //
31// Hitting the enter key will generate: //
32// kC_TEXTENTRY, kTE_ENTER, widget id, 0. //
33// Hitting the tab key will generate: //
34// kC_TEXTENTRY, kTE_TAB, widget id, 0. //
35// //
36// This widget has the behaviour e.g. of the "Location" field in //
37// netscape. That includes handling Control/Shift key modifiers and //
38// scrolling the text. //
39//
40//
41// enum TGTextEntry::EEchoMode
42//
43// This enum type describes the ways in which TGTextEntry can display
44// its contents. The currently defined values are:
45//
46/*
47<ul>
48<li> kNormal - display characters as they are entered. This is the default.
49<li> kNoEcho - do not display anything.
50<li> kPassword - display asterisks instead of the characters actually entered.
51</ul>
52*/
53//
54// See also SetEchoMode(), GetEchoMode().
55//
56// enum TGTextEntry::EInsertMode
57//
58// This enum type describes the way how typed characters are
59// inserted in the text entry. This mode is switched by "Insert" key.
60//
61/*
62<ul>
63<li> kInsert - typed character are inserted (cursor has shape of short line).
64<li> kReplace - typed characters substitute already typed ones
65 (cursor has the shape of filled rectangle).
66</ul>
67*/
68//
69//
70// enum TGWidget::ETextJustification
71//
72// This enum type (defined in TGWidget.h) describes the text alignment modes.
73// These modes are valid until text fits the frame width
74//
75/*
76<ul>
77<li> kTextLeft - left-side text alignment
78<li> kTextRight - right-side text alignment
79<li> kTextCenterX - center text alignment
80</ul>
81*/
82//
83//
84//
85// The key press event handler converts a key press to some line editor action.
86// Here are the default key bindings:
87//
88/*
89<ul>
90<li><i> Left Arrow </i>
91 Move the cursor one character leftwards.
92 Scroll the text when cursor is out of frame.
93<li><i> Right Arrow </i>
94 Move the cursor one character rightwards
95 Scroll the text when cursor is out of frame.
96<li><i> Backspace </i>
97 Deletes the character on the left side of the text cursor and moves the
98 cursor one position to the left. If a text has been marked by the user
99 (e.g. by clicking and dragging) the cursor will be put at the beginning
100 of the marked text and the marked text will be removed.
101<li><i> Home </i>
102 Moves the text cursor to the left end of the line. If mark is TRUE text
103 will be marked towards the first position, if not any marked text will
104 be unmarked if the cursor is moved.
105<li><i> End </i>
106 Moves the text cursor to the right end of the line. If mark is TRUE text
107 will be marked towards the last position, if not any marked text will
108 be unmarked if the cursor is moved.
109<li><i> Delete </i>
110 Deletes the character on the right side of the text cursor. If a text
111 has been marked by the user (e.g. by clicking and dragging) the cursor
112 will be put at the beginning of the marked text and the marked text will
113 be removed.
114<li><i> Insert </i>
115 Switches character insert mode.
116<li><i> Shift - Left Arrow </i>
117 Mark text one character leftwards
118<li><i> Shift - Right Arrow </i>
119 Mark text one character rightwards
120<li><i> Control - Left Arrow </i>
121 Move the cursor one word leftwards
122<li><i> Control - Right Arrow </i>
123 Move the cursor one word rightwards.
124<li><i> Control - Shift - Left Arrow </i>
125 Mark text one word leftwards
126<li><i> Control - Shift - Right Arrow </i>
127 Mark text one word rightwards
128<li><i> Control-A </i>
129 Move the cursor to the beginning of the line
130<li><i> Control-B </i>
131 Move the cursor one character leftwards
132<li><i> Control-C </i>
133 Copy the marked text to the clipboard.
134<li><i> Control-D </i>
135 Delete the character to the right of the cursor
136<li><i> Control-E </i>
137 Move the cursor to the end of the line
138<li><i> Control-F </i>
139 Move the cursor one character rightwards
140<li><i> Control-H </i>
141 Delete the character to the left of the cursor
142<li><i> Control-K </i>
143 Delete marked text if any or delete all
144 characters to the right of the cursor
145<li><i> Control-U </i>
146 Delete all characters on the line
147<li><i> Control-V </i>
148 Paste the clipboard text into line edit.
149<li><i> Control-X </i>
150 Cut the marked text, copy to clipboard.
151<li><i> Control-Y </i>
152 Paste the clipboard text into line edit.
153</ul>
154All other keys with valid ASCII codes insert themselves into the line.
155*/
156//
157//
158////////////////////////////////////////////////////////////////////////////////
159
160//******************* TGTextEntry signals *************************************
161//______________________________________________________________________________
162// TGTextEntry::ReturnPressed()
163//
164// This signal is emitted when the return or enter key is pressed.
165//
166//______________________________________________________________________________
167// TGTextEntry::TabPressed()
168//
169// This signal is emitted when the <TAB> key is pressed.
170// Use for changing focus.
171//
172//______________________________________________________________________________
173// TGTextEntry::ShiftTabPressed()
174//
175// This signal is emitted when the <SHIFT> and <TAB> keys are pressed.
176// Use for changing focus in reverse direction.
177//
178//______________________________________________________________________________
179// TGTextEntry::TextChanged(const char *text)
180//
181// This signal is emitted every time the text has changed.
182// The argument is the new text.
183//
184//______________________________________________________________________________
185// TGTextEntry::CursorOutLeft()
186//
187// This signal is emitted when cursor is going out of left side.
188//
189//______________________________________________________________________________
190// TGTextEntry::CursorOutRight()
191//
192// This signal is emitted when cursor is going out of right side.
193//
194//______________________________________________________________________________
195// TGTextEntry::CursorOutUp()
196//
197// This signal is emitted when cursor is going out of upper side.
198//
199//______________________________________________________________________________
200// TGTextEntry::CursorOutDown()
201//
202// This signal is emitted when cursor is going out of bottom side.
203//
204//______________________________________________________________________________
205// TGTextEntry::DoubleClicked()
206//
207// This signal is emitted when widget is double clicked.
208
209
210#include "TGTextEntry.h"
211#include "TGResourcePool.h"
212#include "TGToolTip.h"
213#include "TSystem.h"
214#include "TTimer.h"
215#include "TColor.h"
216#include "KeySymbols.h"
217#include "Riostream.h"
218#include "TClass.h"
219#include "TGMsgBox.h"
220
221
227
229
230////////////////////////////////////////////////////////////////////////////////
231
232class TBlinkTimer : public TTimer {
233private:
234 TGTextEntry *fTextEntry;
235public:
236 TBlinkTimer(TGTextEntry *t, Long_t ms) : TTimer(ms, kTRUE) { fTextEntry = t; }
237 Bool_t Notify();
238};
239
240////////////////////////////////////////////////////////////////////////////////
241/// Notify when timer times out and reset the timer.
242
243Bool_t TBlinkTimer::Notify()
244{
245 fTextEntry->HandleTimer(0);
246 Reset();
247 return kFALSE;
248}
249
250
252
253////////////////////////////////////////////////////////////////////////////////
254/// Create a text entry widget. It will adopt the TGTextBuffer object
255/// (i.e. the text buffer will be deleted by the text entry widget).
256
258 GContext_t norm, FontStruct_t font, UInt_t options,
259 ULong_t back) :
260 TGFrame(p, 1, 1, options | kOwnBackground, back)
261{
262 TGGC *normgc = fClient->GetResourcePool()->GetGCPool()->FindGC(norm);
263
264 fWidgetId = id;
265 fMsgWindow = p;
266 if (normgc)
267 fNormGC = *normgc;
268 else
270 fFontStruct = font;
271 fText = text;
272
273 Init();
274}
275
276////////////////////////////////////////////////////////////////////////////////
277/// Simple text entry constructor.
278
279TGTextEntry::TGTextEntry(const TGWindow *parent, const char *text, Int_t id) :
280 TGFrame(parent, 1, 1, kSunkenFrame | kDoubleBorder | kOwnBackground, fgWhitePixel)
281{
282 fWidgetId = id;
283 fMsgWindow = parent;
286 fText = new TGTextBuffer();
287 fText->AddText(0, !text && !parent ? GetName() : text);
288
289 Init(); // default initialization
290}
291
292////////////////////////////////////////////////////////////////////////////////
293/// Simple test entry constructor. Notice TString argument comes before the
294/// parent argument (to make this ctor different from the first one taking a
295/// const char*).
296
297TGTextEntry::TGTextEntry(const TString &contents, const TGWindow *parent, Int_t id) :
298 TGFrame(parent, 1, 1, kSunkenFrame | kDoubleBorder | kOwnBackground, fgWhitePixel)
299{
300 fWidgetId = id;
301 fMsgWindow = parent;
304 fText = new TGTextBuffer();
305 fText->AddText(0, contents.Data());
306
307 Init(); // default initialization
308}
309
310////////////////////////////////////////////////////////////////////////////////
311/// Delete a text entry widget.
312
314{
315 delete fText;
316 delete fCurBlink;
317 delete fTip;
318
319 if (this == gBlinkingEntry) gBlinkingEntry = 0;
320}
321
322////////////////////////////////////////////////////////////////////////////////
323/// Do default initialization.
324
326{
330
331 fOffset = 0;
332 // Set default maximum length to 4096. Can be changed with SetMaxLength()
333 fMaxLen = 4096;
335 fEdited = kFALSE;
339 fDefWidth = fDefHeight = 0;
340
341 int tw, max_ascent, max_descent;
342 tw = gVirtualX->TextWidth(fFontStruct, GetText(), fText->GetTextLength());
343
344 if (tw < 1) {
346 tw = gVirtualX->TextWidth(fFontStruct, dummy.Data(), dummy.Length());
347 }
348 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
349 Resize(tw + 8, max_ascent + max_descent + 7);
350
351 Int_t offset = IsFrameDrawn() ? 4 : 0;
352 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
353 offset = 2;
354 fCursorX = offset ;
357 fCurBlink = 0;
358 fTip = 0;
360
362
363 gVirtualX->GrabButton(fId, kAnyButton, kAnyModifier,
366
369
372 wattr.fBitGravity = 1; // NorthWestGravity
373 wattr.fWinGravity = 1;
374 gVirtualX->ChangeWindowAttributes(fId, &wattr);
375
379}
380
381////////////////////////////////////////////////////////////////////////////////
382/// Return the default / minimal size of the widget.
383
385{
386 UInt_t w = (GetOptions() & kFixedWidth) || (fDefWidth == 0) ? fWidth : fDefWidth;
388 return TGDimension(w, h);
389}
390
391////////////////////////////////////////////////////////////////////////////////
392/// Set the default / minimal size of the widget.
393
395{
396 fDefWidth = w;
397 fDefHeight = h;
398}
399
400////////////////////////////////////////////////////////////////////////////////
401/// This signal is emitted when the return or enter key is pressed.
402
404{
407
408 Emit("ReturnPressed()");
409}
410
411////////////////////////////////////////////////////////////////////////////////
412/// This signal is emitted when `SHIFT` and `TAB` keys are pressed.
413
415{
416 Emit("ShiftTabPressed()");
417}
418
419////////////////////////////////////////////////////////////////////////////////
420/// This signal is emitted when the <TAB> key is pressed.
421
423{
426
427 Emit("TabPressed()");
428}
429
430////////////////////////////////////////////////////////////////////////////////
431/// This signal is emitted every time the text has changed.
432
433void TGTextEntry::TextChanged(const char *)
434{
437
438 Emit("TextChanged(char*)", GetText()); // The argument is the new text.
439}
440
441////////////////////////////////////////////////////////////////////////////////
442/// This signal is emitted when cursor is going out of left side.
443
445{
446 Emit("CursorOutLeft()");
447}
448
449////////////////////////////////////////////////////////////////////////////////
450/// This signal is emitted when cursor is going out of right side.
451
453{
454 Emit("CursorOutRight()");
455}
456
457////////////////////////////////////////////////////////////////////////////////
458/// This signal is emitted when cursor is going out of upper side.
459
461{
462 Emit("CursorOutUp()");
463}
464
465////////////////////////////////////////////////////////////////////////////////
466/// This signal is emitted when cursor is going out of bottom side.
467
469{
470 Emit("CursorOutDown()");
471}
472
473////////////////////////////////////////////////////////////////////////////////
474/// This signal is emitted when widget is double clicked.
475
477{
478 Emit("DoubleClicked()");
479}
480
481////////////////////////////////////////////////////////////////////////////////
482/// Returns the text that's currently displayed. This is normally
483/// the same as GetText(), but can be e.g.
484/// "*****" if EEchoMode is kPassword or
485/// "" if it is kNoEcho.
486
488{
489 TString res;
490
491 switch (GetEchoMode()) {
492 case kNormal:
493 res = GetText();
494 break;
495 case kNoEcho:
496 res = "";
497 break;
498 case kPassword:
499 res.Prepend('*', fText->GetTextLength()); // fill with '*'
500 break;
501 }
502 return res;
503}
504
505////////////////////////////////////////////////////////////////////////////////
506/// Set state of widget. If kTRUE=enabled, kFALSE=disabled.
507
509{
510 if (state) {
513 } else {
516 fCursorOn = kFALSE; // remove the cursor when disabling the widget
517 if (fCurBlink) fCurBlink->Remove();
518 }
519 fClient->NeedRedraw(this);
520}
521
522////////////////////////////////////////////////////////////////////////////////
523/// Returns the index of the character to whose left edge xcoord is closest.
524
526{
527 int tw, ix, up, down, len;
528
529 // check for out of boundaries first...
530 TString dt = GetDisplayText();
531 len = dt.Length();
532 tw = gVirtualX->TextWidth(fFontStruct, dt.Data(), len);
533 if (xcoord < 0) return 0;
534 if (xcoord > tw) return len; // len-1
535
536 // do a binary approximation
537 up = len; //-1
538 down = 0;
539 while (up-down > 1) {
540 ix = (up+down) >> 1;
541 tw = gVirtualX->TextWidth(fFontStruct, fText->GetString(), ix);
542 if (tw > xcoord)
543 up = ix;
544 else
545 down = ix;
546 if (tw == xcoord) break;
547 }
548 ix = down;
549
550 // safety check...
551 ix = TMath::Max(ix, 0);
552 ix = TMath::Min(ix, len); // len-1
553
554 return ix;
555}
556
557////////////////////////////////////////////////////////////////////////////////
558/// Sets the text entry to draw itself inside a two-pixel frame if
559/// enable is kTRUE, and to draw itself without any frame if enable is
560/// kFALSE. The default is kTRUE.
561
563{
564 if (fFrameDrawn == enable) return;
565
566 fFrameDrawn = enable;
567 fClient->NeedRedraw(this);
568 // ChangedBy("SetFrameDrawn"); // emit signal ChangedBy
569}
570
571////////////////////////////////////////////////////////////////////////////////
572/// Sets the alignment of the text entry.
573/// Possible values are kTextLeft(default), kTextRight, kTextCenterX.
574/// See also GetAlignment().
575
577{
578 if ((mode == kTextRight ||
579 mode == kTextCenterX ||
580 mode == kTextLeft)) {
581
584 wattr.fWinGravity = 1;
585
586 if (mode == kTextLeft) {
587 wattr.fBitGravity = 1;
588 } else if (mode == kTextRight) {
589 wattr.fBitGravity = 3;
590 } else {
591 wattr.fBitGravity = 5;
592 }
593
594 gVirtualX->ChangeWindowAttributes(fId, &wattr);
595
596 fAlignment = mode;
597 UpdateOffset();
598 fClient->NeedRedraw(this);
599 // ChangedBy("SetAlignment"); // emit signal ChangedBy
600 }
601}
602
603////////////////////////////////////////////////////////////////////////////////
604/// Sets the mode how characters are entered to the text entry.
605
607{
608 if (fInsertMode == mode) return;
609
610 fInsertMode = mode;
611 fClient->NeedRedraw(this);
612 // ChangedBy("SetInsertMode"); // emit signal ChangedBy
613}
614
615////////////////////////////////////////////////////////////////////////////////
616/// Sets text entry to text, clears the selection and moves
617/// the cursor to the end of the line.
618/// If necessary the text is truncated to fit MaxLength().
619/// See also GetText().
620
621void TGTextEntry::SetText(const char *text, Bool_t emit)
622{
623 TString oldText(GetText());
624
625 fText->Clear();
626 fText->AddText(0, text); // new text
627
628 Int_t dif = fText->GetTextLength() - fMaxLen;
629 if (dif > 0) fText->RemoveText(fMaxLen, dif); // truncate
630
631 End(kFALSE);
632 if (oldText != GetText()) {
633 if (emit)
634 TextChanged(); // emit signal
635 fClient->NeedRedraw(this);
636 }
637}
638
639////////////////////////////////////////////////////////////////////////////////
640/// Set the maximum length of the text in the editor. If the text is
641/// currently too long, it is chopped off at the limit. Any marked text will
642/// be unmarked. The cursor position is set to 0 and the first part of the
643/// string is shown.
644/// See also GetMaxLength().
645
647{
648 fMaxLen = maxlen < 0 ? 0 : maxlen; // safety check for maxlen < 0
649
650 Int_t dif = fText->GetTextLength() - fMaxLen;
651 if (dif > 0) fText->RemoveText(fMaxLen, dif); // truncate
652
654 Deselect();
655
656 // ChangedBy("SetMaxLength"); // emit signal ChangedBy
657}
658
659////////////////////////////////////////////////////////////////////////////////
660/// The echo modes available are:
661///
662/// <ul>
663/// <li> kNormal - display characters as they are entered. This is the default.
664/// <li> kNoEcho - do not display anything.
665/// <li> kPassword - display asterisks instead of the characters actually entered.
666/// </ul>
667///
668/// It is always possible to cut and paste any marked text; only the widget's own
669/// display is affected.
670/// See also GetEchoMode(), GetDisplayText().
671
673{
674 if (fEchoMode == mode) return;
675
676 Int_t offset = IsFrameDrawn() ? 4 : 0;
677 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
678 offset = 2;
679 fEchoMode = mode;
680 if (GetEchoMode() == kNoEcho) { fCursorX = offset; }
681 UpdateOffset();
682 fClient->NeedRedraw(this);
683 // ChangedBy("SetEchoMode"); // emit signal ChangedBy
684}
685
686////////////////////////////////////////////////////////////////////////////////
687/// Returns the text marked by the user (e.g. by clicking and
688/// dragging), or zero if no text is marked.
689/// See also HasMarkedText().
690
692{
693 Int_t minP = MinMark();
694 Int_t len = MaxMark() - minP;
695 TString res(GetText()+minP,len);
696 return res;
697}
698
699////////////////////////////////////////////////////////////////////////////////
700/// New character mark at position pos.
701/// See also SetCursorPosition().
702
704{
705 TString dt = GetDisplayText();
706 Int_t offset = IsFrameDrawn() ? 4 : 0;
707 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
708 offset = 2;
709 Int_t x = fOffset + offset;
710 Int_t len = dt.Length();
711
712 Int_t pos = newPos < len ? newPos : len;
713 fEndIX = pos < 0 ? 0 : pos;
714
717
718 if (fSelectionOn) {
719 fEndX = x + gVirtualX->TextWidth(fFontStruct, dt.Data() , fEndIX);
720 fStartX = x + gVirtualX->TextWidth(fFontStruct, dt.Data() , fStartIX);
721 }
722}
723
724////////////////////////////////////////////////////////////////////////////////
725/// Set the cursor position to newPos.
726/// See also NewMark().
727
729{
730 Int_t offset = IsFrameDrawn() ? 4 : 0;
731 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
732 offset = 2;
733 if (GetEchoMode() == kNoEcho) { fCursorX = offset; return; }
734
735 UpdateOffset();
736 TString dt = GetDisplayText();
737
738 Int_t x = fOffset + offset;
739 Int_t len = dt.Length();
740
741 Int_t pos;
742
743 if (newPos < len)
744 pos = newPos;
745 else {
746 pos = len;
747 if (newPos > len) CursorOutRight();
748 }
749
750 if (pos < 0) {
751 fCursorIX = 0;
753 } else
754 fCursorIX = pos;
755
756 fCursorX = x + gVirtualX->TextWidth(fFontStruct, dt.Data(), fCursorIX);
757
758 if (!fSelectionOn){
761 }
762}
763
764////////////////////////////////////////////////////////////////////////////////
765/// Marks the word nearest to cursor position.
766/// See also HandleDoubleClick().
767
769{
770 Int_t i = pos - 1;
771 while (i >= 0 && isprint(GetText()[i]) && !isspace(GetText()[i])) i--;
772 i++;
773 Int_t newStartIX = i;
774
775 i = pos;
776 while (isprint(GetText()[i]) && !isspace(GetText()[i])) i++;
777 while(isspace(GetText()[i])) i++;
778
780 fStartIX = newStartIX;
781 fEndIX = i;
782 NewMark(i);
783}
784
785////////////////////////////////////////////////////////////////////////////////
786/// Removes any currently selected text, inserts newText,
787/// sets it as the new contents of the text entry.
788
789void TGTextEntry::Insert(const char *newText)
790{
791 TString old(GetText());
792 TString t(newText);
793
794 if (t.IsNull()) return;
795
796 for (int i=0; i<t.Length(); i++) {
797 if (t[i] < ' ') t[i] = ' '; // unprintable/linefeed becomes space
798 }
799
800 Int_t minP = MinMark();
801 Int_t maxP = MaxMark();
802 Int_t cp = fCursorIX;
803
804 if (HasMarkedText()) {
805 fText->RemoveText(minP, maxP-minP);
806 cp = minP;
807 }
808
809 if (fInsertMode == kReplace) fText->RemoveText(cp,t.Length());
810 Int_t ncp = TMath::Min(cp+t.Length(), GetMaxLength());
811 fText->AddText(cp, t.Data());
813 if (dlen>0) fText->RemoveText(GetMaxLength(),dlen); // truncate
814
816 if (old != GetText()) TextChanged();
817}
818
819////////////////////////////////////////////////////////////////////////////////
820/// Moves the cursor rightwards one or more characters.
821/// See also CursorLeft().
822
824{
825 Int_t cp = fCursorIX + steps;
826
827 if (cp == fCursorIX) {
828 if (!mark) {
831 }
832 } else if (mark) {
834 NewMark(cp);
835 } else {
838 }
839}
840
841////////////////////////////////////////////////////////////////////////////////
842/// Moves the cursor leftwards one or more characters.
843/// See also CursorRight().
844
846{
847 CursorRight(mark, -steps);
848}
849
850////////////////////////////////////////////////////////////////////////////////
851/// Moves the cursor one word to the right. If mark is kTRUE, the text
852/// is marked.
853/// See also CursorWordBackward().
854
856{
857 Int_t i = fCursorIX;
858 while (i < (Int_t)fText->GetTextLength() && !isspace(GetText()[i])) ++i;
859 while (i < (Int_t)fText->GetTextLength() && isspace(GetText()[i])) ++i;
861}
862
863////////////////////////////////////////////////////////////////////////////////
864/// Moves the cursor one word to the left. If mark is kTRUE, the text
865/// is marked.
866/// See also CursorWordForward().
867
869{
870 Int_t i = fCursorIX;
871 while (i > 0 && isspace(GetText()[i-1])) --i;
872 while (i > 0 && !isspace(GetText()[i-1])) --i;
874}
875
876////////////////////////////////////////////////////////////////////////////////
877/// Deletes the character on the left side of the text cursor and moves the
878/// cursor one position to the left. If a text has been marked by the user
879/// (e.g. by clicking and dragging) the cursor will be put at the beginning
880/// of the marked text and the marked text will be removed.
881/// See also Del().
882
884{
885 if (HasMarkedText()) {
886 Del();
887 } else if (fCursorIX > 0) {
889 Del();
890 }
891}
892
893////////////////////////////////////////////////////////////////////////////////
894/// Deletes the character on the right side of the text cursor. If a text
895/// has been marked by the user (e.g. by clicking and dragging) the cursor
896/// will be put at the beginning of the marked text and the marked text will
897/// be removed.
898/// See also Backspace().
899
901{
902 Int_t minP = MinMark();
903 Int_t maxP = MaxMark();
904 Int_t offset = IsFrameDrawn() ? 4 : 0;
905 Int_t w = GetWidth() - 2 * offset; // subtract border twice
906
907 if (HasMarkedText()) {
908 fText->RemoveText(minP, maxP-minP);
910 TString dt = GetDisplayText();
911 Int_t textWidth = gVirtualX->TextWidth(fFontStruct, dt.Data(), dt.Length());
912 fOffset = w - textWidth - 1;
913 SetCursorPosition(minP);
914 } else if (fCursorIX != (Int_t)fText->GetTextLength()) {
917 TString dt = GetDisplayText();
918 Int_t textWidth = gVirtualX->TextWidth(fFontStruct, dt.Data(), dt.Length());
919 fOffset = w - textWidth - 1;
921 }
922 TextChanged();
923}
924
925////////////////////////////////////////////////////////////////////////////////
926/// Deletes all characters on the right side of the cursor.
927/// See also Del() Backspace().
928
930{
934 TextChanged(); // emit signal
935 }
936}
937
938////////////////////////////////////////////////////////////////////////////////
939/// Copies the marked text to the clipboard, if there is any and
940/// GetEchoMode() is kNormal.
941/// See also Cut() Paste().
942
944{
945 if (HasMarkedText() && GetEchoMode() == kNormal) {
947 *fgClipboardText = GetMarkedText(); // assign
948 gVirtualX->SetPrimarySelectionOwner(fId);
949 }
950}
951
952////////////////////////////////////////////////////////////////////////////////
953/// Inserts text at the cursor position, deleting any
954/// previous marked text.
955/// See also CopyText() Cut().
956
958{
959 if (gVirtualX->GetPrimarySelectionOwner() == kNone) {
960 // No primary selection, so use the buffer
962 } else {
963 gVirtualX->ConvertPrimarySelection(fId, fClipboard, 0);
964 }
965}
966
967////////////////////////////////////////////////////////////////////////////////
968/// Copies the marked text to the clipboard and deletes it, if there is any.
969/// See also CopyText() Paste().
970
972{
973 if (HasMarkedText()) {
974 CopyText();
975 Del();
976 }
977}
978
979////////////////////////////////////////////////////////////////////////////////
980/// Clears up the text entry.
981
983{
984 SetText("");
985}
986
987////////////////////////////////////////////////////////////////////////////////
988/// Moves the text cursor to the left end of the line. If mark is kTRUE text
989/// will be marked towards the first position, if not any marked text will
990/// be unmarked if the cursor is moved.
991/// See also End().
992
994{
995 fOffset = 0;
996 if (mark){
999 UpdateOffset();
1000 NewMark(0);
1001 } else {
1004 }
1005}
1006
1007////////////////////////////////////////////////////////////////////////////////
1008/// Moves the text cursor to the right end of the line. If mark is kTRUE text
1009/// will be marked towards the last position, if not any marked text will
1010/// be unmarked if the cursor is moved.
1011/// See also Home().
1012
1014{
1015 TString dt = GetDisplayText();
1016 Int_t len = dt.Length();
1017
1018 fOffset = (Int_t)GetWidth() - gVirtualX->TextWidth(fFontStruct, dt.Data(), len);
1019 if (fOffset > 0) fOffset = 0;
1020
1021 if (mark){
1024 UpdateOffset();
1025 NewMark(len);
1026 } else {
1028 SetCursorPosition(len);
1029 }
1030}
1031
1032////////////////////////////////////////////////////////////////////////////////
1033/// Selects all text (i.e. marks it) and moves the cursor to the
1034/// end. Useful when a default value has been inserted. If the user
1035/// types before clicking on the widget the selected text will be
1036/// erased.
1037
1039{
1041 fStartIX = 0;
1043 DoRedraw();
1044}
1045
1046////////////////////////////////////////////////////////////////////////////////
1047/// Deselects all text (i.e. removes marking) and leaves the cursor at the
1048/// current position.
1049
1051{
1054 DoRedraw();
1055}
1056
1057////////////////////////////////////////////////////////////////////////////////
1058/// Draw the border of the text entry widget.
1059
1061{
1064 if (gClient->GetStyle() < 2) {
1065 gVirtualX->DrawLine(fId, GetShadowGC()(), 0, 0, fWidth-2, 0);
1066 gVirtualX->DrawLine(fId, GetShadowGC()(), 0, 0, 0, fHeight-2);
1067 gVirtualX->DrawLine(fId, GetBlackGC()(), 1, 1, fWidth-3, 1);
1068 gVirtualX->DrawLine(fId, GetBlackGC()(), 1, 1, 1, fHeight-3);
1069
1070 gVirtualX->DrawLine(fId, GetHilightGC()(), 0, fHeight-1, fWidth-1, fHeight-1);
1071 gVirtualX->DrawLine(fId, GetHilightGC()(), fWidth-1, fHeight-1, fWidth-1, 0);
1072 gVirtualX->DrawLine(fId, GetBckgndGC()(), 1, fHeight-2, fWidth-2, fHeight-2);
1073 gVirtualX->DrawLine(fId, GetBckgndGC()(), fWidth-2, 1, fWidth-2, fHeight-2);
1074 break;
1075 }
1076 default:
1078 break;
1079 }
1080}
1081
1082////////////////////////////////////////////////////////////////////////////////
1083/// Draw the text entry widget.
1084
1086{
1087 Int_t x, y, max_ascent, max_descent, h;
1088 Int_t offset = IsFrameDrawn() ? 4 : 0;
1089 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
1090 offset = 2;
1091 TString dt = GetDisplayText(); // text to be displayed
1092 Int_t len = dt.Length(); // length of displayed text
1093
1094 // TGFrame::DoRedraw() == drawing border twice
1095 Int_t border = IsFrameDrawn() ? fBorderWidth : 0;
1096
1097 gVirtualX->ClearArea(fId, border, border,
1098 fWidth - (border << 1), fHeight - (border << 1));
1099
1100 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
1101
1102 h = max_ascent + max_descent;
1103 y = (fHeight - h) >> 1 ;
1104 x = fOffset + offset;
1105
1106 if (fEchoMode == kNoEcho) {
1108 fCursorX = offset;
1109 }
1110
1111 if ((GetInsertMode() == kInsert) || (fEchoMode == kNoEcho)) {
1112 // line cursor
1113 if (fCursorOn) {
1114 gVirtualX->DrawLine(fId, GetBlackGC()(), fCursorX, y - 1,
1115 fCursorX, h + 2);
1116 }
1117 gVirtualX->DrawString(fId, fNormGC(), x, y + max_ascent, dt.Data(), len);
1118
1119 } else {
1120 // filled rectangle (block) cursor
1121 gVirtualX->DrawString(fId, fNormGC(), x, y + max_ascent, dt.Data(), len);
1122
1123 if (fCursorOn) {
1124 Int_t ind = fCursorIX < len-1 ? fCursorIX : len - 1;
1125 Int_t charWidth = ind < 0 || fCursorIX > len - 1 ? 4 :
1126 gVirtualX->TextWidth(fFontStruct, &dt[ind],1);
1127
1128 Int_t before = gVirtualX->TextWidth(fFontStruct, dt, fCursorIX) + x;
1129
1130 gVirtualX->FillRectangle(fId, fSelbackGC , before, y ,
1131 charWidth , h + 1);
1132
1133 if (fCursorIX < len)
1134 gVirtualX->DrawString(fId, fSelGC(), before, y + max_ascent, &dt[ind], 1);
1135 }
1136 }
1137
1138 if (fSelectionOn) {
1139 int xs, ws, ixs, iws;
1140
1141 xs = TMath::Min(fStartX, fEndX);
1143 ixs = TMath::Min(fStartIX, fEndIX);
1144 iws = TMath::Abs(fEndIX - fStartIX);
1145
1146 gVirtualX->FillRectangle(fId, fSelbackGC, xs, y, ws, h + 1);
1147
1148 gVirtualX->DrawString(fId, fSelGC(), xs, y + max_ascent,
1149 dt.Data() + ixs, iws);
1150 }
1151 if (IsFrameDrawn()) DrawBorder();
1152}
1153
1154////////////////////////////////////////////////////////////////////////////////
1155/// The key press event handler converts a key press to some line editor
1156/// action. Here are the default key bindings:
1157///
1158/// <ul>
1159/// <li><i> Left Arrow </i>
1160/// Move the cursor one character leftwards.
1161/// Scroll the text when cursor is out of frame.
1162/// <li><i> Right Arrow </i>
1163/// Move the cursor one character rightwards
1164/// Scroll the text when cursor is out of frame.
1165/// <li><i> Backspace </i>
1166/// Deletes the character on the left side of the text cursor and moves the
1167/// cursor one position to the left. If a text has been marked by the user
1168/// (e.g. by clicking and dragging) the cursor will be put at the beginning
1169/// of the marked text and the marked text will be removed.
1170/// <li><i> Home </i>
1171/// Moves the text cursor to the left end of the line. If mark is TRUE text
1172/// will be marked towards the first position, if not any marked text will
1173/// be unmarked if the cursor is moved.
1174/// <li><i> End </i>
1175/// Moves the text cursor to the right end of the line. If mark is TRUE text
1176/// will be marked towards the last position, if not any marked text will
1177/// be unmarked if the cursor is moved.
1178/// <li><i> Delete </i>
1179/// Deletes the character on the right side of the text cursor. If a text
1180/// has been marked by the user (e.g. by clicking and dragging) the cursor
1181/// will be put at the beginning of the marked text and the marked text will
1182/// be removed.
1183/// <li><i> Insert </i>
1184/// Switches character insert mode.
1185/// <li><i> Shift - Left Arrow </i>
1186/// Mark text one character leftwards
1187/// <li><i> Shift - Right Arrow </i>
1188/// Mark text one character rightwards
1189/// <li><i> Control - Left Arrow </i>
1190/// Move the cursor one word leftwards
1191/// <li><i> Control - Right Arrow </i>
1192/// Move the cursor one word rightwards.
1193/// <li><i> Control - Shift - Left Arrow </i>
1194/// Mark text one word leftwards
1195/// <li><i> Control - Shift - Right Arrow </i>
1196/// Mark text one word rightwards
1197/// <li><i> Control-A </i>
1198/// Move the cursor to the beginning of the line
1199/// <li><i> Control-B </i>
1200/// Move the cursor one character leftwards
1201/// <li><i> Control-C </i>
1202/// Copy the marked text to the clipboard.
1203/// <li><i> Control-D </i>
1204/// Delete the character to the right of the cursor
1205/// <li><i> Control-E </i>
1206/// Move the cursor to the end of the line
1207/// <li><i> Control-F </i>
1208/// Move the cursor one character rightwards
1209/// <li><i> Control-H </i>
1210/// Delete the character to the left of the cursor
1211/// <li><i> Control-K </i>
1212/// Delete marked text if any or delete all
1213/// characters to the right of the cursor
1214/// <li><i> Control-U </i>
1215/// Delete all characters on the line
1216/// <li><i> Control-V </i>
1217/// Paste the clipboard text into line edit.
1218/// <li><i> Control-X </i>
1219/// Cut the marked text, copy to clipboard.
1220/// <li><i> Control-Y </i>
1221/// Paste the clipboard text into line edit.
1222/// </ul>
1223///
1224/// All other keys with valid ASCII codes insert themselves into the line.
1225
1227{
1228 Int_t n;
1229 char tmp[10];
1230 UInt_t keysym;
1231
1232 if (fTip && event->fType == kGKeyPress) fTip->Hide();
1233
1234 if (!IsEnabled() || event->fType != kGKeyPress) return kTRUE;
1235
1236 gVirtualX->LookupString(event, tmp, sizeof(tmp), keysym);
1237 n = strlen(tmp);
1238 Int_t unknown = 0;
1239
1240 if ((EKeySym)keysym == kKey_Enter || (EKeySym)keysym == kKey_Return) {
1241
1242 ReturnPressed(); // emit signal
1243 if (!TestBit(kNotDeleted)) return kTRUE;
1245
1246 } else if (event->fState & kKeyShiftMask && (EKeySym)keysym == kKey_Backtab) {
1247 ShiftTabPressed(); // emit signal
1249 return kTRUE;
1250
1251 } else if ((EKeySym)keysym == kKey_Tab) {
1252
1253 TabPressed(); // emit signal
1255
1256 } else if (event->fState & kKeyControlMask) { // Cntrl key modifier pressed
1257 switch ((EKeySym)keysym & ~0x20) { // treat upper and lower the same
1258 case kKey_A:
1259 Home(event->fState & kKeyShiftMask);
1260 break;
1261 case kKey_B:
1263 break;
1264 case kKey_C:
1265 CopyText();
1266 break;
1267 case kKey_D:
1268 Del();
1269 break;
1270 case kKey_E:
1271 End(event->fState & kKeyShiftMask);
1272 break;
1273 case kKey_F:
1275 break;
1276 case kKey_H:
1277 Backspace();
1278 break;
1279 case kKey_K:
1280 HasMarkedText() ? Del() : Remove();
1281 break;
1282 case kKey_U:
1283 Home();
1284 Remove();
1285 break;
1286 case kKey_V:
1287 Paste();
1288 break;
1289 case kKey_X:
1290 Cut();
1291 break;
1292 case kKey_Y:
1293 Paste();
1294 break;
1295 case kKey_Right:
1297 break;
1298 case kKey_Left:
1300 break;
1301 default:
1302 unknown++;
1303 }
1304 } else if (n && keysym <127 && keysym >=32 && // printable keys
1305 (EKeySym)keysym != kKey_Delete &&
1306 (EKeySym)keysym != kKey_Backspace) {
1307
1308 Insert(tmp);
1310
1311 } else {
1312 switch ((EKeySym)keysym) {
1313 case kKey_Down:
1314 CursorOutDown();
1315 break;
1316 case kKey_Up:
1317 CursorOutUp();
1318 break;
1319 case kKey_Left:
1321 break;
1322 case kKey_Right:
1324 break;
1325 case kKey_Backspace:
1326 Backspace();
1327 break;
1328 case kKey_Home:
1329 Home(event->fState & kKeyShiftMask);
1330 break;
1331 case kKey_End:
1332 End(event->fState & kKeyShiftMask);
1333 break;
1334 case kKey_Delete:
1335 Del();
1336 break;
1337 case kKey_Insert: // switch on/off insert mode
1339 break;
1340 default:
1341 unknown++;
1342 }
1343 }
1344
1345 UpdateOffset();
1346 fClient->NeedRedraw(this);
1347
1348 return kTRUE;
1349}
1350
1351////////////////////////////////////////////////////////////////////////////////
1352/// Handle mouse button event in text entry widget.
1353
1355{
1356 if (fTip) fTip->Hide();
1357
1358 if (!IsEnabled()) return kTRUE;
1359
1360 if (event->fType == kButtonPress) {
1361 SetFocus();
1362 if (fEchoMode == kNoEcho) return kTRUE;
1363
1364 if (event->fCode == kButton1) {
1365 Int_t offset = IsFrameDrawn() ? 4 : 0;
1366 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
1367 offset = 2;
1368 Int_t x = fOffset + offset;
1369 Int_t position = GetCharacterIndex(event->fX - x);
1371 SetCursorPosition(position);
1372 DoRedraw();
1373 } else if (event->fCode == kButton2) {
1374 if (gVirtualX->GetPrimarySelectionOwner() == kNone) {
1375 // No primary selection, so use the cut buffer
1377 } else {
1378 gVirtualX->ConvertPrimarySelection(fId, fClipboard, event->fTime);
1379 }
1380 }
1381 }
1382 if (event->fType == kButtonRelease)
1383 if (event->fCode == kButton1)
1384 CopyText();
1385
1386 return kTRUE;
1387}
1388
1389////////////////////////////////////////////////////////////////////////////////
1390/// Handle mouse crossing event.
1391
1393{
1394 if (event->fType == kEnterNotify) {
1395 if (fTip) fTip->Reset();
1396 } else {
1397 if (fTip) fTip->Hide();
1398 }
1399
1400 return kTRUE;
1401}
1402
1403////////////////////////////////////////////////////////////////////////////////
1404/// Handle mouse motion event in the text entry widget.
1405
1407{
1408 if (!IsEnabled() || (GetEchoMode() == kNoEcho)) return kTRUE;
1409
1410 Int_t offset = IsFrameDrawn() ? 4 : 0;
1411 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
1412 offset = 2;
1413 Int_t x = fOffset + offset;
1414 Int_t position = GetCharacterIndex(event->fX - x); // + 1;
1416 NewMark(position);
1417 UpdateOffset();
1418 DoRedraw();
1419 return kTRUE;
1420}
1421
1422////////////////////////////////////////////////////////////////////////////////
1423/// Handle mouse double click event in the text entry widget.
1424
1426{
1427 if (!IsEnabled()) return kTRUE;
1428
1429 Int_t offset = IsFrameDrawn() ? 4 : 0;
1430 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
1431 offset = 2;
1432 Int_t x = fOffset + offset ;
1433
1434 DoubleClicked();
1435 SetFocus();
1436 if (fEchoMode == kNoEcho) return kTRUE;
1437
1438 Int_t position = GetCharacterIndex(event->fX - x);
1439 MarkWord(position);
1440 return kTRUE;
1441}
1442
1443////////////////////////////////////////////////////////////////////////////////
1444/// Handles resize events for this widget.
1445
1447{
1449 Bool_t wasSelection = fSelectionOn;
1450 Int_t end = fEndIX, start = fStartIX;
1452 UpdateOffset();
1454 fSelectionOn = wasSelection;
1455 fEndIX = end;
1456 fStartIX = start;
1458 return kTRUE;
1459}
1460
1461////////////////////////////////////////////////////////////////////////////////
1462/// Handle focus change event in text entry widget.
1463
1465{
1466 if (!IsEnabled()) return kTRUE;
1467
1468 // check this when porting to Win32
1469 if (event->fType == kFocusIn) {
1470 fCursorOn = kTRUE;
1471 if (!fCurBlink) fCurBlink = new TBlinkTimer(this, 500);
1472 fCurBlink->Reset();
1473 gBlinkingEntry = this;
1475 } else {
1476 fCursorOn = kFALSE;
1477 // fSelectionOn = kFALSE; // "netscape location behavior"
1478 if (fCurBlink) fCurBlink->Remove();
1479 gBlinkingEntry = 0;
1480 }
1481 fClient->NeedRedraw(this);
1482 return kTRUE;
1483}
1484
1485////////////////////////////////////////////////////////////////////////////////
1486/// Handle text selection event.
1487
1489{
1490 PastePrimary((Window_t)event->fUser[0], (Atom_t)event->fUser[3], kTRUE);
1491 return kTRUE;
1492}
1493
1494////////////////////////////////////////////////////////////////////////////////
1495/// Handle selection clear event.
1496
1498{
1501 fClient->NeedRedraw(this);
1502 return kTRUE;
1503}
1504
1505////////////////////////////////////////////////////////////////////////////////
1506/// Handle request to send current clipboard contents to requestor window.
1507
1509{
1510 Event_t reply;
1511 char *buffer;
1512 Long_t len;
1513 Atom_t targets[2];
1514 Atom_t type;
1515
1516 reply.fType = kSelectionNotify;
1517 reply.fTime = event->fTime;
1518 reply.fUser[0] = event->fUser[0]; // requestor
1519 reply.fUser[1] = event->fUser[1]; // selection
1520 reply.fUser[2] = event->fUser[2]; // target
1521 reply.fUser[3] = event->fUser[3]; // property
1522
1523 targets[0] = gVirtualX->InternAtom("TARGETS", kFALSE);
1524 targets[1] = gVirtualX->InternAtom("XA_STRING", kFALSE);
1525
1526 if ((Atom_t)event->fUser[2] == targets[0]) {
1527 type = gVirtualX->InternAtom("XA_ATOM", kFALSE);
1528 gVirtualX->ChangeProperty((Window_t) event->fUser[0], (Atom_t) event->fUser[3],
1529 type, (UChar_t*) targets, (Int_t) 2);
1530
1531 gVirtualX->SendEvent((Window_t)event->fUser[0], &reply);
1532 return kTRUE;
1533 }
1534
1535 len = 0;
1537 buffer = new char[len+1];
1538 if (fgClipboardText) strlcpy (buffer, fgClipboardText->Data(), len+1);
1539
1540 gVirtualX->ChangeProperty((Window_t) event->fUser[0], (Atom_t) event->fUser[3],
1541 (Atom_t) event->fUser[2], (UChar_t*) buffer,
1542 (Int_t) len);
1543 delete [] buffer;
1544
1545 gVirtualX->SendEvent((Window_t)event->fUser[0], &reply);
1546
1547 return kTRUE;
1548}
1549
1550////////////////////////////////////////////////////////////////////////////////
1551/// Paste text from selection (either primary or cut buffer) into
1552/// text entry widget.
1553
1555{
1556 TString data;
1557 Int_t nchar;
1558
1559 if (!IsEnabled()) return;
1560
1561 gVirtualX->GetPasteBuffer(wid, property, data, nchar, del);
1562
1563 if (nchar) Insert(data.Data());
1564 fClient->NeedRedraw(this);
1565}
1566
1567////////////////////////////////////////////////////////////////////////////////
1568/// Handle cursor blink timer.
1569
1571{
1573 DoRedraw();
1574 return kTRUE;
1575}
1576
1577////////////////////////////////////////////////////////////////////////////////
1578/// Returns kTRUE if cursor is out of frame.
1579
1581{
1582 // fCursorX = fOffset + 4 + gVirtualX->TextWidth(fFontStruct,
1583 // GetDisplayText(), fCursorIX);
1584
1585 Int_t offset = IsFrameDrawn() ? 4 : 0;
1586 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
1587 offset = 2;
1588 Int_t w = GetWidth();
1589 return ((fCursorX < offset) || (fCursorX > w-offset));
1590}
1591
1592////////////////////////////////////////////////////////////////////////////////
1593/// Shift position of cursor by one character.
1594
1596{
1597 if (GetEchoMode() == kNoEcho) return;
1598
1599 TString dt = GetDisplayText();
1600 Int_t len = dt.Length();
1601 Int_t ind = fCursorIX < len-1 ? fCursorIX : len-1;
1602 Int_t charWidth = ind < 0 ? 4 : gVirtualX->TextWidth(fFontStruct, &dt[ind],1);
1603 Int_t w = GetWidth();
1604 Int_t d;
1605 Int_t offset = IsFrameDrawn() ? 4 : 0;
1606 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
1607 offset = 2;
1608
1609 if (fCursorX < offset) {
1610 fOffset += charWidth;
1611 fCursorX += charWidth;
1612 d = fCursorX;
1613
1614 if (d < offset){ // correction
1615 d -= offset;
1616 fOffset -= d;
1617 fCursorX -= d;
1618 charWidth += d;
1619 }
1620 } else if (fCursorX > w-offset) {
1621 fOffset -= charWidth;
1622 fCursorX -= charWidth;
1623 d = w - fCursorX;
1624
1625 if (d < offset) { // correction
1626 d -= offset;
1627 fOffset += d;
1628 fCursorX += d;
1629 charWidth += d;
1630 }
1631 }
1632}
1633
1634////////////////////////////////////////////////////////////////////////////////
1635/// Updates start text offset according GetAlignment() mode,
1636/// if cursor is out of frame => scroll the text.
1637/// See also SetAlignment() and ScrollByChar().
1638
1640{
1641 TString dt = GetDisplayText();
1642 Int_t textWidth = gVirtualX->TextWidth(fFontStruct, dt.Data() , dt.Length());
1643 Int_t offset = IsFrameDrawn() ? 4 : 0;
1644 if ((offset == 0) && fParent->InheritsFrom("TGComboBox"))
1645 offset = 2;
1646 Int_t w = GetWidth() - 2 * offset; // subtract border twice
1647
1648 if (fAlignment == kTextRight) fOffset = w - textWidth - 1;
1649 else if (fAlignment == kTextCenterX) fOffset = (w - textWidth)/2;
1650 else if (fAlignment == kTextLeft) fOffset = 0;
1651 if (textWidth > 0 && textWidth > w) { // may need to scroll.
1653 }
1654}
1655
1656////////////////////////////////////////////////////////////////////////////////
1657/// Set tool tip text associated with this text entry. The delay is in
1658/// milliseconds (minimum 250). To remove tool tip call method with
1659/// text = 0.
1660
1661void TGTextEntry::SetToolTipText(const char *text, Long_t delayms)
1662{
1663 if (fTip) {
1664 delete fTip;
1665 fTip = 0;
1666 }
1667
1668 if (text && strlen(text))
1669 fTip = new TGToolTip(fClient->GetDefaultRoot(), this, text, delayms);
1670}
1671
1672////////////////////////////////////////////////////////////////////////////////
1673/// Set focus to this text entry.
1674
1676{
1677 if (gBlinkingEntry && (gBlinkingEntry != this)) {
1678 gBlinkingEntry->fCurBlink->Remove();
1679 }
1680 RequestFocus();
1681}
1682
1683////////////////////////////////////////////////////////////////////////////////
1684/// Inserts text at position pos, clears the selection and moves
1685/// the cursor to the end of the line.
1686/// If necessary the text is truncated to fit MaxLength().
1687/// See also GetText(), SetText(), AppendText(), RemoveText().
1688
1689void TGTextEntry::InsertText(const char *text, Int_t pos)
1690{
1691 Int_t position = TMath::Min((Int_t)fText->GetTextLength(), pos);
1692 TString newText(GetText());
1693 newText.Insert(position, text);
1694 SetText(newText.Data());
1695}
1696
1697////////////////////////////////////////////////////////////////////////////////
1698/// Appends text to the end of text entry, clears the selection
1699/// and moves the cursor to the end of the line.
1700/// If necessary the text is truncated to fit MaxLength().
1701/// See also GetText(), InsertText(), SetText(), RemoveText().
1702
1704{
1706}
1707
1708////////////////////////////////////////////////////////////////////////////////
1709/// Removes text at the range, clears the selection and moves
1710/// the cursor to the end of the line.
1711/// See also GetText(), InsertText(), SetText(), AppendText().
1712
1714{
1715 Int_t pos = TMath::Min(start, end);
1716 Int_t len = TMath::Abs(end-start);
1717 TString newText(GetText());
1718 newText.Remove(pos, len);
1719 SetText(newText.Data());
1720}
1721
1722
1723////////////////////////////////////////////////////////////////////////////////
1724/// Changes text font.
1725/// If local is kTRUE font is changed locally.
1726
1728{
1729 if (font == fFontStruct) return;
1730
1731 FontH_t v = gVirtualX->GetFontHandle(font);
1732
1733 if (!v) return;
1734
1735 if (local) {
1736 TGGC *gc = new TGGC(fNormGC); // copy
1738 fNormGC = *gc;
1739 gc = new TGGC(fSelGC); // copy
1740 fSelGC = *gc;
1741 }
1742 fNormGC.SetFont(v);
1743 fSelGC.SetFont(v);
1744 fFontStruct = font;
1745 fClient->NeedRedraw(this);
1746}
1747
1748////////////////////////////////////////////////////////////////////////////////
1749/// Changes text font specified by name.
1750/// If local is kTRUE font is changed locally.
1751
1752void TGTextEntry::SetFont(const char *fontName, Bool_t local)
1753{
1754 TGFont *font = fClient->GetFont(fontName);
1755 if (font) {
1756 SetFont(font->GetFontStruct(), local);
1757 }
1758}
1759
1760////////////////////////////////////////////////////////////////////////////////
1761/// Changes text font specified by pointer to TGFont object.
1762/// If local is kTRUE font is changed locally.
1763
1765{
1766 if (font) {
1767 SetFont(font->GetFontStruct(), local);
1768 }
1769}
1770
1771////////////////////////////////////////////////////////////////////////////////
1772/// Changes text color.
1773/// If local is true color is changed locally.
1774
1776{
1777 if (local) {
1778 TGGC *gc = new TGGC(fNormGC); // copy
1780 fNormGC = *gc;
1781 }
1782
1783 fNormGC.SetForeground(color);
1784 fClient->NeedRedraw(this);
1785}
1786
1787////////////////////////////////////////////////////////////////////////////////
1788/// Changes text color.
1789/// If local is true color is changed locally.
1790
1792{
1793 if (color) {
1794 SetTextColor(color->GetPixel(), local);
1795 }
1796}
1797
1798////////////////////////////////////////////////////////////////////////////////
1799/// Return default font structure in use.
1800
1802{
1803 if (!fgDefaultFont)
1804 fgDefaultFont = gClient->GetResourcePool()->GetDefaultFont();
1805 return fgDefaultFont->GetFontStruct();
1806}
1807
1808////////////////////////////////////////////////////////////////////////////////
1809/// Return default graphics context.
1810
1812{
1813 if (!fgDefaultGC)
1814 fgDefaultGC = gClient->GetResourcePool()->GetFrameGC();
1815 return *fgDefaultGC;
1816}
1817
1818////////////////////////////////////////////////////////////////////////////////
1819/// Return selection graphics context.
1820
1822{
1824 fgDefaultSelectedGC = gClient->GetResourcePool()->GetSelectedGC();
1825 return *fgDefaultSelectedGC;
1826}
1827
1828////////////////////////////////////////////////////////////////////////////////
1829/// Return graphics context for highlighted frame background.
1830
1832{
1834 fgDefaultSelectedBackgroundGC = gClient->GetResourcePool()->GetSelectedBckgndGC();
1836}
1837
1838////////////////////////////////////////////////////////////////////////////////
1839/// Save a text entry widget as a C++ statement(s) on output stream out.
1840
1841void TGTextEntry::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1842{
1843 char quote = '"';
1844
1845 // font + GC
1846 option = GetName()+5; // unique digit id of the name
1847 TString parGC, parFont;
1848 // coverity[returned_null]
1849 // coverity[dereference]
1850 parFont.Form("%s::GetDefaultFontStruct()",IsA()->GetName());
1851 // coverity[returned_null]
1852 // coverity[dereference]
1853 parGC.Form("%s::GetDefaultGC()()",IsA()->GetName());
1854
1855 if ((GetDefaultFontStruct() != fFontStruct) || (GetDefaultGC()() != fNormGC.GetGC())) {
1856 TGFont *ufont = gClient->GetResourcePool()->GetFontPool()->FindFont(fFontStruct);
1857 if (ufont) {
1858 ufont->SavePrimitive(out, option);
1859 parFont.Form("ufont->GetFontStruct()");
1860 }
1861
1862 TGGC *userGC = gClient->GetResourcePool()->GetGCPool()->FindGC(fNormGC.GetGC());
1863 if (userGC) {
1864 userGC->SavePrimitive(out, option);
1865 parGC.Form("uGC->GetGC()");
1866 }
1867 }
1868
1869 if (fBackground != GetWhitePixel()) SaveUserColor(out, option);
1870
1871 out << " TGTextEntry *";
1872 out << GetName() << " = new TGTextEntry(" << fParent->GetName()
1873 << ", new TGTextBuffer(" << GetBuffer()->GetBufferLength() << ")";
1874
1875 if (fBackground == GetWhitePixel()) {
1876 if (GetOptions() == (kSunkenFrame | kDoubleBorder)) {
1878 if (fNormGC() == GetDefaultGC()()) {
1879 if (fWidgetId == -1) {
1880 out <<");" << std::endl;
1881 } else {
1882 out << "," << fWidgetId << ");" << std::endl;
1883 }
1884 } else {
1885 out << "," << fWidgetId << "," << parGC.Data() << ");" << std::endl;
1886 }
1887 } else {
1888 out << "," << fWidgetId << "," << parGC.Data() << "," << parFont.Data()
1889 <<");" << std::endl;
1890 }
1891 } else {
1892 out << "," << fWidgetId << "," << parGC.Data() << "," << parFont.Data()
1893 << "," << GetOptionString() << ");" << std::endl;
1894 }
1895 } else {
1896 out << "," << fWidgetId << "," << parGC.Data() << "," << parFont.Data()
1897 << "," << GetOptionString() << ",ucolor);" << std::endl;
1898 }
1899 if (option && strstr(option, "keep_names"))
1900 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
1901
1902 out << " " << GetName() << "->SetMaxLength(" << GetMaxLength() << ");" << std::endl;
1903
1904 out << " " << GetName() << "->SetAlignment(";
1905
1906 if (fAlignment == kTextLeft)
1907 out << "kTextLeft);" << std::endl;
1908
1909 if (fAlignment == kTextRight)
1910 out << "kTextRight);" << std::endl;
1911
1912 if (fAlignment == kTextCenterX)
1913 out << "kTextCenterX);" << std::endl;
1914
1915 out << " " << GetName() << "->SetText(" << quote << GetText() << quote
1916 << ");" << std::endl;
1917
1918 out << " " << GetName() << "->Resize("<< GetWidth() << "," << GetName()
1919 << "->GetDefaultHeight());" << std::endl;
1920
1921 if ((fDefWidth > 0) || (fDefHeight > 0)) {
1922 out << " " << GetName() << "->SetDefaultSize(";
1923 out << fDefWidth << "," << fDefHeight << ");" << std::endl;
1924 }
1925
1926 if (fTip) {
1927 TString tiptext = fTip->GetText()->GetString();
1928 tiptext.ReplaceAll("\n", "\\n");
1929 out << " ";
1930 out << GetName() << "->SetToolTipText(" << quote
1931 << tiptext << quote << ");" << std::endl;
1932 }
1933}
@ kGKeyPress
Definition: GuiTypes.h:59
@ kButtonRelease
Definition: GuiTypes.h:59
@ kSelectionNotify
Definition: GuiTypes.h:62
@ kButtonPress
Definition: GuiTypes.h:59
@ kFocusIn
Definition: GuiTypes.h:60
@ kEnterNotify
Definition: GuiTypes.h:60
const Mask_t kWABitGravity
Definition: GuiTypes.h:143
const Mask_t kButtonMotionMask
Definition: GuiTypes.h:163
const Mask_t kFocusChangeMask
Definition: GuiTypes.h:168
const Mask_t kButtonPressMask
Definition: GuiTypes.h:160
Handle_t FontH_t
Definition: GuiTypes.h:34
const Mask_t kWAWinGravity
Definition: GuiTypes.h:144
const Mask_t kAnyModifier
Definition: GuiTypes.h:209
const Mask_t kKeyPressMask
Definition: GuiTypes.h:158
const Mask_t kKeyShiftMask
Definition: GuiTypes.h:194
Handle_t Atom_t
Definition: GuiTypes.h:36
const Handle_t kNone
Definition: GuiTypes.h:87
const Mask_t kKeyControlMask
Definition: GuiTypes.h:196
const Mask_t kLeaveWindowMask
Definition: GuiTypes.h:167
const Mask_t kStructureNotifyMask
Definition: GuiTypes.h:165
Handle_t GContext_t
Definition: GuiTypes.h:37
const Mask_t kButtonReleaseMask
Definition: GuiTypes.h:161
const Mask_t kEnterWindowMask
Definition: GuiTypes.h:166
Handle_t FontStruct_t
Definition: GuiTypes.h:38
ULong_t Pixel_t
Definition: GuiTypes.h:39
@ kButton2
Definition: GuiTypes.h:213
@ kButton1
Definition: GuiTypes.h:213
@ kAnyButton
Definition: GuiTypes.h:213
Handle_t Window_t
Definition: GuiTypes.h:28
const Atom_t kCutBuffer
Definition: GuiTypes.h:367
EKeySym
Definition: KeySymbols.h:25
@ kKey_Right
Definition: KeySymbols.h:42
@ kKey_Down
Definition: KeySymbols.h:43
@ kKey_Y
Definition: KeySymbols.h:150
@ kKey_B
Definition: KeySymbols.h:127
@ kKey_F
Definition: KeySymbols.h:131
@ kKey_Up
Definition: KeySymbols.h:41
@ kKey_Return
Definition: KeySymbols.h:30
@ kKey_C
Definition: KeySymbols.h:128
@ kKey_Delete
Definition: KeySymbols.h:33
@ kKey_A
Definition: KeySymbols.h:126
@ kKey_Left
Definition: KeySymbols.h:40
@ kKey_E
Definition: KeySymbols.h:130
@ kKey_Backspace
Definition: KeySymbols.h:29
@ kKey_D
Definition: KeySymbols.h:129
@ kKey_X
Definition: KeySymbols.h:149
@ kKey_Home
Definition: KeySymbols.h:38
@ kKey_U
Definition: KeySymbols.h:146
@ kKey_Insert
Definition: KeySymbols.h:32
@ kKey_Enter
Definition: KeySymbols.h:31
@ kKey_Tab
Definition: KeySymbols.h:27
@ kKey_H
Definition: KeySymbols.h:133
@ kKey_Backtab
Definition: KeySymbols.h:28
@ kKey_End
Definition: KeySymbols.h:39
@ kKey_K
Definition: KeySymbols.h:136
@ kKey_V
Definition: KeySymbols.h:147
#define d(i)
Definition: RSha256.hxx:102
#define h(i)
Definition: RSha256.hxx:106
static RooMathCoreReg dummy
int Int_t
Definition: RtypesCore.h:41
unsigned char UChar_t
Definition: RtypesCore.h:34
unsigned int UInt_t
Definition: RtypesCore.h:42
const Bool_t kFALSE
Definition: RtypesCore.h:88
unsigned long ULong_t
Definition: RtypesCore.h:51
long Long_t
Definition: RtypesCore.h:50
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:87
const char Option_t
Definition: RtypesCore.h:62
#define ClassImp(name)
Definition: Rtypes.h:365
#define gClient
Definition: TGClient.h:166
@ kRaisedFrame
Definition: TGFrame.h:62
@ kSunkenFrame
Definition: TGFrame.h:61
@ kDoubleBorder
Definition: TGFrame.h:63
@ kFixedWidth
Definition: TGFrame.h:65
@ kFixedHeight
Definition: TGFrame.h:67
@ kOwnBackground
Definition: TGFrame.h:69
TGTextEntry * gBlinkingEntry
ETextJustification
Definition: TGWidget.h:33
@ kTextCenterX
Definition: TGWidget.h:36
@ kTextLeft
Definition: TGWidget.h:34
@ kTextRight
Definition: TGWidget.h:35
@ kWidgetIsEnabled
Definition: TGWidget.h:48
@ kWidgetWantFocus
Definition: TGWidget.h:46
XFontStruct * id
Definition: TGX11.cxx:108
int type
Definition: TGX11.cxx:120
R__EXTERN TSystem * gSystem
Definition: TSystem.h:560
#define gVirtualX
Definition: TVirtualX.h:345
Int_t MK_MSG(EWidgetMessageTypes msg, EWidgetMessageTypes submsg)
@ kTE_TEXTCHANGED
@ kTE_ENTER
@ kTE_TAB
@ kC_TEXTENTRY
The color creation and management class.
Definition: TColor.h:19
ULong_t GetPixel() const
Return pixel value corresponding to this color.
Definition: TColor.cxx:1434
const TGWindow * GetDefaultRoot() const
Returns the root (i.e.
Definition: TGClient.cxx:234
void ProcessLine(TString cmd, Long_t msg, Long_t parm1, Long_t parm2)
Execute string "cmd" via the interpreter.
Definition: TGClient.cxx:913
TGFont * GetFont(const char *font, Bool_t fixedDefault=kTRUE)
Get a font from the font pool.
Definition: TGClient.cxx:348
const TGResourcePool * GetResourcePool() const
Definition: TGClient.h:133
void NeedRedraw(TGWindow *w, Bool_t force=kFALSE)
Set redraw flags.
Definition: TGClient.cxx:372
Definition: TGFont.h:149
FontStruct_t GetFontStruct() const
Definition: TGFont.h:193
virtual void SavePrimitive(std::ostream &out, Option_t *="")
Save the used font as a C++ statement(s) on output stream out.
Definition: TGFont.cxx:1869
void AddInput(UInt_t emask)
Add events specified in the emask to the events the frame should handle.
Definition: TGFrame.cxx:321
static const TGGC & GetBlackGC()
Get black graphics context.
Definition: TGFrame.cxx:717
UInt_t fOptions
Definition: TGFrame.h:141
virtual Bool_t HandleConfigureNotify(Event_t *event)
This event is generated when the frame is resized.
Definition: TGFrame.cxx:425
static Pixel_t GetWhitePixel()
Get white pixel value.
Definition: TGFrame.cxx:691
UInt_t fHeight
Definition: TGFrame.h:135
virtual void DrawBorder()
Draw frame border.
Definition: TGFrame.cxx:403
Int_t fBorderWidth
Definition: TGFrame.h:140
static const TGGC & GetHilightGC()
Get highlight color graphics context.
Definition: TGFrame.cxx:737
virtual void SetBackgroundColor(Pixel_t back)
Set background color (override from TGWindow base class).
Definition: TGFrame.cxx:294
virtual void SendMessage(const TGWindow *w, Long_t msg, Long_t parm1, Long_t parm2)
Send message (i.e.
Definition: TGFrame.cxx:627
static Pixel_t GetDefaultFrameBackground()
Get default frame background.
Definition: TGFrame.cxx:665
virtual UInt_t GetOptions() const
Definition: TGFrame.h:244
TString GetOptionString() const
Returns a frame option string - used in SavePrimitive().
Definition: TGFrame.cxx:2462
static const TGGC & GetShadowGC()
Get shadow color graphics context.
Definition: TGFrame.cxx:747
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition: TGFrame.cxx:587
UInt_t fWidth
Definition: TGFrame.h:134
static Pixel_t fgWhitePixel
Definition: TGFrame.h:150
UInt_t GetWidth() const
Definition: TGFrame.h:271
void SaveUserColor(std::ostream &out, Option_t *)
Save a user color in a C++ macro file - used in SavePrimitive().
Definition: TGFrame.cxx:2435
Pixel_t fBackground
Definition: TGFrame.h:142
static const TGGC & GetBckgndGC()
Get background color graphics context.
Definition: TGFrame.cxx:757
TGGC * FindGC(const TGGC *gc)
Find graphics context. Returns 0 in case gc is not found.
Definition: TGGC.cxx:949
Definition: TGGC.h:31
GContext_t GetGC() const
Definition: TGGC.h:50
void SavePrimitive(std::ostream &out, Option_t *option="")
Save graphics context info as a C++ statement(s) on output stream out.
Definition: TGGC.cxx:625
void SetFont(FontH_t v)
Set font.
Definition: TGGC.cxx:409
void SetForeground(Pixel_t v)
Set foreground color.
Definition: TGGC.cxx:276
TGClient * fClient
Definition: TGObject.h:37
Handle_t GetId() const
Definition: TGObject.h:47
Handle_t fId
Definition: TGObject.h:36
Cursor_t GetTextCursor() const
Atom_t GetClipboard() const
TGGCPool * GetGCPool() const
const char * GetString() const
Definition: TGString.h:40
UInt_t GetBufferLength() const
Definition: TGTextBuffer.h:46
void AddText(Int_t pos, const char *text)
Definition: TGTextBuffer.h:49
const char * GetString() const
Definition: TGTextBuffer.h:47
void RemoveText(Int_t pos, Int_t length)
Definition: TGTextBuffer.h:51
UInt_t GetTextLength() const
Definition: TGTextBuffer.h:45
void Clear()
Definition: TGTextBuffer.h:52
virtual void SetState(Bool_t state)
Set state of widget. If kTRUE=enabled, kFALSE=disabled.
Int_t fOffset
Definition: TGTextEntry.h:52
virtual void SetFocus()
Set focus to this text entry.
virtual Bool_t HandleKey(Event_t *event)
The key press event handler converts a key press to some line editor action.
void CursorLeft(Bool_t mark=kFALSE, Int_t steps=1)
Moves the cursor leftwards one or more characters.
Bool_t fFrameDrawn
Definition: TGTextEntry.h:65
void CursorRight(Bool_t mark=kFALSE, Int_t steps=1)
Moves the cursor rightwards one or more characters.
Bool_t HasMarkedText() const
Definition: TGTextEntry.h:137
Int_t fStartIX
Definition: TGTextEntry.h:49
virtual void SetEchoMode(EEchoMode mode=kNormal)
The echo modes available are:
virtual void SetDefaultSize(UInt_t w, UInt_t h)
Set the default / minimal size of the widget.
UInt_t fDefHeight
Definition: TGTextEntry.h:71
virtual void SetMaxLength(Int_t maxlen)
Set the maximum length of the text in the editor.
EEchoMode fEchoMode
Definition: TGTextEntry.h:66
static FontStruct_t GetDefaultFontStruct()
Return default font structure in use.
virtual void RemoveText(Int_t start, Int_t end)
Removes text at the range, clears the selection and moves the cursor to the end of the line.
Int_t fStartX
Definition: TGTextEntry.h:47
virtual Bool_t HandleSelectionRequest(Event_t *event)
Handle request to send current clipboard contents to requestor window.
TGTextBuffer * fText
Definition: TGTextEntry.h:46
TString GetDisplayText() const
Returns the text that's currently displayed.
UInt_t fDefWidth
Definition: TGTextEntry.h:70
virtual ~TGTextEntry()
Delete a text entry widget.
virtual Bool_t HandleConfigureNotify(Event_t *event)
Handles resize events for this widget.
TGGC fNormGC
Definition: TGTextEntry.h:57
Bool_t fHasOwnFont
Definition: TGTextEntry.h:69
void Deselect()
Deselects all text (i.e.
TBlinkTimer * fCurBlink
Definition: TGTextEntry.h:61
void CopyText() const
Copies the marked text to the clipboard, if there is any and GetEchoMode() is kNormal.
virtual Bool_t HandleCrossing(Event_t *event)
Handle mouse crossing event.
static TString * fgClipboardText
Definition: TGTextEntry.h:83
virtual void UpdateOffset()
Updates start text offset according GetAlignment() mode, if cursor is out of frame => scroll the text...
TGTextBuffer * GetBuffer() const
Definition: TGTextEntry.h:127
const char * GetText() const
Definition: TGTextEntry.h:134
virtual void TabPressed()
This signal is emitted when the <TAB> key is pressed.
void CursorWordBackward(Bool_t mark=kFALSE)
Moves the cursor one word to the left.
virtual void SetCursorPosition(Int_t pos)
Set the cursor position to newPos.
void Backspace()
Deletes the character on the left side of the text cursor and moves the cursor one position to the le...
TString GetMarkedText() const
Returns the text marked by the user (e.g.
virtual Bool_t HandleFocusChange(Event_t *event)
Handle focus change event in text entry widget.
void Del()
Deletes the character on the right side of the text cursor.
Bool_t fCursorOn
Definition: TGTextEntry.h:55
static const TGFont * fgDefaultFont
Definition: TGTextEntry.h:84
TGToolTip * fTip
Definition: TGTextEntry.h:62
virtual Bool_t HandleTimer(TTimer *t)
Handle cursor blink timer.
void NewMark(Int_t pos)
New character mark at position pos.
Bool_t IsFrameDrawn() const
Definition: TGTextEntry.h:143
TGTextEntry(const TGTextEntry &)
virtual Bool_t HandleMotion(Event_t *event)
Handle mouse motion event in the text entry widget.
static const TGGC & GetDefaultSelectedBackgroundGC()
Return graphics context for highlighted frame background.
virtual void AppendText(const char *text)
Appends text to the end of text entry, clears the selection and moves the cursor to the end of the li...
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a text entry widget as a C++ statement(s) on output stream out.
virtual void SelectAll()
Selects all text (i.e.
virtual void CursorOutRight()
This signal is emitted when cursor is going out of right side.
virtual Bool_t HandleSelectionClear(Event_t *event)
Handle selection clear event.
void Paste()
Inserts text at the cursor position, deleting any previous marked text.
virtual void SetFrameDrawn(Bool_t flag=kTRUE)
Sets the text entry to draw itself inside a two-pixel frame if enable is kTRUE, and to draw itself wi...
EInsertMode fInsertMode
Definition: TGTextEntry.h:67
virtual void SetAlignment(ETextJustification mode=kTextLeft)
Sets the alignment of the text entry.
Int_t fEndIX
Definition: TGTextEntry.h:50
Atom_t fClipboard
Definition: TGTextEntry.h:60
virtual void ScrollByChar()
Shift position of cursor by one character.
Int_t GetCharacterIndex(Int_t xcoord)
Returns the index of the character to whose left edge xcoord is closest.
EInsertMode GetInsertMode() const
Definition: TGTextEntry.h:131
virtual void ShiftTabPressed()
This signal is emitted when SHIFT and TAB keys are pressed.
Int_t fEndX
Definition: TGTextEntry.h:48
virtual void ReturnPressed()
This signal is emitted when the return or enter key is pressed.
virtual void TextChanged(const char *text=0)
This signal is emitted every time the text has changed.
static const TGGC * fgDefaultSelectedGC
Definition: TGTextEntry.h:85
GContext_t fSelbackGC
Definition: TGTextEntry.h:59
virtual void SetToolTipText(const char *text, Long_t delayms=500)
Set tool tip text associated with this text entry.
EEchoMode GetEchoMode() const
Definition: TGTextEntry.h:130
ETextJustification fAlignment
Definition: TGTextEntry.h:68
Bool_t fSelectionOn
Definition: TGTextEntry.h:51
virtual void SetTextColor(Pixel_t color, Bool_t local=kTRUE)
Changes text color.
virtual void SetText(const char *text, Bool_t emit=kTRUE)
Sets text entry to text, clears the selection and moves the cursor to the end of the line.
FontStruct_t fFontStruct
Definition: TGTextEntry.h:56
virtual void CursorOutLeft()
This signal is emitted when cursor is going out of left side.
virtual TGDimension GetDefaultSize() const
Return the default / minimal size of the widget.
Int_t MaxMark() const
Definition: TGTextEntry.h:147
void Clear(Option_t *option="")
Clears up the text entry.
void Cut()
Copies the marked text to the clipboard and deletes it, if there is any.
static const TGGC * fgDefaultGC
Definition: TGTextEntry.h:87
void End(Bool_t mark=kFALSE)
Moves the text cursor to the right end of the line.
virtual void InsertText(const char *text, Int_t pos)
Inserts text at position pos, clears the selection and moves the cursor to the end of the line.
virtual void CursorOutDown()
This signal is emitted when cursor is going out of bottom side.
virtual void SetFont(TGFont *font, Bool_t local=kTRUE)
Changes text font specified by pointer to TGFont object.
virtual Bool_t IsCursorOutOfFrame()
Returns kTRUE if cursor is out of frame.
virtual void SetInsertMode(EInsertMode mode=kInsert)
Sets the mode how characters are entered to the text entry.
void CursorWordForward(Bool_t mark=kFALSE)
Moves the cursor one word to the right.
virtual void Insert(const char *)
Removes any currently selected text, inserts newText, sets it as the new contents of the text entry.
virtual void Init()
Do default initialization.
virtual Bool_t HandleSelection(Event_t *event)
Handle text selection event.
Bool_t fEdited
Definition: TGTextEntry.h:64
Int_t MinMark() const
Definition: TGTextEntry.h:148
void MarkWord(Int_t pos)
Marks the word nearest to cursor position.
void Home(Bool_t mark=kFALSE)
Moves the text cursor to the left end of the line.
virtual Bool_t HandleDoubleClick(Event_t *event)
Handle mouse double click event in the text entry widget.
virtual Bool_t HandleButton(Event_t *event)
Handle mouse button event in text entry widget.
virtual void DoubleClicked()
This signal is emitted when widget is double clicked.
virtual void PastePrimary(Window_t wid, Atom_t property, Bool_t del)
Paste text from selection (either primary or cut buffer) into text entry widget.
Int_t fCursorX
Definition: TGTextEntry.h:53
static const TGGC & GetDefaultSelectedGC()
Return selection graphics context.
virtual void CursorOutUp()
This signal is emitted when cursor is going out of upper side.
static const TGGC & GetDefaultGC()
Return default graphics context.
Int_t GetMaxLength() const
Definition: TGTextEntry.h:133
Int_t fMaxLen
Definition: TGTextEntry.h:63
Int_t fCursorIX
Definition: TGTextEntry.h:54
virtual void DoRedraw()
Draw the text entry widget.
virtual void DrawBorder()
Draw the border of the text entry widget.
void Remove()
Deletes all characters on the right side of the cursor.
static const TGGC * fgDefaultSelectedBackgroundGC
Definition: TGTextEntry.h:86
void Hide()
Hide tool tip window.
Definition: TGToolTip.cxx:246
const TGString * GetText() const
Get the tool tip text.
Definition: TGToolTip.cxx:426
void Reset()
Reset tool tip popup delay timer.
Definition: TGToolTip.cxx:259
Int_t fWidgetId
Definition: TGWidget.h:58
TString fCommand
Definition: TGWidget.h:61
Int_t ClearFlags(Int_t flags)
Definition: TGWidget.h:71
Int_t fWidgetFlags
Definition: TGWidget.h:59
Int_t SetFlags(Int_t flags)
Definition: TGWidget.h:70
const TGWindow * fMsgWindow
Definition: TGWidget.h:60
Bool_t IsEnabled() const
Definition: TGWidget.h:81
virtual void SetWindowName(const char *name=0)
Set window name.
Definition: TGWindow.cxx:118
virtual const char * GetName() const
Return unique name, used in SavePrimitive methods.
Definition: TGWindow.cxx:221
const TGWindow * fParent
Definition: TGWindow.h:37
@ kEditDisableHeight
Definition: TGWindow.h:64
virtual void RequestFocus()
Definition: TGWindow.h:98
UInt_t fEditDisabled
Definition: TGWindow.h:41
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
@ kNotDeleted
object has not been deleted
Definition: TObject.h:78
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:443
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
Basic string class.
Definition: TString.h:131
Ssiz_t Length() const
Definition: TString.h:405
TString & Insert(Ssiz_t pos, const char *s)
Definition: TString.h:644
const char * Data() const
Definition: TString.h:364
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:687
TString & Prepend(const char *cs)
Definition: TString.h:656
Bool_t IsNull() const
Definition: TString.h:402
TString & Remove(Ssiz_t pos)
Definition: TString.h:668
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2289
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
Definition: TSystem.cxx:481
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:51
virtual Bool_t Notify()
Notify when timer times out.
Definition: TTimer.cxx:143
TTimer(const TTimer &)
TText * text
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
static constexpr double ms
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
EGEventType fType
Definition: GuiTypes.h:174
UInt_t fState
Definition: GuiTypes.h:180
Int_t fX
Definition: GuiTypes.h:177
Long_t fUser[5]
Definition: GuiTypes.h:186
Time_t fTime
Definition: GuiTypes.h:176
UInt_t fCode
Definition: GuiTypes.h:179
#define mark(osub)
Definition: triangle.c:1206
void ws()
Definition: ws.C:66