TweetFollow Us on Twitter

Menu Command Unit
Volume Number:7
Issue Number:9
Column TagPascal Procedures

Related Info: Menu Manager

Menu Command Handler Unit

By David T. Craig, Kansas City, MO

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

[David has been involved with the Macintosh on the software side since its introduction in 1984. Currently he works as a Macintosh programmer for a small custom application development company in Kansas City, Kansas.]

Introduction

This unit manages menu commands in a manner similar to Apple’s MacApp “command menu” mechanism. Each application menu item should contain a unique “command number”, an integer value in the range 1 to 32767. This module scans the installed menus, parses the command numbers from each menu item, and stores the item command numbers in a table. When a menu item is selected, this module should be called to return the command number of the selected item. The parsed menu command number is also removed from the menu item.

Having each menu item define its own unique command value simplifies the job of the application programmer. Instead of using the menu id and menu item values for menu handling, the programmer needs only to use the unique command numbers. Using command numbers allows the programmer to move menu items around in the resource file without having to change the application source code. Users also benefit since they too can move menu items around via ResEdit as long as they don’t alter the item’s command number.

A menu item has a command number if the menu contains the character “#” followed by the command number. An example follows for a typical file menu (format compatible with Apple’s MPW Rez tool):

#1

“New#1”,noicon,nokey,nomark, plain;
“Open...#2”,noicon,”O”,nomark,plain;
“-”,noicon,nokey,nomark,plain;
“Quit#3”, noicon,”Q”,nomark,plain;

Note that the command number must exist at the menu item’s end.

Using this Unit

This module contains several routines which completely control access to menu command numbers.

Routine MC_Build_Menu_Command_Table builds the menu command table for an application. Call this at the start of an application after the application menus have been installed. This routine takes a pointer to a list of menu handles which define all the application menus. In Pascal a simple array of MenuHandle is adequate.

Once you are completely finished with all the menus call routine MC_UnBuild_Menu_Command_Table. This should generally be called when the application quits.

Routine MC_Fetch_Menu_Command should be called when the user selects a menu item via either the ROM MenuSelect or ROM MenuKey routines. This routine returns the command number for the selected menu item.

Routine MC_Fetch_Menu_ID_and_Item returns the menu id and item numbers for a menu command number. Once this routine is used you may use the command’s id and item numbers with the many routines supported by the Apple Menu Manager.

Routine MC_Version returns the version number and compilation date and time of this module.

Applications supporting menus that change may also use this module (MicroSoft Word is an example of an application with changing menus). Whenever the menus change you must deallocate the built menu command table and rebuild the new menu command table.

WARNING: The caller of these routines must not make any assumptions about the contents of a menu command table. This data structure, which is referenced thru a handle, must be considered off limits since its internal layout may change. Use only the public routines in this module and you will have no problems.

Unit Interface Routines
PROCEDURE MC_Version (VAR version_phrase: Str255);

PROCEDURE MC_Build_Menu_Command_Table
     (menu_list: Ptr;
      menu_count: INTEGER;
      VAR command_table: Handle;
      VAR good_build: BOOLEAN);  

PROCEDURE MC_UnBuild_Menu_Command_Table
      (VAR command_table: Handle;
       VAR good_unbuild: BOOLEAN);

PROCEDURE MC_Fetch_Menu_Command
     (command_table: Handle;
      menu_info: LONGINT;
      VAR menu_command: INTEGER);  

PROCEDURE MC_Fetch_Menu_ID_and_Item
     (command_table: Handle;
      menu_command: INTEGER;
      VAR menu_id: INTEGER;
      VAR menu_item: INTEGER);
