Logo ROOT  
Reference Guide
TGMenu.h
Go to the documentation of this file.
1// @(#)root/gui:$Id$
2// Author: Fons Rademakers 09/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#ifndef ROOT_TGMenu
13#define ROOT_TGMenu
14
15
16//////////////////////////////////////////////////////////////////////////
17// //
18// TGMenuBar, TGPopupMenu, TGMenuTitle and TGMenuEntry //
19// //
20// This header contains all different menu classes. //
21// //
22// Selecting a menu item will generate the event: //
23// kC_COMMAND, kCM_MENU, menu id, user data. //
24// //
25//////////////////////////////////////////////////////////////////////////
26
27#include "TGFrame.h"
28#include "TGString.h"
29#include "TGPicture.h"
30#include "TGWidget.h"
31
32//--- Menu entry status mask
33
42};
43
44//--- Menu entry types
45
51};
52
53
54class TGPopupMenu;
55class TGMenuBar;
56class TGMenuTitle;
57class TTimer;
58class TGSplitButton;
59
60//////////////////////////////////////////////////////////////////////////
61// //
62// TGMenuEntry //
63// //
64// This class contains all information about a menu entry. //
65// It is a fully protected class used internally by TGPopupMenu. //
66// //
67//////////////////////////////////////////////////////////////////////////
68
69class TGMenuEntry : public TObject {
70
71friend class TGPopupMenu;
72friend class TGMenuBar;
73
74protected:
75 Int_t fEntryId; // the entry id (used for event processing)
76 void *fUserData; // pointer to user data structure
77 EMenuEntryType fType; // type of entry
78 Int_t fStatus; // entry status (OR of EMenuEntryState)
79 Int_t fEx, fEy; // position of entry
80 UInt_t fEw, fEh; // width and height of entry
81 TGHotString *fLabel; // menu entry label
82 TGString *fShortcut; // menu entry shortcut
83 const TGPicture *fPic; // menu entry icon
84 TGPopupMenu *fPopup; // pointer to popup menu (in case of cascading menus)
85
86private:
87 TGMenuEntry(const TGMenuEntry&); // not implemented
88 TGMenuEntry& operator=(const TGMenuEntry&); // not implemented
89
90public:
92 fEx(0), fEy(0), fEw(0), fEh(0), fLabel(0), fShortcut(0), fPic(0), fPopup(0) { }
93 virtual ~TGMenuEntry() { if (fLabel) delete fLabel; if (fShortcut) delete fShortcut; }
94
95 Int_t GetEntryId() const { return fEntryId; }
96 const char *GetName() const { return fLabel ? fLabel->GetString() : 0; }
97 const char *GetShortcutText() const { return fShortcut ? fShortcut->GetString() : 0; }
98 virtual Int_t GetStatus() const { return fStatus; }
99 EMenuEntryType GetType() const { return fType; }
100 TGPopupMenu *GetPopup() const { return fPopup; }
101 TGHotString *GetLabel() const { return fLabel; }
102 TGString *GetShortcut() const { return fShortcut; }
103 Int_t GetEx() const { return fEx; }
104 Int_t GetEy() const { return fEy; }
105 UInt_t GetEw() const { return fEw; }
106 UInt_t GetEh() const { return fEh; }
107 const TGPicture *GetPic() const { return fPic; }
108 void *GetUserData() const { return fUserData; }
109
110 ClassDef(TGMenuEntry,0); // Menu entry class
111};
112
113
114//////////////////////////////////////////////////////////////////////////
115// //
116// TGPopupMenu //
117// //
118// This class creates a popup menu object. Popup menu's are attached //
119// to TGMenuBar objects. //
120// //
121//////////////////////////////////////////////////////////////////////////
122
123class TGPopupMenu : public TGFrame {
124
125friend class TGMenuTitle;
126friend class TGMenuBar;
127friend class TGSplitButton;
128
129protected:
130 TList *fEntryList; // list of menu entries
131 TGMenuEntry *fCurrent; // currently selected menu entry
132 Bool_t fStick; // stick mode (popup menu stays sticked on screen)
133 Bool_t fHasGrab; // true if menu has grabbed pointer
134 Bool_t fPoppedUp; // true if menu is currently popped up
135 UInt_t fXl; // Max width of all menu entries
136 UInt_t fMenuWidth; // width of popup menu
137 UInt_t fMenuHeight; // height of popup menu
138 TTimer *fDelay; // delay before poping up cascading menu
139 GContext_t fNormGC; // normal drawing graphics context
140 GContext_t fSelGC; // graphics context for drawing selections
141 GContext_t fSelbackGC; // graphics context for drawing selection background
142 FontStruct_t fFontStruct; // font to draw menu entries
143 FontStruct_t fHifontStruct; // font to draw highlighted entries
144 Cursor_t fDefaultCursor; // right pointing cursor
145 const TGWindow *fMsgWindow; // window which handles menu events
146 TGMenuBar *fMenuBar; // menu bar (if any)
147 TGSplitButton *fSplitButton; // split button (if any)
148 UInt_t fEntrySep; // separation distance between ebtris
149
150 static const TGFont *fgDefaultFont;
151 static const TGFont *fgHilightFont;
152 static const TGGC *fgDefaultGC;
155
159 virtual void DoRedraw();
160 virtual void DrawEntry(TGMenuEntry *entry);
161 virtual void Reposition();
162
165 static const TGGC &GetDefaultGC();
166 static const TGGC &GetDefaultSelectedGC();
167 static const TGGC &GetDefaultSelectedBackgroundGC();
168
169private:
170 TGPopupMenu(const TGPopupMenu&); // not implemented
171 TGPopupMenu& operator=(const TGPopupMenu&); // not implemented
172
173public:
174 TGPopupMenu(const TGWindow *p = 0, UInt_t w = 10, UInt_t h = 10,
175 UInt_t options = 0);
176 virtual ~TGPopupMenu();
177
178 virtual void AddEntry(TGHotString *s, Int_t id, void *ud = 0,
179 const TGPicture *p = 0, TGMenuEntry *before = 0);
180 virtual void AddEntry(const char *s, Int_t id, void *ud = 0,
181 const TGPicture *p = 0, TGMenuEntry *before = 0);
182 virtual void AddSeparator(TGMenuEntry *before = 0);
183 virtual void AddLabel(TGHotString *s, const TGPicture *p = 0,
184 TGMenuEntry *before = 0);
185 virtual void AddLabel(const char *s, const TGPicture *p = 0,
186 TGMenuEntry *before = 0);
187 virtual void AddPopup(TGHotString *s, TGPopupMenu *popup,
188 TGMenuEntry *before = 0, const TGPicture *p = 0);
189 virtual void AddPopup(const char *s, TGPopupMenu *popup,
190 TGMenuEntry *before = 0, const TGPicture *p = 0);
191 virtual void EnableEntry(Int_t id);
192 virtual void DisableEntry(Int_t id);
193 virtual Bool_t IsEntryEnabled(Int_t id);
194 virtual void HideEntry(Int_t id);
195 virtual Bool_t IsEntryHidden(Int_t id);
196 virtual void DefaultEntry(Int_t id);
197 virtual void CheckEntry(Int_t id);
198 virtual void CheckEntryByData(void *user_data);
199 virtual void UnCheckEntry(Int_t id);
200 virtual void UnCheckEntryByData(void *user_data);
201 virtual void UnCheckEntries();
202 virtual Bool_t IsEntryChecked(Int_t id);
203 virtual void RCheckEntry(Int_t id, Int_t IDfirst, Int_t IDlast);
204 virtual Bool_t IsEntryRChecked(Int_t id);
205 virtual void PlaceMenu(Int_t x, Int_t y, Bool_t stick_mode,
206 Bool_t grab_pointer);
207 virtual Int_t EndMenu(void *&userData);
208 virtual void DeleteEntry(Int_t id);
209 virtual void DeleteEntry(TGMenuEntry *entry);
210 virtual TGMenuEntry *GetEntry(Int_t id);
211 virtual TGMenuEntry *GetCurrent() const { return fCurrent; }
212 virtual TGMenuEntry *GetEntry(const char *s);
213 const TList *GetListOfEntries() const { return fEntryList; }
214 virtual void DrawBorder();
215 virtual Bool_t HandleButton(Event_t *event);
216 virtual Bool_t HandleMotion(Event_t *event);
217 virtual Bool_t HandleCrossing(Event_t *event);
218 virtual Bool_t HandleTimer(TTimer *t);
219 virtual void Associate(const TGWindow *w) { fMsgWindow = w; }
220 virtual void SetMenuBar(TGMenuBar *bar) { fMenuBar = bar; }
221 TGMenuBar *GetMenuBar() const { return fMenuBar; }
222 virtual void Activate(Bool_t) { }
223 virtual void Activate(TGMenuEntry *entry);
224 virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
225
226 UInt_t GetEntrySep() const { return fEntrySep; }
227 virtual void SetEntrySep(UInt_t sep) { fEntrySep = sep; }
228
229 virtual void PoppedUp() { Emit("PoppedUp()"); } // *SIGNAL*
230 virtual void PoppedDown() { Emit("PoppedDown()"); } // *SIGNAL*
231 virtual void Highlighted(Int_t id) { Emit("Highlighted(Int_t)", id); } // *SIGNAL*
232 virtual void Activated(Int_t id) { Emit("Activated(Int_t)", id); } // *SIGNAL*
233
234 ClassDef(TGPopupMenu,0) // Popup menu
235};
236
237
238//////////////////////////////////////////////////////////////////////////
239// //
240// TGMenuTitle //
241// //
242// This class creates a menu title. A menu title is a frame //
243// to which a popup menu can be attached. Menu titles are automatically //
244// created when adding a popup menu to a menubar. //
245// //
246//////////////////////////////////////////////////////////////////////////
247
248class TGMenuTitle : public TGFrame {
249
250protected:
251 TGPopupMenu *fMenu; // attached popup menu
252 TGHotString *fLabel; // menu title
253 Int_t fTitleId; // id of selected menu item
254 void *fTitleData; // user data associated with selected item
255 Bool_t fState; // menu title state (active/not active)
256 Int_t fHkeycode; // hot key code
258 Pixel_t fTextColor; // text color
259 GContext_t fNormGC, fSelGC; // normal and selection graphics contexts
260
261 virtual void DoRedraw();
262
263 static const TGFont *fgDefaultFont;
265 static const TGGC *fgDefaultGC;
266
267private:
268 TGMenuTitle(const TGMenuTitle&); // not implemented
269 TGMenuTitle& operator=(const TGMenuTitle&); // not implemented
270
271public:
273 static const TGGC &GetDefaultSelectedGC();
274 static const TGGC &GetDefaultGC();
275
276 TGMenuTitle(const TGWindow *p = 0, TGHotString *s = 0, TGPopupMenu *menu = 0,
277 GContext_t norm = GetDefaultGC()(),
279 UInt_t options = 0);
280 virtual ~TGMenuTitle() { if (fLabel) delete fLabel; }
281
282 Pixel_t GetTextColor() const { return fTextColor; }
283 void SetTextColor(Pixel_t col) { fTextColor = col; }
284 virtual void SetState(Bool_t state);
285 Bool_t GetState() const { return fState; }
286 Int_t GetHotKeyCode() const { return fHkeycode; }
287 TGPopupMenu *GetMenu() const { return fMenu; }
288 const char *GetName() const { return fLabel ? fLabel->GetString() : 0; }
289 virtual void DoSendMessage();
290 virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
291
292 ClassDef(TGMenuTitle,0) // Menu title class
293};
294
295
296//////////////////////////////////////////////////////////////////////////
297// //
298// TGMenuBar //
299// //
300// This class creates a menu bar. //
301// //
302//////////////////////////////////////////////////////////////////////////
303
305
306friend class TGPopupMenu;
307
308protected:
309 TGMenuTitle *fCurrent; // current menu title
310 TList *fTitles; // list of menu titles
311 Cursor_t fDefaultCursor; // right pointing cursor
312 Bool_t fStick; // stick mode (popup menu stays sticked on screen)
313 TList *fTrash; // garbage
314 Bool_t fKeyNavigate; // kTRUE if arrow key navigation is on
315 TGPopupMenu *fMenuMore; // extra >> menu
316 TGLayoutHints *fMenuBarMoreLayout; // layout of the extra menu
317 Bool_t fWithExt; // indicates whether the >> menu is shown or not
318 TList *fOutLayouts; // keeps trace of layouts of hidden menus
319 TList *fNeededSpace; // keeps trace of space needed for hidden menus
320
321 virtual void AddFrameBefore(TGFrame *f, TGLayoutHints *l = 0,
322 TGPopupMenu *before = 0);
323
324 virtual void BindHotKey(Int_t keycode, Bool_t on = kTRUE);
325 virtual void BindKeys(Bool_t on = kTRUE);
326 void BindMenu(TGPopupMenu* subMenu, Bool_t on);
327
328private:
329 TGMenuBar(const TGMenuBar&); // not implemented
330 TGMenuBar& operator=(const TGMenuBar&); // not implemented
331
332public:
333 TGMenuBar(const TGWindow *p = 0, UInt_t w = 60, UInt_t h = 20,
335 virtual ~TGMenuBar();
336
337 virtual void AddPopup(TGHotString *s, TGPopupMenu *menu, TGLayoutHints *l,
338 TGPopupMenu *before = 0);
339 virtual void AddPopup(const char *s, TGPopupMenu *menu, TGLayoutHints *l,
340 TGPopupMenu *before = 0);
341 virtual TGPopupMenu *AddPopup(const TString &s, Int_t padleft = 4, Int_t padright = 0,
342 Int_t padtop = 0, Int_t padbottom = 0);
343 virtual void AddTitle(TGMenuTitle *title, TGLayoutHints *l, TGPopupMenu *before = 0);
344
345 virtual TGPopupMenu *GetPopup(const char *s);
346 virtual TGPopupMenu *RemovePopup(const char *s);
347
348 virtual TGMenuTitle *GetCurrent() const { return fCurrent; }
349 virtual TList *GetTitles() const { return fTitles; }
350 virtual Bool_t HandleButton(Event_t *event);
351 virtual Bool_t HandleMotion(Event_t *event);
352 virtual Bool_t HandleKey(Event_t *event);
353 virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
354 virtual void Layout();
355 void PopupConnection();
357
358 ClassDef(TGMenuBar,0) // Menu bar class
359};
360
361#endif
Handle_t Cursor_t
Definition: GuiTypes.h:33
Handle_t GContext_t
Definition: GuiTypes.h:37
Handle_t FontStruct_t
Definition: GuiTypes.h:38
ULong_t Pixel_t
Definition: GuiTypes.h:39
ROOT::R::TRInterface & r
Definition: Object.C:4
#define b(i)
Definition: RSha256.hxx:100
#define f(i)
Definition: RSha256.hxx:104
#define h(i)
Definition: RSha256.hxx:106
int Int_t
Definition: RtypesCore.h:41
unsigned int UInt_t
Definition: RtypesCore.h:42
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:87
const char Option_t
Definition: RtypesCore.h:62
#define ClassDef(name, id)
Definition: Rtypes.h:326
#define BIT(n)
Definition: Rtypes.h:83
@ kRaisedFrame
Definition: TGFrame.h:62
@ kHorizontalFrame
Definition: TGFrame.h:60
EMenuEntryState
Definition: TGMenu.h:34
@ kMenuRadioMask
Definition: TGMenu.h:39
@ kMenuRadioEntryMask
Definition: TGMenu.h:41
@ kMenuHideMask
Definition: TGMenu.h:40
@ kMenuCheckedMask
Definition: TGMenu.h:38
@ kMenuActiveMask
Definition: TGMenu.h:35
@ kMenuDefaultMask
Definition: TGMenu.h:37
@ kMenuEnableMask
Definition: TGMenu.h:36
EMenuEntryType
Definition: TGMenu.h:46
@ kMenuEntry
Definition: TGMenu.h:49
@ kMenuSeparator
Definition: TGMenu.h:47
@ kMenuPopup
Definition: TGMenu.h:50
@ kMenuLabel
Definition: TGMenu.h:48
Definition: TGFont.h:149
Definition: TGGC.h:31
TGPopupMenu * fMenuMore
Definition: TGMenu.h:315
virtual TGPopupMenu * RemovePopup(const char *s)
Remove popup menu from menu bar.
Definition: TGMenu.cxx:558
Bool_t fStick
Definition: TGMenu.h:312
virtual ~TGMenuBar()
Delete menu bar object.
Definition: TGMenu.cxx:152
virtual Bool_t HandleMotion(Event_t *event)
Handle a mouse motion event in a menu bar.
Definition: TGMenu.cxx:587
virtual Bool_t HandleKey(Event_t *event)
Handle keyboard events in a menu bar.
Definition: TGMenu.cxx:683
TGMenuBar & operator=(const TGMenuBar &)
virtual void AddTitle(TGMenuTitle *title, TGLayoutHints *l, TGPopupMenu *before=0)
Add popup via created before menu title.
Definition: TGMenu.cxx:432
virtual void BindHotKey(Int_t keycode, Bool_t on=kTRUE)
If on kTRUE bind hot keys, otherwise remove key binding.
Definition: TGMenu.cxx:380
Bool_t fWithExt
Definition: TGMenu.h:317
TGMenuTitle * fCurrent
Definition: TGMenu.h:309
virtual TGPopupMenu * GetPopup(const char *s)
Return popup menu with the specified name.
Definition: TGMenu.cxx:537
TList * fTrash
Definition: TGMenu.h:313
virtual void AddFrameBefore(TGFrame *f, TGLayoutHints *l=0, TGPopupMenu *before=0)
Private version of AddFrame for menubar, to make sure that we indeed only add TGMenuTitle objects to ...
Definition: TGMenu.cxx:500
virtual void BindKeys(Bool_t on=kTRUE)
If on kTRUE bind arrow, popup menu hot keys, otherwise remove key bindings.
Definition: TGMenu.cxx:334
virtual TGMenuTitle * GetCurrent() const
Definition: TGMenu.h:348
virtual TList * GetTitles() const
Definition: TGMenu.h:349
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a menu bar widget as a C++ statement(s) on output stream out.
Definition: TGMenu.cxx:2339
void BindMenu(TGPopupMenu *subMenu, Bool_t on)
If on kTRUE bind subMenu hot keys, otherwise remove key bindings.
Definition: TGMenu.cxx:352
TList * fOutLayouts
Definition: TGMenu.h:318
virtual Bool_t HandleButton(Event_t *event)
Handle a mouse button event in a menubar.
Definition: TGMenu.cxx:620
TGFrameElement * GetLastOnLeft()
Returns the last visible menu title on the left of the '>>' in the menu bar.
Definition: TGMenu.cxx:265
void PopupConnection()
Connects the corresponding cascaded menu to the proper slots, according to the highlighted menu entry...
Definition: TGMenu.cxx:286
TList * fNeededSpace
Definition: TGMenu.h:319
Cursor_t fDefaultCursor
Definition: TGMenu.h:311
Bool_t fKeyNavigate
Definition: TGMenu.h:314
virtual void Layout()
Calculates whether the >> menu must be shown or not and which menu titles are hidden.
Definition: TGMenu.cxx:190
TGLayoutHints * fMenuBarMoreLayout
Definition: TGMenu.h:316
TList * fTitles
Definition: TGMenu.h:310
virtual void AddPopup(TGHotString *s, TGPopupMenu *menu, TGLayoutHints *l, TGPopupMenu *before=0)
Add popup menu to menu bar.
Definition: TGMenu.cxx:415
TGMenuBar(const TGMenuBar &)
TGPopupMenu * GetPopup() const
Definition: TGMenu.h:100
Int_t fEx
Definition: TGMenu.h:79
const char * GetShortcutText() const
Definition: TGMenu.h:97
const TGPicture * GetPic() const
Definition: TGMenu.h:107
TGMenuEntry()
Definition: TGMenu.h:91
TGString * GetShortcut() const
Definition: TGMenu.h:102
Int_t fStatus
Definition: TGMenu.h:78
Int_t fEntryId
Definition: TGMenu.h:75
void * GetUserData() const
Definition: TGMenu.h:108
TGHotString * fLabel
Definition: TGMenu.h:81
TGHotString * GetLabel() const
Definition: TGMenu.h:101
TGMenuEntry(const TGMenuEntry &)
UInt_t GetEw() const
Definition: TGMenu.h:105
Int_t GetEx() const
Definition: TGMenu.h:103
virtual ~TGMenuEntry()
Definition: TGMenu.h:93
Int_t GetEy() const
Definition: TGMenu.h:104
UInt_t fEw
Definition: TGMenu.h:80
virtual Int_t GetStatus() const
Definition: TGMenu.h:98
const TGPicture * fPic
Definition: TGMenu.h:83
TGString * fShortcut
Definition: TGMenu.h:82
void * fUserData
Definition: TGMenu.h:76
Int_t fEy
Definition: TGMenu.h:79
TGMenuEntry & operator=(const TGMenuEntry &)
EMenuEntryType GetType() const
Definition: TGMenu.h:99
UInt_t GetEh() const
Definition: TGMenu.h:106
EMenuEntryType fType
Definition: TGMenu.h:77
UInt_t fEh
Definition: TGMenu.h:80
TGPopupMenu * fPopup
Definition: TGMenu.h:84
const char * GetName() const
Returns name of object.
Definition: TGMenu.h:96
Int_t GetEntryId() const
Definition: TGMenu.h:95
TGHotString * fLabel
Definition: TGMenu.h:252
virtual ~TGMenuTitle()
Definition: TGMenu.h:280
static const TGGC * fgDefaultGC
Definition: TGMenu.h:265
void * fTitleData
Definition: TGMenu.h:254
Pixel_t GetTextColor() const
Definition: TGMenu.h:282
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a title menu widget as a C++ statement(s) on output stream out.
Definition: TGMenu.cxx:2307
const char * GetName() const
Return unique name, used in SavePrimitive methods.
Definition: TGMenu.h:288
static FontStruct_t GetDefaultFontStruct()
Return default font structure in use.
Definition: TGMenu.cxx:2141
TGPopupMenu * fMenu
Definition: TGMenu.h:251
TGMenuTitle(const TGMenuTitle &)
Int_t fHkeycode
Definition: TGMenu.h:256
virtual void SetState(Bool_t state)
Set state of menu title.
Definition: TGMenu.cxx:2056
GContext_t fNormGC
Definition: TGMenu.h:259
static const TGFont * fgDefaultFont
Definition: TGMenu.h:263
static const TGGC & GetDefaultGC()
Return default graphics context in use.
Definition: TGMenu.cxx:2151
Int_t GetHotKeyCode() const
Definition: TGMenu.h:286
static const TGGC * fgDefaultSelectedGC
Definition: TGMenu.h:264
virtual void DoRedraw()
Draw a menu title.
Definition: TGMenu.cxx:2085
TGPopupMenu * GetMenu() const
Definition: TGMenu.h:287
static const TGGC & GetDefaultSelectedGC()
Return default selection graphics context in use.
Definition: TGMenu.cxx:2161
void SetTextColor(Pixel_t col)
Definition: TGMenu.h:283
Bool_t GetState() const
Definition: TGMenu.h:285
virtual void DoSendMessage()
Send final selected menu item to be processed.
Definition: TGMenu.cxx:2128
TGMenuTitle & operator=(const TGMenuTitle &)
Pixel_t fTextColor
Definition: TGMenu.h:258
GContext_t fSelGC
Definition: TGMenu.h:259
Bool_t fState
Definition: TGMenu.h:255
FontStruct_t fFontStruct
Definition: TGMenu.h:257
Int_t fTitleId
Definition: TGMenu.h:253
virtual void PoppedUp()
Definition: TGMenu.h:229
virtual void DrawBorder()
Draw border round popup menu.
Definition: TGMenu.cxx:1601
TList * fEntryList
Definition: TGMenu.h:130
virtual void AddLabel(TGHotString *s, const TGPicture *p=0, TGMenuEntry *before=0)
Add a menu label to the menu.
Definition: TGMenu.cxx:1092
UInt_t GetEntrySep() const
Definition: TGMenu.h:226
virtual void HideEntry(Int_t id)
Hide entry (hidden entries are not shown in the menu).
Definition: TGMenu.cxx:1748
virtual void AddPopup(TGHotString *s, TGPopupMenu *popup, TGMenuEntry *before=0, const TGPicture *p=0)
Add a (cascading) popup menu to a popup menu.
Definition: TGMenu.cxx:1149
virtual void DefaultEntry(Int_t id)
Set default entry (default entries are drawn with bold text).
Definition: TGMenu.cxx:1686
Bool_t fPoppedUp
Definition: TGMenu.h:134
static const TGGC * fgDefaultGC
Definition: TGMenu.h:152
TGMenuEntry * fCurrent
Definition: TGMenu.h:131
virtual TGMenuEntry * GetEntry(Int_t id)
Find entry with specified id.
Definition: TGMenu.cxx:1894
virtual Bool_t HandleMotion(Event_t *event)
Handle pointer motion event in popup menu.
Definition: TGMenu.cxx:1391
static const TGGC & GetDefaultSelectedGC()
Return the selection graphics context in use.
Definition: TGMenu.cxx:1971
Cursor_t fDefaultCursor
Definition: TGMenu.h:144
static const TGGC * fgDefaultSelectedBackgroundGC
Definition: TGMenu.h:154
virtual Bool_t IsEntryChecked(Int_t id)
Return true if menu item is checked.
Definition: TGMenu.cxx:1842
virtual void AddEntry(TGHotString *s, Int_t id, void *ud=0, const TGPicture *p=0, TGMenuEntry *before=0)
Add a menu entry.
Definition: TGMenu.cxx:987
UInt_t fMenuHeight
Definition: TGMenu.h:137
virtual Bool_t IsEntryRChecked(Int_t id)
Return true if menu item has radio check mark.
Definition: TGMenu.cxx:1875
virtual Bool_t HandleButton(Event_t *event)
Handle button event in the popup menu.
Definition: TGMenu.cxx:1335
virtual void CheckEntryByData(void *user_data)
Check a menu entry (i.e.
Definition: TGMenu.cxx:1792
TGSplitButton * fSplitButton
Definition: TGMenu.h:147
virtual void SetMenuBar(TGMenuBar *bar)
Definition: TGMenu.h:220
GContext_t fNormGC
Definition: TGMenu.h:139
virtual ~TGPopupMenu()
Delete a popup menu.
Definition: TGMenu.cxx:972
GContext_t fSelGC
Definition: TGMenu.h:140
virtual void Highlighted(Int_t id)
Definition: TGMenu.h:231
TGPopupMenu & operator=(const TGPopupMenu &)
virtual void AddSeparator(TGMenuEntry *before=0)
Add a menu separator to the menu.
Definition: TGMenu.cxx:1057
static const TGGC & GetDefaultGC()
Return default graphics context.
Definition: TGMenu.cxx:1961
virtual void UnCheckEntries()
Uncheck all entries.
Definition: TGMenu.cxx:1816
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a popup menu widget as a C++ statement(s) on output stream out.
Definition: TGMenu.cxx:2171
static FontStruct_t GetDefaultFontStruct()
Return the default font structure in use.
Definition: TGMenu.cxx:1991
static const TGGC * fgDefaultSelectedGC
Definition: TGMenu.h:153
static const TGFont * fgDefaultFont
Definition: TGMenu.h:150
virtual void CheckEntry(Int_t id)
Check a menu entry (i.e. add a check mark in front of it).
Definition: TGMenu.cxx:1779
virtual void Activate(Bool_t)
Definition: TGMenu.h:222
UInt_t fEntrySep
Definition: TGMenu.h:148
TGMenuBar * fMenuBar
Definition: TGMenu.h:146
virtual void Reposition()
Reposition entries in popup menu.
Definition: TGMenu.cxx:1206
virtual void SetEntrySep(UInt_t sep)
Definition: TGMenu.h:227
virtual void DisableEntry(Int_t id)
Disable entry (disabled entries appear in a sunken relieve).
Definition: TGMenu.cxx:1721
virtual void DrawEntry(TGMenuEntry *entry)
Draw popup menu entry.
Definition: TGMenu.cxx:1503
virtual void EnableEntry(Int_t id)
Enable entry. By default entries are enabled.
Definition: TGMenu.cxx:1702
virtual void UnCheckEntryByData(void *user_data)
Uncheck a menu entry (i.e.
Definition: TGMenu.cxx:1830
virtual void PoppedDown()
Definition: TGMenu.h:230
virtual Bool_t IsEntryHidden(Int_t id)
Return true if menu entry is hidden.
Definition: TGMenu.cxx:1765
TTimer * fDelay
Definition: TGMenu.h:138
UInt_t fXl
Definition: TGMenu.h:135
virtual Bool_t HandleCrossing(Event_t *event)
Handle pointer crossing event in popup menu.
Definition: TGMenu.cxx:1364
FontStruct_t fFontStruct
Definition: TGMenu.h:142
virtual void UnCheckEntry(Int_t id)
Uncheck menu entry (i.e. remove check mark).
Definition: TGMenu.cxx:1804
virtual void Associate(const TGWindow *w)
Definition: TGMenu.h:219
virtual Int_t EndMenu(void *&userData)
Close menu and return ID of selected menu item.
Definition: TGMenu.cxx:1286
virtual TGMenuEntry * GetCurrent() const
Definition: TGMenu.h:211
virtual void DeleteEntry(Int_t id)
Delete entry with specified id from menu.
Definition: TGMenu.cxx:1923
static FontStruct_t GetHilightFontStruct()
Return the font structure in use for highlighted menu entries.
Definition: TGMenu.cxx:2001
virtual void DoRedraw()
Draw popup menu.
Definition: TGMenu.cxx:1489
const TGWindow * fMsgWindow
Definition: TGMenu.h:145
static const TGGC & GetDefaultSelectedBackgroundGC()
Return the selection background graphics context in use.
Definition: TGMenu.cxx:1981
Bool_t fStick
Definition: TGMenu.h:132
FontStruct_t fHifontStruct
Definition: TGMenu.h:143
void DrawRCheckMark(GContext_t gc, Int_t l, Int_t t, Int_t r, Int_t b)
Draw radio check mark. Used for radio button type menu entries.
Definition: TGMenu.cxx:1667
void DrawCheckMark(GContext_t gc, Int_t l, Int_t t, Int_t r, Int_t b)
Draw check mark. Used for checked button type menu entries.
Definition: TGMenu.cxx:1648
virtual void RCheckEntry(Int_t id, Int_t IDfirst, Int_t IDlast)
Radio-select entry (note that they cannot be unselected, the selection must be moved to another entry...
Definition: TGMenu.cxx:1857
TGMenuBar * GetMenuBar() const
Definition: TGMenu.h:221
UInt_t fMenuWidth
Definition: TGMenu.h:136
TGPopupMenu(const TGPopupMenu &)
virtual void PlaceMenu(Int_t x, Int_t y, Bool_t stick_mode, Bool_t grab_pointer)
Popup a popup menu.
Definition: TGMenu.cxx:1238
virtual Bool_t HandleTimer(TTimer *t)
If TPopupDelayTimer times out popup cascading popup menu (if it is still the current entry).
Definition: TGMenu.cxx:1464
const TList * GetListOfEntries() const
Definition: TGMenu.h:213
virtual void Activated(Int_t id)
Definition: TGMenu.h:232
GContext_t fSelbackGC
Definition: TGMenu.h:141
static const TGFont * fgHilightFont
Definition: TGMenu.h:151
Bool_t fHasGrab
Definition: TGMenu.h:133
void DrawTrianglePattern(GContext_t gc, Int_t l, Int_t t, Int_t r, Int_t b)
Draw triangle pattern.
Definition: TGMenu.cxx:1628
virtual Bool_t IsEntryEnabled(Int_t id)
Return true if menu entry is enabled.
Definition: TGMenu.cxx:1733
const char * GetString() const
Definition: TGString.h:40
A doubly linked list.
Definition: TList.h:44
Mother of all ROOT objects.
Definition: TObject.h:37
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
Basic string class.
Definition: TString.h:131
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:51
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
static constexpr double bar
static constexpr double s
auto * l
Definition: textangle.C:4