![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tmenuhit.3r CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / 630 / man / src / p_man / man3|
Return to tmenuhit.3r CVS log | Up to [Research Unix] / researchv10dc / 630 / man / src / p_man / man3 |
1.1 ! root 1: .ds ZZ DEVELOPMENT PACKAGE ! 2: .TH TMENUHIT 3R "630 MTG" ! 3: .XE "tmenuhit()" ! 4: .XE "tm_ret()" ! 5: .SH NAME ! 6: tmenuhit \- present user with menu and get selection ! 7: .SH SYNOPSIS ! 8: .ft B ! 9: #include <dmd.h> ! 10: .br ! 11: #include <menu.h> ! 12: .sp ! 13: Titem \(**tmenuhit (m, n, flags [, p]) ! 14: .br ! 15: Tmenu \(**m; ! 16: .br ! 17: int n; ! 18: .br ! 19: int flags; ! 20: .br ! 21: Point p; ! 22: .sp ! 23: void tm_ret() ! 24: .PP ! 25: .nf ! 26: \s-1 ! 27: .ft CM ! 28: typedef struct Titem ! 29: { ! 30: char *text; /* string for menu */ ! 31: struct { ! 32: unsigned short uval; /* user field */ ! 33: unsigned short grey; /* grey this selection */ ! 34: } ufield; ! 35: struct Tmenu *next; /* ptr to sub-menu */ ! 36: Bitmap *icon; /* ptr to the icons bitmap */ ! 37: struct Font *font; /* font defined for this item */ ! 38: void (*dfn)(); /* execute function before sub-menu */ ! 39: void (*bfn)(); /* execute function after sub-menu */ ! 40: void (*hfn)(); /* execute function on selection */ ! 41: } Titem; ! 42: ! 43: typedef struct Tmenu ! 44: { ! 45: Titem *item; /* Titem array */ ! 46: short prevhit; /* index to current item */ ! 47: short prevtop; /* index to top item */ ! 48: Titem *(*generator)(); /* used if item == 0 */ ! 49: short menumap; /* bit definition of structure */ ! 50: } Tmenu; ! 51: ! 52: /* bit definitions in menumap */ ! 53: #define TM_TEXT 0x0001 /* defines the text field */ ! 54: #define TM_UFIELD 0x0002 /* defines the ufield field */ ! 55: #define TM_NEXT 0x0004 /* defines the next field */ ! 56: #define TM_ICON 0x0008 /* defines the icon field */ ! 57: #define TM_FONT 0x0010 /* defines the font field */ ! 58: #define TM_DFN 0x0020 /* defines the dfn field */ ! 59: #define TM_BFN 0x0040 /* defines the bfn field */ ! 60: #define TM_HFN 0x0080 /* defines the hfn field */ ! 61: .ft R ! 62: .fi ! 63: \s+1 ! 64: .SH DESCRIPTION ! 65: The \fItmenuhit\fP function ! 66: is an enhanced version of menuhit. It adds such features as ! 67: expanding menus, use of icons and various fonts within a menu item, ! 68: greying non-selectable items, and extended control over invocation and ! 69: specification of the menu facility. ! 70: .SS "Menu Trees" ! 71: Menu trees allow the presentation of several menus in a hierarchical ! 72: format. Each menu is specified by a \fITmenu\fP structure. ! 73: Each \fITmenu\fP structure contains a array of one or more \fITitem\fP ! 74: structures which specify the menu items. Each item of a menu may then, ! 75: in turn, point to a submenu. Submenus appear to the right ! 76: of the parent menu. The presence of a submenu for a menu item is indicated ! 77: by an arrow icon pointing to the right. Moving the cursor to the ! 78: arrow icon allows the user to preview the submenu. Sliding further to the ! 79: right moves the cursor into the submenu and allows the user to make a ! 80: selection in this menu. Moving the cursor back to the left exits the ! 81: submenu and moves the cursor back into the parent menu. ! 82: .SS Usage ! 83: The \fItmenuhit\fP function ! 84: presents the user with a menu tree specified by the root \fITmenu\fP pointer ! 85: \fIm\fP ! 86: and returns a pointer to a \fITitem\fP structure indicating which item was ! 87: selected. If no item was selected \fItmenuhit\fP returns a 0. ! 88: The \fIn\fP argument is an integer which ! 89: specifies the mouse button for user interaction: 1, 2, 3 or 0 for all ! 90: the buttons.. ! 91: The \fIflags\fP ! 92: argument is a bit vector which indicates various ! 93: modes of function in \fItmenuhit\fP. ! 94: These flags include: ! 95: .TP ! 96: .B (flags & TM_EXPAND) ! 97: If true, the menu tree will be expanded (according to the previous selection) ! 98: down to the lowest leaf on invocation of \fItmenuhit\fP. ! 99: .TP ! 100: .B (flags & TM_NORET) ! 101: If true, \fItmenuhit\fP will not return when a valid selection is made. This ! 102: feature is useful if a lot of selections are to be made from a large menu. ! 103: .TP ! 104: .B (flags & TM_STATIC) ! 105: If true, \fItmenuhit\fP assumes that no button is depressed when it is called. ! 106: In this case, the user makes a selection by depressing the button specified ! 107: when the cursor points to the item desired. If this is false, ! 108: \fItmenuhit\fP assumes that the button is depressed when called. The user ! 109: makes a selection by lifting the button when the cursor points to the ! 110: desired item. ! 111: .TP ! 112: .B (flags & TM_POINT) ! 113: If true, the argument \fIp\fP must be present and the origin of the root ! 114: menu will appear at this point on the display. ! 115: .P ! 116: The user may define one or more of these flags by or'ing them together ! 117: within the function call (e.g. (TM_EXPAND|TM_POINT) ). ! 118: .SS "Structure and Functional Description" ! 119: This section describes the structure fields of the \fITmenu\fP and the ! 120: \fITitem\fP structures and the functions of \fItmenuhit\fP they serve. ! 121: .P ! 122: The ! 123: .B Tmenu ! 124: structure defines a menu. It has the following fields: ! 125: .TP ! 126: .B item ! 127: This is an array of \fITitem\fP structures which defines each item in the ! 128: menu. The last item in the array must have its \fITitem\fP text ! 129: field equal to 0. ! 130: .TP ! 131: .B prevhit ! 132: \fIprevhit\fR is used to store the menu's previous selection. ! 133: When \fItmenuhit\fP ! 134: is called the menu is displayed such that, if possible, the mouse cursor ! 135: will be displayed over the previous selection. This might not be possible ! 136: if the menu is near the border of the screen. ! 137: \fIPrevhit\fR holds the index from ! 138: the top of the displayed menu. ! 139: The \fIprevhit\fR value is initialized to 0 and ! 140: normally does not need to be ! 141: manipulated by the application program. ! 142: .TP ! 143: .B prevtop ! 144: \fIprevtop\fR is used to store the topmost item ! 145: displayed in the menu when more ! 146: than sixteen menu items are defined. The maximum number of items which ! 147: may be displayed within a menu is sixteen. When there are more than sixteen ! 148: the menu becomes a ! 149: .B scrolling menu. ! 150: In this case, ! 151: the left portion of the menu contains a scroll bar that is ! 152: used for scrolling quickly through the menu selections. ! 153: The vertical size of the scroll bar is an indication of the size ! 154: of the user's view of the menu (16 items) relative to the number ! 155: of selections in the entire menu. ! 156: .sp ! 157: There are two ways to scroll through the menu items. ! 158: The first is to move the mouse cursor to the left side of the menu ! 159: into the scroll bar area. ! 160: By moving the mouse cursor up or down within the scroll bar area, the menu ! 161: items will scroll accordingly. ! 162: The second method used to scroll through the menu ! 163: items is to place the mouse cursor on the top or bottom entry of the menu ! 164: list. The menu will scroll up or down by one item at a time if ! 165: there are additional items to be displayed in that direction. ! 166: .sp ! 167: Like prevhit, the value of prevtop is initialized to 0 and ! 168: normally does not need to be manipulated by the application program. ! 169: .TP ! 170: .B generator ! 171: Menu items may be generated dynamically from a program by specifying ! 172: a generator function in the \fITmenu\fP structure. ! 173: If the item field in the \fITmenu\fP data structure ! 174: is 0 when a menu is entered, ! 175: either by calling \fItmenuhit\fP or through the sub-menu mechanism, ! 176: then the routine specified by \fIgenerator\fR ! 177: is called with two parameters that are ! 178: an integer index beginning at 0 and the address of the current \fITmenu\fP. ! 179: The generator must return a pointer to a \fITitem\fP ! 180: structure containing the text for the corresponding menu item. ! 181: This generator function is called repeatedly ! 182: with the index increasing by 1 until the generator returns a \s-1NULL\s+1 ! 183: for the text field in the \fITitem\fP structure, ! 184: indicating the end of the menu selections. ! 185: .TP ! 186: .B menumap ! 187: In applications where many menus are to be used, ! 188: the programmer can re-define the \fITitem\fP structure to include ! 189: only those fields that are actually used. ! 190: This has the advantage of requiring less data initialization ! 191: on the part of the programmer. It is done with a ! 192: bit vector called \fImenumap\fP in the \fITmenu\fP structure. ! 193: If used, the user defined structure replacing \fITitem\fP must contain ! 194: the specified member variables in the same order. ! 195: For example, if one wishes to use only the text, ufield, and next fields ! 196: of a \fITitem\fP structure, he may define a \fITitem\fP structure with ! 197: only those fields, and then set the menumap field of the \fITmenu\fP ! 198: structure to the value of (TM_TEXT|TM_UFIELD|TMNEXT). ! 199: Normally, this variable has the value zero when the standard \fITitem\fP ! 200: structure is used. ! 201: .PP ! 202: Each menu item is defined by a structure of the type \fITitem\fP. ! 203: The ! 204: .B Titem ! 205: structure has the following fields: ! 206: .TP ! 207: .B text ! 208: The text field is a pointer to a NULL terminated character string. This ! 209: is the character string that is displayed within the menu. ! 210: .sp ! 211: A facility provided by ! 212: .I tmenuhit ! 213: is that of a spread character. ! 214: A spread character is any ascii character with the high-order bit set ! 215: (e.g., an ascii space character defined as a spread character would have ! 216: the value of \'\\240\'). ! 217: The spread character acts somewhat like a spring pushing against ! 218: the adjacent text and borders within a menu entry. ! 219: The spread character can be placed at the beginning, middle, or end ! 220: of the string defining the menu entry. ! 221: If placed at the beginning of the string, ! 222: the text in the menu item will be right-justified. ! 223: If placed at the end of the string, ! 224: the text will be left justified. ! 225: If placed in the middle of the string, the text on each ! 226: side of the spread character will be pushed against the corresponding ! 227: menu border. In each case, ! 228: the space created by the spread character will be filled in with ! 229: the ascii character contained in the spread character. ! 230: For entries without a spread character, ! 231: the default is to have the text centered. ! 232: .TP ! 233: .B uval ! 234: This is an integer to be used for any purpose the user wishes. ! 235: It is typically used to store a constant that is used by the application ! 236: to identify \fITitem\fP structures. ! 237: For instance, this field could be set to a unique value for each menu ! 238: item in the menu tree. In this way, a switch statement ! 239: can easily determine the menu item selection regardless of the menu used ! 240: and the difference in size of different \fITitem\fP structures. ! 241: .TP ! 242: .B grey ! 243: If this field is set to 1, the item will be displayed in ! 244: the menu with a grey background. This item is non-selectable and, if ! 245: selected, the value \fItmenuhit\fP returns is 0. ! 246: .TP ! 247: .B next ! 248: The \fInext\fP variable points to another menu structure of type \fITmenu\fP ! 249: which defines a submenu for this particular item. ! 250: .TP ! 251: .B icon ! 252: The icon field is a pointer to a Bitmap structure that is ! 253: displayed to the left of the menu item. The size of the bitmap is ! 254: specified within the Bitmap structure and can vary from one menu item to ! 255: the next. ! 256: The icon can be displayed with or without a text string. ! 257: However, if icons are to be used without text strings, the value of \fItext\fP ! 258: field cannot be NULL, but must point to a NULL string. ! 259: .sp ! 260: When the icon field is used to display a bitmap, ! 261: all \fITitem\fP structures for the specific menu are scanned to find the largest ! 262: bitmap. This is used to determine the vertical spacing of all the menu ! 263: items within that menu. Smaller bitmaps on other menu entries will be ! 264: centered within the icon area. ! 265: .TP ! 266: .B font ! 267: The font field is a pointer to a font to be used for the text ! 268: is this menu item. Proportional ! 269: characters and different point size fonts will be positioned appropriately. ! 270: If a NULL value is specified, the 630 resident medium font is used. ! 271: .TP ! 272: .B dfn, bfn, hfn ! 273: These three fields may be initialized to point to functions that will ! 274: be executed by \fItmenuhit\fP before entering ! 275: a submenu (sliding \fIdown\fP), ! 276: after returning from a submenu (sliding \fIback\fP), ! 277: and upon making a selection in the current menu (a \fIhit\fP), respectively. ! 278: Each function is passed, as an argument, ! 279: the address of the \fITitem\fP structure from which it is called. ! 280: The hfn function provides an alternative method to using the return value of ! 281: .I tmenuhit. ! 282: .sp ! 283: In the special case of (flags & TM_NORET), ! 284: when a selection is made, the submenu the item ! 285: was in will be erased. Then ! 286: the hfn function ! 287: will be called with the selected item. If there is a parent ! 288: to this menu ! 289: the bfn and dfn functions will also be called in that order (if they ! 290: are initialized) ! 291: after which the menu will be redrawn. ! 292: This is due to the recursiveness of ! 293: .I tmenuhit. ! 294: .sp ! 295: If any of the dfn, bfn, or hfn functions execute calls to the ! 296: function ! 297: .I tmret(), tmenuhit ! 298: will ignore the TM_NORET flag and will return the selection made. ! 299: .SH EXAMPLE ! 300: The following example is a comprehensive example of how one may use ! 301: .I tmenuhit. ! 302: The example presents a menu tree when button 3 is depressed and, ! 303: upon selection of a menu item, it ! 304: prints the text of that item at the bottom of the screen. ! 305: The top level menu contains six items each pointing to a submenu. ! 306: They are ! 307: .I font, test, bttn3, icons, spread, ! 308: and ! 309: .I scroll. ! 310: The following is a brief explanation of each submenu and the functions it ! 311: intends to demonstrate. ! 312: .TP ! 313: .I font ! 314: The font submenu demonstrates the use of fonts and icons ! 315: (within the menu item) and the use of the hfn and dfn functions. ! 316: An hfn function called setfont is executed on selection and ! 317: sets the font to the selected font. Before the font submenu ! 318: is displayed, a dfn function called setmark will place a checkmark icon ! 319: next to the current font in use. ! 320: .TP ! 321: .I test ! 322: This submenu contains various sized ! 323: strings to demonstrate how \fItmenuhit\fP alters its menu item size ! 324: according to the size of ! 325: the string. ! 326: .TP ! 327: .I bttn3 ! 328: This is a replica of the button3 menu ! 329: on the 630MTG. It demonstrates the menu greying capability. This item also ! 330: demonstrates how one may use \fItmenuhit\fP to achieve the ! 331: simple functionality of \fImenuhit\fP plus the added capability ! 332: of greying items. ! 333: .TP ! 334: .I icons ! 335: This submenu demonstrates the use ! 336: of icons within menu items. ! 337: .TP ! 338: .I spread ! 339: This submenu ! 340: demonstrates the spread character facility. ! 341: .TP ! 342: .I scroll ! 343: This submenu ! 344: demonstrates the use of generators and presents the scrolling menu. ! 345: .P ! 346: Another thing to notice is the use of the abbreviated \fITitem\fP ! 347: structures. There are six different types of \fITitem\fP structures. Each ! 348: one corresponds to a menumap vector which defines the fields being used. ! 349: .PP ! 350: .RS 0 ! 351: \s-1 ! 352: .nf ! 353: .ft CM ! 354: #include <dmd.h> ! 355: #include <font.h> ! 356: #include <menu.h> ! 357: ! 358: void setmark(), setfont(); ! 359: Titem *scrllist(); ! 360: extern Tmenu menu20, menu21, menu22, menu23, menu24, menu25; ! 361: extern Tmenu menu30; ! 362: ! 363: Word strawberry[] = { ! 364: 0x0000,0x0000,0x0000, ! 365: 0x0000,0x0000,0x0000, ! 366: 0x0000,0x0000,0x0000, ! 367: 0x0000,0x1B80,0x0000, ! 368: 0x0000,0x3D80,0x0000, ! 369: 0x01F8,0x7E80,0x0000, ! 370: 0x03FE,0x7D80,0x0000, ! 371: 0x07AF,0xFB80,0x0000, ! 372: 0x0EF9,0xF780,0x0000, ! 373: 0x1F57,0xFFFE,0x0000, ! 374: 0x1FFB,0xFEAB,0x8000, ! 375: 0x1DAD,0xF77D,0xC000, ! 376: 0x3FFA,0x65B7,0x4000, ! 377: 0x3AAF,0x8FDE,0xE000, ! 378: 0x3FFD,0xFECB,0xA000, ! 379: 0x3BB7,0x5FEE,0xE000, ! 380: 0x3EFD,0xFAAB,0xA000, ! 381: 0x3FAF,0xAFEE,0xE000, ! 382: 0x3AFA,0xFD6B,0xA000, ! 383: 0x3FAF,0xD7DF,0xE000, ! 384: 0x3EFA,0xFED5,0x4000, ! 385: 0x1FAF,0xABBF,0xC000, ! 386: 0x1EFA,0xFFAA,0x8000, ! 387: 0x1FAF,0xD77F,0x8000, ! 388: 0x1FFD,0x7ED5,0x0000, ! 389: 0x0F57,0xD9FE,0x0000, ! 390: 0x0FFE,0xF754,0x0000, ! 391: 0x07AB,0xCDFC,0x0000, ! 392: 0x03FF,0x7EA8,0x0000, ! 393: 0x00F8,0x3BF0,0x0000, ! 394: 0x0000,0x1EE0,0x0000, ! 395: 0x0000,0x0F80,0x0000, ! 396: 0x0000,0x0000,0x0000, ! 397: 0x0000,0x0000,0x0000, ! 398: }; ! 399: ! 400: Word help_icon[] = { ! 401: 0x0000, 0x0000, 0x0000, 0x0000, ! 402: 0xE0E0, 0x6060, 0x7F7E, 0x7DFF, ! 403: 0x6FFB, 0x6C7B, 0x6FFE, 0xFFF8, ! 404: 0x003C, 0x0000, 0x0000, 0x0000, ! 405: }; ! 406: ! 407: ! 408: /* initialize Bitmap structures */ ! 409: Bitmap bm_strawberry = { ! 410: (Word*) strawberry, 3, 2, 0, 36, 34, 0 ! 411: }; ! 412: Bitmap bm_help = { ! 413: (Word*) help_icon, 1, 0, 0, 16, 16, 0 ! 414: }; ! 415: ! 416: /*******************************/ ! 417: /* definitions for menumap */ ! 418: /*******************************/ ! 419: #define TYPE1 TM_TEXT | TM_NEXT | TM_DFN ! 420: #define TYPE2 TM_TEXT ! 421: #define TYPE3 TM_TEXT | TM_NEXT ! 422: #define TYPE4 TM_TEXT | TM_UFIELD ! 423: #define TYPE5 TM_TEXT | TM_ICON ! 424: #define TYPE6 TM_TEXT | TM_ICON | TM_FONT | TM_HFN ! 425: ! 426: /*******************************/ ! 427: /* define Titem typedef's */ ! 428: /*******************************/ ! 429: ! 430: /* ! 431: * define a Titem structure with only text, next, and dfn fields ! 432: */ ! 433: typedef struct Titem01 ! 434: { ! 435: char *text; /* string for menu */ ! 436: struct Tmenu *next; /* pointer to sub-menu */ ! 437: void (*dfn)(); /* pointer function to execute on submenu */ ! 438: } Titem01; ! 439: ! 440: /* ! 441: * define a Titem structure with only text field ! 442: */ ! 443: typedef struct Titem2 ! 444: { ! 445: char *text; /* string for menu */ ! 446: } Titem2; ! 447: ! 448: /* ! 449: * define a Titem structure with only text and next fields ! 450: */ ! 451: typedef struct Titem3 ! 452: { ! 453: char *text; /* string for menu */ ! 454: struct Tmenu *next; /* pointer to sub-menu */ ! 455: } Titem3; ! 456: ! 457: /* ! 458: * define a Titem structure with only text and ufield fields ! 459: */ ! 460: typedef struct Titem4 ! 461: { ! 462: char *text; /* string for menu */ ! 463: struct { ! 464: unsigned short uval; /* user field */ ! 465: unsigned short grey; /* flag indicates invalid selection */ ! 466: } ufield; ! 467: } Titem4; ! 468: ! 469: ! 470: /* ! 471: * define a Titem structure with only text and icon fields ! 472: */ ! 473: typedef struct Titem5 ! 474: { ! 475: char *text; /* string for menu */ ! 476: Bitmap *icon; /* pointer to the icons bitmap */ ! 477: } Titem5; ! 478: ! 479: ! 480: /* ! 481: * define a Titem structure with only text, icon, font and hfn fields ! 482: */ ! 483: typedef struct Titem6 ! 484: { ! 485: char *text; /* string for menu */ ! 486: Bitmap *icon; /* pointer to the icons bitmap */ ! 487: Font *font; /* pointer to font structure */ ! 488: void (*hfn)(); /* function to execute on selection */ ! 489: } Titem6; ! 490: ! 491: /*******************************/ ! 492: /* initialize Titem structures */ ! 493: /*******************************/ ! 494: ! 495: /* ! 496: * initialize the Titem structure for the main menu ! 497: * has only text, next and dfn fields ! 498: */ ! 499: Titem01 L1_root[] = ! 500: { ! 501: "font", &menu20, setmark, ! 502: "test", &menu21, 0, ! 503: "bttn3", &menu22, 0, ! 504: "icons", &menu23, 0, ! 505: "spread", &menu24, 0, ! 506: "scroll", &menu25, 0, ! 507: 0 ! 508: }; ! 509: ! 510: ! 511: /* ! 512: * initialize the Titem structure for menu20 ! 513: * has only text, icon, font, hfn fields ! 514: */ ! 515: Titem6 L2_font[] = ! 516: { ! 517: "smallfont", 0, 0, setfont, ! 518: "mediumfont", 0, 0, setfont, ! 519: "largefont", 0, 0, setfont, ! 520: 0 ! 521: }; ! 522: ! 523: /* ! 524: * initialize the Titem structure for menu21 ! 525: * has only text and next fields ! 526: */ ! 527: Titem3 L2_test[] = ! 528: { ! 529: "A long test string so we can see what happens", 0, ! 530: "Short strings", &menu30, ! 531: 0 ! 532: }; ! 533: ! 534: /* ! 535: * initialize the Titem structure for menu22 ! 536: * has only text and ufield fields ! 537: */ ! 538: Titem4 L2_bttn3[] = ! 539: { ! 540: "New", 0, 1, ! 541: "Reshape", 0, 1, ! 542: "Top", 0, 1, ! 543: "Bottom", 0, 1, ! 544: "Current", 0, 1, ! 545: "Delete", 0, 1, ! 546: "Exit", 0, 0, ! 547: 0 ! 548: }; ! 549: ! 550: /* ! 551: * initialize the Titem structure for menu23 ! 552: * has only text and icon fields ! 553: */ ! 554: Titem5 L2_icons[] = ! 555: { ! 556: "strawberry", &bm_strawberry, ! 557: "help", &bm_help, ! 558: 0 ! 559: }; ! 560: ! 561: ! 562: /* ! 563: * initialize the Titem structure for menu24 ! 564: * has only text field ! 565: */ ! 566: Titem2 L2_spread[] = ! 567: { ! 568: "left\\240", /* space character with high bit set */ ! 569: "\\256right", /* . char with high bit set */ ! 570: "middle", ! 571: "left\\337right", /* _ char with high bit set */ ! 572: "a very long string", ! 573: 0 ! 574: }; ! 575: ! 576: /* ! 577: * initialize the Titem structure for menu30 ! 578: * has only text field ! 579: */ ! 580: Titem2 L3_shorts[] = ! 581: { ! 582: "abc", ! 583: "xyz", ! 584: "123", ! 585: "XYZ", ! 586: "ABC", ! 587: 0 ! 588: }; ! 589: ! 590: ! 591: /*******************************/ ! 592: /* initialize Tmenu structures */ ! 593: /*******************************/ ! 594: /* ! 595: * menu(xy), where x is the level and y is the menu number ! 596: */ ! 597: Tmenu menu10 = { (Titem *) L1_root, 0, 0, 0, TYPE1 }; ! 598: Tmenu menu20 = { (Titem *) L2_font, 2, 0, 0, TYPE6 }; ! 599: Tmenu menu21 = { (Titem *) L2_test, 0, 0, 0, TYPE3 }; ! 600: Tmenu menu22 = { (Titem *) L2_bttn3, 0, 0, 0, TYPE4 }; ! 601: Tmenu menu23 = { (Titem *) L2_icons, 0, 0, 0, TYPE5 }; ! 602: Tmenu menu24 = { (Titem *) L2_spread, 0, 0, 0, TYPE2 }; ! 603: Tmenu menu25 = { (Titem *) 0, 0, 0, scrllist, 0 }; ! 604: Tmenu menu30 = { (Titem *) L3_shorts, 0, 0, 0, TYPE2 }; ! 605: ! 606: char noselect[] = "no selection"; ! 607: Font *font; ! 608: ! 609: main() ! 610: { ! 611: Titem *ret; ! 612: ! 613: /* set the font and icon fields in the proper menu */ ! 614: L2_font[0].font = &smallfont; ! 615: L2_font[1].font = &mediumfont; ! 616: L2_font[2].font = &largefont; ! 617: L2_font[1].icon = &B_checkmark; ! 618: font = &largefont /* use the medium font to start with */ ! 619: request(MOUSE); ! 620: while(wait(MOUSE)) { ! 621: if (button3()) { ! 622: /* clear the text area for writing strings */ ! 623: cursinhibit(); ! 624: rectf(&display, ! 625: Rpt(Pt(Drect.origin.x, Drect.corner.y-18), Drect.corner), ! 626: F_CLR); ! 627: cursallow(); ! 628: if(ret = tmenuhit (&menu10, 3, TM_EXPAND)) { ! 629: /* write the menu string in text area */ ! 630: string(font, ret->text, &display, ! 631: Pt(Drect.origin.x+5, Drect.corner.y-18), ! 632: F_XOR); ! 633: } ! 634: else { /* no selection was made */ ! 635: string(font, noselect, &display, ! 636: Pt(Drect.origin.x+5, Drect.corner.y-18), ! 637: F_XOR); ! 638: } ! 639: } ! 640: else if (button1()) ! 641: exit(); ! 642: } ! 643: } ! 644: ! 645: char digits[10]; ! 646: Titem scrlitem; ! 647: char scrlstr[] = "scroll"; ! 648: ! 649: /* ! 650: * generator for scroll menu ! 651: * generate 99 menu items ! 652: */ ! 653: Titem *scrllist(i, m) ! 654: int i; ! 655: Tmenu *m; ! 656: { ! 657: int j; ! 658: ! 659: if (i > 99) { /* generator stopping condition */ ! 660: scrlitem.text = 0; ! 661: } ! 662: else { /* generate text for items (i.e. "scroll56") */ ! 663: scrlitem.text = digits; ! 664: for (j=0; scrlstr[j] != '\\0'; j++) digits[j] = scrlstr[j]; ! 665: digits[j++] = i/10 + '0'; ! 666: digits[j++] = i - (i/10 * 10) + '0'; ! 667: digits[j] = '\\0'; ! 668: } ! 669: return ( &scrlitem ); ! 670: } ! 671: ! 672: /* ! 673: * a dfn function. ! 674: * This is executed before the font submenu is entered ! 675: * place the checkmark by the proper font ! 676: */ ! 677: void setmark(mi) ! 678: Titem01 *mi; ! 679: { ! 680: Tmenu *tm; ! 681: Titem6 *tmi; ! 682: int index; ! 683: int hit; ! 684: ! 685: tm = mi->next; ! 686: hit = tm->prevhit + tm->prevtop; ! 687: for (index=0, tmi=(Titem6 *)tm->item; tmi->text; index++, tmi++) { ! 688: tmi->icon = (index == hit) ? &B_checkmark:0; ! 689: } ! 690: } ! 691: ! 692: /* ! 693: * an hfn function ! 694: * this is executed after a selection is made ! 695: */ ! 696: void setfont(mi) ! 697: Titem6 *mi; ! 698: { ! 699: /* set the font to the selected font */ ! 700: font = mi->font; ! 701: } ! 702: \fR ! 703: .fi ! 704: .RE ! 705: \s+1 ! 706: .SH SEE ALSO ! 707: menuhit(3L), structures(3R). ! 708: .SH WARNINGS ! 709: Common uses for user-provided functions in the \fITitem\fP structure ! 710: include modifying the members of menu data structures ! 711: such as the \fIicon\fP ! 712: and \fIgrey\fP fields. The user must be careful that such menu structures are ! 713: properly initialized. ! 714: .PP ! 715: Whenever a menu is displayed, the screen image obscured by the menu is ! 716: saved in a bitmap and then later restored when the menu disappears. ! 717: If the terminal is ! 718: out of memory and therefore cannot save the screen image, ! 719: then the menu will be displayed in \s-1XOR\s+1 (exclusive or) ! 720: mode on top of the existing screen image. ! 721: Menu items may still be selected in this mode but ! 722: may be difficult to read. ! 723: To remedy this problem, ! 724: memory may be freed up by either deleting or ! 725: reshaping windows before the menu is displayed. ! 726: .PP ! 727: Because the \fItmenuhit\fR code is recursive, ! 728: an arbitrary limit to a depth of eight ! 729: menus is defined to avoid stack overflow. ! 730: .PP ! 731: The user should be careful not to perform screen writes from within the ! 732: dfn, bfn, or hfn functions. Any writes to the screen from within these ! 733: functions can corrupt the displayed menu.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.