Listing:  UMenuCommand.p

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                                                        • }
{ •     ----------------------------------------------     • }
{ •       APPLE MACINTOSH MENU COMMAND PARSER MODULE       • }
{ •     ----------------------------------------------     • }
{ •                                                        • }
{ • Author ...... David T. Craig                           • }
{ • Address ..... 736 Edgewater, Wichita, Kansas 67230     • }
{ • Date ........ 1989/1990                                • }
{ • Version ..... 1.0.0                                    • }
{ • Language .... Apple MPW and Think Pascal 3.0           • }
{ • Computer .... Apple Macintosh                          • }
{ •                                                        • }
{ • Copyright ... NOT Copyright (C) 1990 by David T. Craig • }
{ •                                                        • }
{ • PURPOSE:                                               • }
{ •                                                        • }
{ • This module manages menu commands  similar to Apple’s MacApp “command 
menu” mechanism.  • }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                                                        • }
{ •                   Modification Notes                   • }
{ •                                                        • }
{ • Originally written in Lisa Pascal on a Lisa, ported to MPW and thento 
Think Pascal.                                   • }
{ •                                                        • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •          NOT COPYRIGHT 1990 BY DAVID T. CRAIG          • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }

UNIT UMenuCommand;
{ ########################################################## }
INTERFACE
{ ########################################################## }

{$DECL for_MPW}
{$SETC for_MPW:=FALSE}

{$DECL for_THINK}
{$SETC for_THINK:=TRUE}

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                    EXTERNAL MODULES                    • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{$IFC for_MPW}
USES
 MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf, Traps, PasLibIntf;
{$ENDC}

{$IFC for_THINK}
USES
 MemTypes, QuickDraw, OSIntf, ToolIntf, Packages;
{$ENDC}

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                   COMPILER DIRECTIVES                  • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }

{$IFC for_MPW}
{$R+}
 { array, string, & subrange range checking [MPW PASCAL 3.0] }
{$OV+}
 { integer overflow checking [MPW PASCAL 3.0] }
{$SC+}
 { short-circuit boolean evaluation [MPW PASCAL 3.0] }
{$ENDC}

{$IFC for_THINK}
{$R+}
 { array, string,& subrange range checking [THINK PASCAL 3.0] }
{$N+}
 { routine name inclusion for debugger [THINK PASCAL 3.0] }
{$V+}
 { integer overflow checking [THINK PASCAL 3.0] }
{$ENDC}

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                PUBLIC MODULE INTERFACE                 • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
CONST
 MC_c_NoCommand = 0; { menu command value for NO COMMAND }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_Version }
{ • Purpose ... Return the version number and compilation date of the 
module }
{ • Input ..... (none) }
{ • Output .... version_phrase - version number and compilation date 
info }
{ • Notes ..... Use this if you are interested in having this information. 
}
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }

PROCEDURE MC_Version (VAR version_phrase: Str255);

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_Build_Menu_Command_Table }
{ • Purpose ... Build a new menu command tabe from a list of menus }
{ • Input ..... menu_list     - pointer to list of menus to build from 
}
{ •             menu_count    - no. menus in the menu list }
{ • Output .... command_table - build menu command table }
{ •             good_build    - build went well flag }
{ • Notes ..... Call this routine after your application’s menus are 
defined. }
{ •             Using an array of MenuHandles for the menu list is an 
easy  way to pass the menus to this routine.  Duplicate command numbers 
are detected and result in good_build returning False. }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }

PROCEDURE MC_Build_Menu_Command_Table (menu_list: Ptr; { in }
 menu_count: INTEGER; { in }
 VAR command_table: Handle; { out }
 VAR good_build: BOOLEAN); { out }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_UnBuild_Menu_Command_Table }
{ • Purpose ... Unbuild a build menu command table }
{ • Input ..... command_table - built menu command table }
{ • Output .... command_table - deallocated menu command table (=NIL) 
}
{ •             good_unbuild - unbuild process went well flag }
{ • Notes ..... This routine should be called when you are completely 
done with a menu command table. }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }

PROCEDURE MC_UnBuild_Menu_Command_Table (VAR command_table: Handle;
 { in/out } VAR good_unbuild: BOOLEAN); { in }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_Fetch_Menu_Command }
{ • Purpose ... Fetch the menu command command for a menu selected by 
 the ROM Menu Manager routine MenuSelect }
{ • Input ..... command_table - command table from MC_Build_Menu_Command_Table 
}
{ •             menu_info   - menu info from  ROM MenuSelect }
{ • Output .... menu_command  - selected menu command value (0=no command) 
}
{ • Notes ..... Call this routine when the user has selected a menu and 
you have called ROM MenuSelect or ROM MenuKey. }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE MC_Fetch_Menu_Command(command_table: Handle; {in}
 menu_info: LONGINT; { in }
 VAR menu_command: INTEGER); { out }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_Fetch_Menu_ID_and_Item }
{ • Purpose ... Return the menu id and item numbers for a command number 
}
{ • Input ..... command_table - command table from MC_Build_Menu_Command_Table 
}
{ •             menu_command  - menu command number }
{ • Output .... menu_id       - menu id   value for the command number 
}
{ •             menu_item     - menu item value for the command number 
}
{ • Notes ..... If the command number is invalid, then menu_id and menu_item 
are set to -1, an invalid value for either of these numbers. }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE MC_Fetch_Menu_ID_and_Item(command_table:Handle;{in}
 menu_command: INTEGER; { in }
 VAR menu_id: INTEGER; { out }
 VAR menu_item: INTEGER); { out }

{ ########################################################## }
IMPLEMENTATION
{ ########################################################## }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                PRIVATE MODULE CONSTANTS                • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
CONST
 pc_module_version = ‘1.0.0’; { module version number }
 pc_command_identifier = ‘#’;{ command # character for menus}
 pc_command_num_min = 1; { min and max menu command values }
 pc_command_num_max = MAXINT;

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                PRIVATE MODULE TYPES                    • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
TYPE
 { general data types }
 pt_word = 0..MAXINT;

 { list of menu handles used indirectly by callers }
 pt_menu_list = ARRAY[1..1] OF MenuHandle;
 pt_menu_list_ptr = ^pt_menu_list;

 { menu command structure for a single menu item }
 pt_command_info = RECORD
 ci_command_number: INTEGER;{ unique command number }
 ci_menu_id: INTEGER; { menu id   number for command }
 ci_menu_item: pt_word;  { menu item number for command }
 END;

 pt_command_list = ARRAY[1..1] OF pt_command_info;

 pt_command_list_p = ^pt_command_list;
 pt_command_list_h = ^pt_command_list_p;

 { NOTE: The menu commands for all the menus in an application are stored 
as a dynamic array structure.  This structure acts just like a simple 
array, but its size may vary.  Access to the elements of this array requires 
disabling range       checking since the array from Pascal’s perspective 
contains only a single element                                     }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                                                        • }
{ •                PRIVATE MODULE ROUTINES                 • }
{ •                                                        • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... find_Command_in_Table }
{ • Purpose ... Attempt to locate a command number in a menu command 
table }
{ • Input ..... the_command_table - menu command table }
{ •             the_command       - command number to find }
{ • Output .... the_table_index   - index of found command number (0=not 
found) }
{ •             the_command_info  - info about the found command }
{ • Notes ..... Output parm the_table_index is set to 0 (zero) if the 
command number does not exist in menu command table. }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE find_Command_in_Table (the_command_table: pt_command_list_h;
 { in }
 the_command: INTEGER; { in }
 VAR the_table_index: pt_word; { out }
 VAR the_command_info: pt_command_info); { out }
 VAR
 list_size: Size; { physical byte size of command list }
 list_records: pt_word;   { no. records in command list }
 error: INTEGER;  { error result for a MemMgr call }
 BEGIN  { ---------- find_Command_in_Table ---------- }
 the_table_index := 0; { assume the command does not exist in the table 
}
 IF the_command_table <> NIL THEN
 BEGIN
 list_size := GetHandleSize(Handle(the_command_table));
 error := MemError;

 IF (error = NoErr) AND (list_size > 0) THEN
 BEGIN
 list_records := list_size DIV SIZEOF(the_command_info);

 WHILE (list_records >= 1) AND (the_table_index = 0) DO
 BEGIN
 {$PUSH}
 {$R-}
 the_command_info := the_command_table^^[list_records];
 {$POP}

 IF the_command = the_command_info.ci_command_number THEN
 BEGIN
 the_table_index := list_records; 
 { !!! GOTCHA !!! }
 END;

 list_records := list_records - 1;
 END; { WHILE list_records }
 END;
 END;
 END;   { ---------- find_Command_in_Table ---------- }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... add_Command_to_CmdList }
{ • Purpose ... Add a single menu command structure to the end of an 
}
{ •             existing menu command table }
{ • Input ..... the_command_table  - menu command table }
{ •             the_menu_id        - menu id   value }
{ •             the_menu_item      - menu item value }
{ •             the_command_number - menu command number }
{ • Output .... the_error          - error result }
{ • Notes ..... Command table must already exist for this routine to 
work. }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE add_Command_to_CmdList (the_command_table: pt_command_list_h;
 the_menu_id: INTEGER;
 the_menu_item: pt_word;
 the_command_number: INTEGER;
 VAR the_error: INTEGER);
 VAR
 command_to_add: pt_command_info;{info about command toadd}
 list_size: Size; { physical byte size of command list }
 list_records: pt_word;  { no. records in command list }
 BEGIN  { ---------- add_Command_to_CmdList ---------- }
 the_error := NoErr;

 IF the_command_table = NIL THEN
 the_error := NILHandleErr
 ELSE
 BEGIN
{ setup the command info to actually add to the table end }
 command_to_add.ci_command_number := the_command_number;
 command_to_add.ci_menu_id := the_menu_id;
 command_to_add.ci_menu_item := the_menu_item;

 { grow the table by one record for the addition }
 list_size := GetHandleSize(Handle(the_command_table));
 the_error := MemError;

 IF the_error = NoErr THEN
 BEGIN
 list_size := list_size + SIZEOF(command_to_add);
 SetHandleSize(Handle(the_command_table), list_size);
 the_error := MemError;

{ store the command info record at the end of the table }
 IF the_error = NoErr THEN
 BEGIN
 list_records := list_size DIV SIZEOF(command_to_add);

 {$PUSH}
 {$R-}
 the_command_table^^[list_records] := command_to_add;
 {$POP}
 END;
 END;
 END;
 END;   { ---------- add_Command_to_CmdList ---------- }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                                                        • }
{ •                PUBLIC MODULE ROUTINES                  • }
{ •                                                        • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_Version }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE MC_Version (VAR version_phrase: Str255);
 VAR
 comp_stuff: STRING[63]; { compilation date and time info }
 BEGIN  { ---------- MC_Version ---------- }
{ NOTE: COMPDATE and COMPTIME contain the compilation date and time as 
strings.  These are both built into MPW Pascal and THINK Pascal.  MPW 
treats them as string constants while THINK treats them as string functions. 
          }

 comp_stuff := CONCAT(‘[‘, COMPDATE, ‘ -- ‘, COMPTIME, ‘]’);

 version_phrase := CONCAT(pc_module_version, ‘ ‘, comp_stuff);
 END;   { ---------- MC_Version ---------- }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_Build_Menu_Command_Table }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE MC_Build_Menu_Command_Table (menu_list: Ptr;
 menu_count: INTEGER;
 VAR command_table: Handle;
 VAR good_build: BOOLEAN);
 VAR
 menu_index: pt_word;{ menuhandle list indexer }
 menu_list_ptr: pt_menu_list_ptr;  { menu list pointer }
 menu_stuff: MenuHandle; { single entry from menu list }
 menu_id: INTEGER; { menu id  value from menu list entry }
 menu_item: pt_word; {menuitem value from menu list entry}
 menu_phrase: Str255; { phrase for a single menu item }
 command_identifier: STRING[1];    { command identifier character }
 command_position: pt_word; { position of command identifier in item 
}
 command_phrase: Str255; { menu command number phrase (eg: “203”) }
 command_number: LONGINT; { command number value (long) }
 command_value: INTEGER; { command number value (word) }
 table_index: pt_word; { menu command table index of a command }
 command_info: pt_command_info; { information about a single menu command 
}
 good_unbuild: BOOLEAN;  { deallocating menu command table result }
 error: INTEGER; { internal error result }
 BEGIN  { ------ MC_Build_Menu_Command_Table ------ }
 command_table := NIL;
 good_build := FALSE;

 IF menu_count >= 1 THEN
 BEGIN
 command_table := NewHandle(0);
 error := MemError;

 IF error = NoErr THEN
 BEGIN
 good_build := TRUE; { assume all will go well from now on }

 menu_index := 0;

 { scan each of the menu handles }
 REPEAT
 BEGIN
 menu_index := menu_index + 1;

 menu_list_ptr := pt_menu_list_ptr(menu_list);

 {$PUSH}
 {$R-}
 menu_stuff := menu_list_ptr^[menu_index];
 {$POP}

 IF menu_stuff <> NIL THEN
 BEGIN
 command_identifier := ‘?’;
 command_identifier[1] := pc_command_identifier;

{ scan the menu items in the current menu handle }
 menu_id := menu_stuff^^.MenuID;
 menu_item := 0;

 REPEAT
 BEGIN
 menu_item := menu_item + 1;
 GetItem(menu_stuff, menu_item, menu_phrase);

 IF LENGTH(menu_phrase) >= 2 THEN
 BEGIN
 command_position := POS(command_identifier, menu_phrase);

 IF command_position > 0 THEN
 BEGIN
 command_phrase := COPY(menu_phrase, command_position, LENGTH(menu_phrase) 
- command_position + 1);
 DELETE(command_phrase, 1, 1);

 DELETE(menu_phrase, command_position, LENGTH(menu_phrase) - command_position 
+ 1);

 SetItem(menu_stuff, menu_item, menu_phrase);

 WHILE POS(‘ ‘, command_phrase) > 0 DO
 DELETE(command_phrase, POS(‘ ‘, command_phrase), 1);

 StringToNum(command_phrase, command_number);

 command_value := LoWord(command_number);

 IF (command_value < pc_command_num_min) OR (command_value > pc_command_num_max) 
THEN
 good_build := FALSE
 ELSE
 BEGIN
 { command value is valid, now check for duplication }
 find_Command_in_Table( pt_command_list_h(command_table), command_value, 
table_index, command_info);

 IF table_index > 0 THEN
 good_build := FALSE  { !!! DUPLICATE !!! }
 ELSE
 BEGIN
 add_Command_to_CmdList (pt_command_list_h(command_table), menu_id, menu_item, 
command_value, error);

 IF error <> NoErr THEN
 good_build := FALSE;
 END;
 END;
 END;
 END;
 END;
 UNTIL (menu_phrase = ‘’) OR NOT (good_build);
 END;

 IF error <> NoErr THEN
 good_build := FALSE;
 END;
 UNTIL (menu_index >= menu_count) OR (error <> NoErr);
 END;
 END;

 IF NOT (good_build) AND (command_table <> NIL) THEN
 BEGIN
 MC_UnBuild_Menu_Command_Table(command_table, good_unbuild);
 END;
 END;   { ------ MC_Build_Menu_Command_Table ------ }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_UnBuild_Menu_Command_Table }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE MC_UnBuild_Menu_Command_Table (VAR command_table: Handle; VAR 
good_unbuild: BOOLEAN);
 VAR
 error: INTEGER;
 BEGIN  { ------ MC_UnBuild_Menu_Command_Table ------ }
 good_unbuild := TRUE;

 IF command_table = NIL THEN
 good_unbuild := FALSE
 ELSE
 BEGIN
 DisposHandle(command_table);
 error := MemError;

 IF error <> NoErr THEN
 good_unbuild := FALSE;

 command_table := NIL;
 END;
 END;   { ------ MC_UnBuild_Menu_Command_Table ------ }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_Fetch_Menu_Command }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE MC_Fetch_Menu_Command (command_table: Handle;
 menu_info: LONGINT;
 VAR menu_command: INTEGER);
 TYPE
 t_menu_selection = RECORD
 ms_menu_id: INTEGER;
 ms_menu_item: INTEGER;
 END;
 VAR
 menu_selection: t_menu_selection; { info about selected menu item }
 cmd_table: pt_command_list_h;{ menu command table }
 command_info: pt_command_info;    { menu command info }
 list_size: Size; { physical byte size of command list }
 list_records: pt_word;  { no. records in command list }
 BEGIN  { ---------- MC_Fetch_Menu_Command ---------- }
 { assume the command will NOT be found }
 menu_command := MC_c_NoCommand;

 { determine the selected menu ID and menu ITEM }
 menu_selection := t_menu_selection(menu_info);

 IF command_table <> NIL THEN
 BEGIN
 cmd_table := pt_command_list_h(command_table);
 list_size := GetHandleSize(command_table);
 list_records := list_size DIV SIZEOF(command_info);

 WHILE list_records >= 1 DO
 BEGIN
 {$PUSH}
 {$R-}
 command_info := cmd_table^^[list_records];
 {$POP}

 WITH menu_selection, command_info DO
 IF (ms_menu_id = ci_menu_id) AND (ms_menu_item = ci_menu_item) THEN
 BEGIN
 menu_command := ci_command_number; { !!! GOTCHA !!! }
 END;

 list_records := list_records - 1;
 END; { WHILE list_records }
 END;
 END;   { ---------- MC_Fetch_Menu_Command ---------- }

{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ • Routine ... MC_Fetch_Menu_ID_and_Item }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
PROCEDURE MC_Fetch_Menu_ID_and_Item (command_table: Handle;    { in }
 menu_command: INTEGER; { in }
 VAR menu_id: INTEGER; { out }
 VAR menu_item: INTEGER); { out }
 VAR
 command_info: pt_command_info;  { menu command info }
 table_index: pt_word; { index of command in menu command table }
 BEGIN  { ---------- MC_Fetch_Menu_ID_and_Item ---------- }
 { assume no command match will occur }
 menu_id := -1;
 menu_item := -1;

 { attempt to locate the inputted command in the menu command table }
 IF command_table <> NIL THEN
 BEGIN
 find_Command_in_Table(pt_command_list_h(command_table), menu_command, 
table_index, command_info);
 IF table_index >= 1 THEN
 BEGIN
{ command found in table --> return command’s menu stuff }
 menu_id := command_info.ci_menu_id;
 menu_item := command_info.ci_menu_item;
 END;
 END;
 END;   { ---------- MC_Fetch_Menu_ID_and_Item ---------- }
END.  { UNIT UMenuCommand }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }
{ •                                                        • }
{ •                          FINIS                         • }
{ •                                                        • }
{ •••••••••••••••••••••••••••••••••••••••••••••••••••••••••• }

 
AAPL
$524.94
Apple Inc.
+5.93
MSFT
$40.01
Microsoft Corpora
-0.39
GOOG
$536.10
Google Inc.
-20.44

MacTech Search:
Community Search:

Software Updates via MacUpdate

VMware Fusion 6.0.3 - Run Windows apps a...
VMware Fusion allows you to create a Virtual Machine on your Mac and run Windows (including Windows 8.1) and Windows software on your Mac. Run your favorite Windows applications alongside Mac... Read more
Tweetbot 1.5.1 - Popular iOS twitter cli...
Tweetbot is a full-featured OS X Twitter client with a lot of personality. Whether it's the meticulously-crafted interface, sounds and animation, or features like multiple timelines and column views... Read more
Mac DVDRipper Pro 4.1.7 - Copy, backup,...
Mac DVDRipper Pro is the DVD backup solution that lets you protect your DVDs from scratches, save your batteries by reading your movies from your hard disk, manage your collection with just a few... Read more
PDFpenPro 6.2 - Advanced PDF toolkit for...
PDFpenPro allows users to edit PDF's easily. Add text, images and signatures. Fill out PDF forms. Merge or split PDF documents. Reorder and delete pages. Even correct text and edit graphics! Create... Read more
PDFpen 6.2 - Edit and annotate PDFs with...
PDFpen allows users to easily edit PDF's. Add text, images and signatures. Fill out PDF forms. Merge or split PDF documents. Reorder and delete pages. Even correct text and edit graphics! Features... Read more
Monolingual 1.5.9 - Remove unwanted OS X...
Monolingual is a program for removing unnecesary language resources from OS X, in order to reclaim several hundred megabytes of disk space. It requires a 64-bit capable Intel-based Mac and at least... Read more
Maya 2015 - Professional 3D modeling and...
Maya is an award-winning software and powerful, integrated 3D modeling, animation, visual effects, and rendering solution. Because Maya is based on an open architecture, all your work can be scripted... Read more
Starcraft II: Wings of Liberty 1.1.1.180...
Download the patch by launching the Starcraft II game and downloading it through the Battle.net connection within the app. Starcraft II: Wings of Liberty is a strategy game played in real-time. You... Read more
Sibelius 7.5.0 - Music notation solution...
Sibelius is the world's best-selling music notation software for Mac. It is as intuitive to use as a pen, yet so powerful that it does most things in less than the blink of an eye. The demo includes... Read more
Typinator 5.9 - Speedy and reliable text...
Typinator turbo-charges your typing productivity. Type a little. Typinator does the rest. We've all faced projects that require repetitive typing tasks. With Typinator, you can store commonly used... Read more

Latest Forum Discussions

See All

This Week at 148Apps: April 14-18, 2014
Spring Into Our App Reviews   | Read more »
Have a Special Dead Trigger 2 Easter Bas...
Have a Special Dead Trigger 2 Easter Basket Full of Goodies, Courtesy of Madfinger Games Posted by Rob Rich on April 18th, 2014 [ permalink ] Dead Trigger 2 | Read more »
Almost All of Playdek’s Library is on Sa...
Almost All of Playdek’s Library is on Sale Right Now, and You Should Check it Out Posted by Rob Rich on April 18th, 2014 [ permalink ] Playdek has released quite a few great iOS ports of board and card games over the years, and now most of them... | Read more »
Zynga Launches Brand New Farmville Exper...
Zynga Launches Brand New Farmville Experience with Farmville 2: Country Escape Posted by Tre Lawrence on April 18th, 2014 [ permalink ] | Read more »
David. Review
David. Review By Cata Modorcea on April 18th, 2014 Our Rating: :: MINIMALISTIC IN A DIFFERENT WAYUniversal App - Designed for iPhone and iPad David is a minimalistic game wrapped inside of a soothing atmosphere in which the hero... | Read more »
Eyefi Unveils New Eyefi Cloud Service Th...
Eyefi Unveils New Eyefi Cloud Service That Allows Users to Share Media Across Personal Devices Posted by Tre Lawrence on April 18th, 2014 [ permalink ] | Read more »
Tales from the Dragon Mountain: The Lair...
Tales from the Dragon Mountain: The Lair Review By Jennifer Allen on April 18th, 2014 Our Rating: :: STEADY ADVENTURINGiPad Only App - Designed for the iPad Treading a safe path, Tales from the Dragon Mountain: The Lair is a... | Read more »
Yahoo Updates Flickr App with Advanced E...
Yahoo Updates Flickr App with Advanced Editing Features and More Posted by Tre Lawrence on April 18th, 2014 [ permalink ] | Read more »
My Incredible Body - A Kid's App to...
My Incredible Body - A Kid's App to Learn about the Human Body 1.1.00 Device: iOS Universal Category: Education Price: $2.99, Version: 1.1.00 (iTunes) Description: Wouldn’t it be cool to look inside yourself and see what was going on... | Read more »
Trials Frontier Review
Trials Frontier Review By Carter Dotson on April 18th, 2014 Our Rating: :: A ROUGH LANDINGUniversal App - Designed for iPhone and iPad Trials Frontier finally brings the famed stunt racing franchise to mobile, but how much does its... | Read more »

Price Scanner via MacPrices.net

Deal Alert! 13-inch MacBook Pro on sale for $...
Best Buy has the 13″ 2.5GHz MacBook Pro on sale for $999.99 on their online store. Choose free shipping or free instant local store pickup (if available). Their price is $200 off MSRP. Price is valid... Read more
Free HopTo 2.2 Helps Enhance Your Productivit...
The HopTo app helps you do more on your iPad by providing more and easier adaccess to files and documents. Version 2.2 adds Egnyte and HopTo’s Mac OSX File Connector. If you already have the hopTo... Read more
National Distracted Driving Awareness Month:...
As the country recognizes National Distracted Driving Awareness Month, Sprint is reminding wireless consumers to focus on driving while behind the wheel, to not text or email while driving, and to... Read more
13-inch 2.4GHz Retina MacBook Pro available f...
Abt has the 13″ 2.4GHz 128GB Retina MacBook Pro available for $1229 including free shipping. Their price is $70 off MSRP. Read more
iMacs on sale for up to $160 off MSRP this we...
Best Buy has iMacs on sale for up to $160 off MSRP for a limited time. Choose free home shipping or free instant local store pickup (if available). Prices are valid for online orders only, in-store... Read more
iPad Airs on sale this weekend for up to $100...
Best Buy has WiFi iPad Airs on sale for $50 off MSRP and WiFi + Cellular iPad Airs on sale for $100 off MSRP on their online store for a limited time, with prices now starting at $449. Choose free... Read more
Apple restocks refurbished Mac minis starting...
The Apple Store has restocked Apple Certified Refurbished Mac minis for up to $150 off the cost of new models. Apple’s one-year warranty is included with each mini, and shipping is free: - 2.5GHz Mac... Read more
Hyundai Brings Apple CarPlay To The 2015 Sona...
Hyundai Motor America has announced it will bring Apple CarPlay functionality to the 2015 Sonata. CarPlay is pitched as a smarter, safer and easier way to use iPhone in the car and gives iPhone users... Read more
Updated iPads Coming Sooner Than We Had Thoug...
MacRumors, cites KGI securities analyst Ming Chi Kuo, well-respected as an Apple product prognisticator, saying that Apple will introduce an upgraded iPad Air and iPad mini in 2014/Q3, meaning the... Read more
Toshiba Unveils New High And Low End Laptop M...
Toshiba has announced new laptop models covering both the high-end and low-end of the notebook computer spectrum. Toshiba 4K Ultra HD Laptop Toshiba’s new Satellite P55t features one of the world’s... Read more

Jobs Board

Position Opening at *Apple* - Apple (United...
…customers purchase our products, you're the one who helps them get more out of their new Apple technology. Your day in the Apple Store is filled with a range of Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
*Apple* Inc. Research Data Specialist - Appl...
…of Worldwide Market Research & Intelligence. The team is responsible for conducting Apple branded consumer market research. It is also responsible for analyzing data Read more
*Apple* Automotive Parts Department position...
Apple Automotive is one of the fastest growing dealer…and it shows. Consider making the switch to the Apple Automotive Group today! At Apple Automotive, we Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.