TweetFollow Us on Twitter

XCMD CookBook
Volume Number:4
Issue Number:6
Column Tag:

XCMD CookBook

By Donald Koscheka, Apple Computer, Inc.

[Donald Koscheka is a Software Engineer employed by Apple Computer Inc. He has written some very important development XCMDs which you will hear about soon. -HyperEd]

Introduction to XCMD’s

If you’ve used Hypercard and its programming language HyperTalk for any length of time, you’ve no doubt discovered some of the things that you can’t do with Hypercard. Perhaps you’re writing a forms generator in HyperTalk and you want to be able to print customized reports. The designers of Hypercard knew that their product would have to be a lot of things to a lot of people and it would be nearly impossible to provide every possible feature in the language. They did, however, provide us with the capability of customizing HyperCard and HyperTalk directly. To paraphrase Abraham Lincoln, “You can fool some of the people all of the time, or all of the people some of the time, but to fool all of the people all of the time, write an XCMD”.

As a programming language, HyperTalk is highly extensible; you can add your own commands and functions to the language very easily. These extensions are known as eXternal CoMmanDs ( XCMDs) and eXternal FunCtioNs (XFCNs). The capital letters, ie. case, are significant as I’ll discuss later. XCMDs and XFCNs are identical at the coding level, so I’ll refer to both as XCMDs. The determination of whether a command will be an XCMD or an XFCN is made at link-time.

Creating an XCMD is a straightforward process. First, you write the XCMD using the language of your choice (I’ll show examples in both “C” and Pascal). Next, you compile and link the XCMD as a resource and then you add it to the resource fork of the stack that you want to call it from, the home stack or even Hypercard itself.

Where you put the XCMD is significant. When Hypercard encounters a command that it does not recognize, it first checks the current object (button or field) to see if it contains any handlers for that command. If no handler is found, the search continues in the following order: card, background, stack, home stack, HyperCard. If after looking in all the places that it could expect to find a handler no handler turns up, Hypercard then searches its own resource fork for any external commands that can handle the command. It identifies the appropriate command by name. Note what this hiearchy implies. If you want your XCMD to be globally visible to all stacks, put the XCMD in HyperCard’s resource fork or Home Card. There is a tradeoff, though. If you want the stack that uses the XCMD to be “portable”, you’ll need to put the XCMD in that stack. There is no conflict of interest here, you can put the XCMD in both places. [Use Rescopy , via scripts, to allow the user the option of installing it into the Home Stack. -HyperEd] Hypercard stops searching as soon as it finds a copy of the command. If it finds a copy in your stack, it’ll stop the search there. If you call the XCMD from another stack that does not contain the XCMD, then it’ll go all the way back to the Home Stack or Hypercard to search for the command.

Now that you have an idea of where to place the XCMD, let’s take a look at how they are created. All XCMDs and XFCNs interface to Hypercard in a standard and straightforward way. When an XCMD is invoked, Hypercard will pass it a parameter block that contains, among other things, the number of parameters and handles to the parameters. For argument’s sake, let’s see how the following XCMD would be called:

Pizza “Cheese”, “Pepperoni”, “Anchovies”

When this XCMD is called, Hypercard will pass a record, referred to as the Parameter Block, to the XCMD. The first argument in the parameter block will be the number of parameters passed; in this case three, one for each item in the argument list. Each parameter is passed as a handle to a zero-terminated text string. Parameter 1 will be a handle to the string “Cheese\0”, where the the ‘\0’ means the character whose ASCII value is 0. “C” programmers will recognize this format as a standard string definition in “C”. Pascal programmers often refer to this format as a C-String. The actual structure of a parameter block (in Pascal) is:

TYPE

  XCmdPtr = ^XCmdBlock;
  XCmdBlock =
    RECORD
      paramCount : INTEGER;     
      params: ARRAY[1..16] OF Handle;
      returnValue: Handle;      
      passFlag : BOOLEAN; 
      
      entryPoint :  ProcPtr;  { to call back to HyperCard }
      request    :  INTEGER;  
      result:  INTEGER;  
      inArgs:  ARRAY[1..8] OF LongInt;
      outArgs    :  ARRAY[1..4] OF LongInt;
    END;

Let’s examine this record in more detail. First, we define a pointer to the record, called an XCmdPtr. Hypercard passes a pointer to the record so you’ll need to be comfortable with pointers to work with XCMDs.

The first field in the record, paramCount , is a count of the number of parameters that have been passed to the XCMD. This is a number between 1 and 16, which is the maximum size of the parameter array, params, in field 2. Params is an array of handles which implies that the fundamental element in the array is a signed byte.

Field 3 in the record, returnValue, is a handle to the data that you want to return to Hypercard on completion of the XCMD. You create the handle and pass it back to hypercard with the assignment:

 paramPtr^.returnValue := Handle_You_Created;

Herein lies the most important difference between XCMDs and XFCNs. ReturnValue os places in the global container, result, when returning from an XCMD and by value when returning from an XFCN. The following illustrates the mechanics:

 XCMD: Pizza “cheese”, “pepperoni”, “anchovies”
 Put the result

 XFCN: Put Pizza (“cheese”, “pepperoni”, “anchovies”)

XCMDs, like any other command in hypercard, take their parameters on the same line as the command itself. XFCNs, like any other function in Hypercard, take their parameters in parentheses and return a value. This is the most important difference between XCMDs and XFCNs. You make the decision at link-time as to whether a code resource will be an XCMD or an XFCN. Please note, the code is identical for both XCMDs and XFCNs. Hypercard re-vectors ReturnValue for you depending on whether you invoked an XCMD or an XFCN.

The next field, passFlag, should be set to TRUE if you want Hypercard to pass the command on in the hierarchy after invoking the XCMD. Most of the time, you won’t concern yourself with this field.

The next five fields in the parameter block are used for making callbacks to Hypercard [the subject of the next article -DK]. Callbacks allow you to invoke some hypercard commands from within an XCMD, quite a useful feature. An example of a callback is GetFieldByNum which will return a handle to the data in a field on the current card. This is analogous to “Get card field 1” in HyperTalk.

EntryPoint is set by Hypercard on entry to the XCMD and is used as a jumping off point for invoking callbacks. In effect, Hypercard will execute a jump instruction to EntryPoint for all callbacks. But before executing the jump instruction, Hypercard will place an integer value into the Request field. This integer tells Hypercard which callback to execute. The code at entryPoint will vector to the appropriate routine based on the value in Request.

Upon returning from a callback, Hypercard will have set the value of the Result field to some integer value to tell you how things went in the callback. A value of 0 indicates that no error occurred in the callback, 1 indicates that the callback failed for some reason or other and 2 indicates that the callback is not implemented.

The next to last field in the record, inArgs, is an array of up to eight input arguments to the callback. Although the arguments are passed as longInts (long in “C”), they may contain anything. Generally speaking, the Hypercard callback glue will handle type-casting for you.

Finally, callbacks can return up to 4 parameters in OutArgs. These parameters will be set by the callback and available to you from the calling XCMD. Callbacks are glued to the XCMD using standard Pascal interfaces so they’re pretty easy to get along with.

Callbacks are a useful and powerful tool available to the XCMD programmer. Currently, Hypercard includes about thirty callbacks and I’ll discuss each one in more detail next month.

The foregoing discussion implies that you’ll mostly concern yourself with the first four fields in the record and let Hypercard manage the callback parameters. In practice, you’ll mostly be concerned with paramCount, params and returnValue.

For the sake of our “C” readership, here’s the definition of the parameter block as a “C” structure:

typedef struct XCmdBlock {
 short  paramCount;     
      Handle     params[16];
   Handle   returnValue;      
   BooleanpassFlag; 
      
      char  *entryPoint; 
   shortrequest;  
      short result;  
      longinArgs[8];
   long outArgs[4];
   } XCmdBlock, *XCmdBlockPtr;

All Input and Output to an XCMD is passed through the parameter block. Armed with this information, here is a simple XCMD that does absolutely nothing (note: I use MPW Pascal and “C” in my examples).

{******************************************* *}
{* File: SimpleXCMD.p*}
{* *}
{* Shell for XCMDs and XFCNs in MPW Pascal   *}
{* --------------------------------------    *}
{* In:  paramPtr = pointer to the XCMD *}
{* Parameter Block *}
{* *}
{* --------------------------------------    *}
{* © 1988, Donald Koscheka*}
{* --------------------------------------    *}
{******************************************* *}

(******************************
 BUILD SEQUENCE
pascal SimpleXCMD.p
link -m ENTRYPOINT -rt XCMD=6555 
 -sn Main=SimpleXCMD 
 SimpleXCMD.p.o 
 “{Libraries}”Interface.o 
 “{PLibraries}”Paslib.o 
 -o “{xcmds}”your_stack_here

******************************)

{$S SimpleXCMD }

UNIT Donald_Koscheka; 

INTERFACE

USES
 MemTypes, QuickDraw, OSIntf, ToolIntf,
  PackIntf, HyperXCmd;


PROCEDURE EntryPoint( paramPtr: XCmdPtr);

IMPLEMENTATION

{$R-}   
TYPE
 Str31 = String[31]; 

PROCEDURE SimpleXCMD(paramPtr: XCmdPtr); FORWARD;

{--------------EntryPoint----------------}
PROCEDURE EntryPoint(paramPtr: XCmdPtr);
 BEGIN
 SimpleXCMD(paramPtr);
 END;

{----------SimpleXCMD------------------}
PROCEDURE SimpleXCMD(paramPtr: XCmdPtr);
VAR
 i : INTEGER;
 
{$I XCmdGlue.inc }

 BEGIN
 WITH paramPtr^ DO
 BEGIN
   returnValue := NIL;
 END;
 END; 

END.

The Build sequence for this file is included in the header for the sake of convenience. After the compilation, we need to link the code into a resource and add it to some stack. First, let’s take a closer look at the link options. The “-m ENTRYPOINT” option tells the linker that the first line of executable code in the resource is at the label ENTRYPOINT. Next, the “-rt XCMD=6555” option tells the linker that this file whould be written as a resource of type “XCMD” and should be assigned a resource ID of 6555. Because we are writing the resource directly out to the stack named “your_stack_here”, any XCMD with ID 6555 will be overwritten by this link. To link the code as an XFCN, use “-rt XFCN=6555”. That’s about the only difference between XCMDs and XFCNs!

You must remember to note that resource types are case sensitive. Telling the linker to set the resource type to “xcmd” will work fine, only Hypercard won’t recognize the resource as an XCMD. As far as numbering XCMDs goes, I don’t know of any rational system that’s been implemented yet. Follow the number guidelines provided in Inside Macintosh, Chapter five.

The option “-sn Main=SimpleXCMD” tells the linker to change the segment name of the main segment from “Main” to “SimpleXCMD”. “SimpleXCMD.p.o” is the name of the input file, the library includes follow. The last line “-o your_stack_here” instructs the linker to add this XCMD to the resource fork of the stack whose name is “your_stack_here”. Remember to include pathnames in your build.

The build sequence for XCMDs is pretty much a boiler-plate. You’ll change type from XCMD to XFCN, the ID to whatever you want, and the input and output lines. About the most important addition you might make to the build is to add libraries as needed.

The XCMD itself follows the standard layout for a Pascal Unit. The unit name is inconsequential to us. A lot of programmers use “UNIT dummyUnit” to remind themselves of that . I use my name instead.

The interface portion is straightforward. Tell the compiler what files you want to include and declare the interface to your routine. Note that we use “EntryPoint” and not “SimpleXCMD” as the main entrypoint for this routine. I’ll leave it as an exercise to the student to figure what that’s all about.

Note the use of the {$R-} directive in the implementation section. This turns off range checking and results in more efficient code. Although we don’t use the Str31 type declared in the TYPE statement, it is needed by the callbacks so we MUST include it here.

Procedure SimpleXCMD contains the actual code for the XCMD. Note that it takes exactly one parameter, a pointer to an XCmdBlock. Although the VAR statement is not used in the body of the code, I included it here so that those of you that are less fluid in Pascal can clearly see that the {$I XCmdGlue.inc} directive follows the CONST, TYPE and VAR declarations within SimpleXCMD. XCMDGlue contains the glue routines for the callbacks. They are simple compiled with the rest of the code. Because of the scoping of procedures feature of Pascal, the glue routines will be able to access paramPtr directly, you won;t need to pass it to each routine in turn.

Finally, the body of the program. Here we simply set the returnValue to NIL and exit. If you already have code that you want to implement in an XCMD or XFCN, replace the body of SimpleXCMD with the body of your routine and off you go!

PROCEDURE SimpleXCMD(paramPtr: XCmdPtr);
VAR
 i : INTEGER;
 
{$I XCmdGlue.inc }
BEGIN
 WITH paramPtr^ DO
 BEGIN
   returnValue := NIL;
 END;
END; 

XCMDs in “C” are different enough in implementation to bear some discussion. Here is SimpleXCMD in “C”:

/***************************************     *\
*file:  SimpleXCMD.c *
** 
*  XCMD shell in MPW “C”  *
**
*C -q2 SimpleXCMD.c*
*link -sn Main=SimpleXCMD  *
*-sn STDIO=SimpleXCMD    *
*-sn INTENV=SimpleXCMD -rt XCMD=301 *
* SimpleXCMD.c.o -o your_stack_here  *
**
*If you use parts of the “C”  *
*Library, use this *
*link instead:   *
**
*link -sn Main=SimpleXCMD -sn     *
*STDIO=SimpleXCMD *
* -sn INTENV=SimpleXCMD -rt XCMD=301*
* -m SIMPLEXCMD SimpleXCMD.c.o    *
*“{CLibraries}”CRuntime.o  *
*“{CLibraries}”CInterface.o  *
*-o your_stack_here*
**
* ------------------------------------ *
* By: Donald Koscheka*
* Date: 21-Sept-87 *
* ©Copyright 1987, Donald Koscheka *
**
* ------------------------------------ *
\**********************************/

#include<Types.h>
#include<OSUtils.h>
#include<Memory.h>
#include<Files.h>
#include<Resources.h>
#include “HyperXCmd.h”


pascal void SimpleXCMD( paramPtr )
 XCmdBlockPtr  paramPtr;
/*******************************
* SimpleXCMD()
*******************************/
{
 paramPtr->returnValue = nil;
}

#include <XCmdGlue.inc.c>

SimpleXCMD() is defined as a Pascal Void to tell the “C” compiler to push the parameters “Pascal Style”. This means that parameters are pushed from left to right rather than from right to left. Also, we need to inform “C” that this function does not return a value, so we qualify the type with “void”. Otherwise, “C” will leave room on the stack for an integer-wide return value.

An important difference between the two languages is that “C” does not allow scoping of procedures. The callback glue routines are not local to SimpleXCMD as is the case in Pascal. For this reason, when calling glue routines from “C”, the first parameter passed must be a pointer to the XCmdBlock.

When you start programming XCMDs, you may encounter a seemingly nebulous link error, “No Data Initialization”. The linker is telling you that there is no global memory to initialize for the XCMD. XCMDs are code resources, they are designed to be called “subroutine” fashion from Hypercard and as such do not have access to their own globals. Put another way, Hypercard owns the global pool from which XCMDs may draw. This means that the only kind of data that can be declared in an XCMD is local data, also known as automatics. Automatics get created on the stack and exist only for the life of the XCMD. When the XCMD returns to Hypercard, the local memory pool goes away.

You are most likely to encounter a problem with this when using strings in “C”. Consider the following code fragment:

 char *myStr;

   myStr = “Colleen”;

In this code, I declare a string pointer called myStr. I then point this string pointer at the properly formed string ‘Colleen’. This code will compile correctly but the linker will not be able to work with it. When “C” compiles strings in-line, it actually puts the string into the global pool and points myStr at the string in global memory. Since the XCMD is assembled without global memory, the linker won’t know what to do with this code. Pascal does not suffer this fate because it does not put the string into global memory. The following code will compile and link just fine in Pascal:

 myStr  : StrPtr;

 myStr  := ‘Margaret’;

The reason this works in Pascal and not in “C” is that Pascal tacks the string “Margaret” onto the end of the code resource, rather than put the string into global memory.

The upshot of this diatribe is don’t declare global variables from XCMDs. If you need to use strings in “C”, you’ll need to hard-code the assignments:

 myStr[0] = ‘C’;
 myStr[1] = ‘o’;
 myStr[2] = ‘l’;
 myStr[3] = ‘l’;
 myStr[4] = ‘e’;
 myStr[5] = ‘e’;
 myStr[6] = ‘n’;
 myStr[7]= ‘\0’

If your going to be using a lot of strings, I would suggest that you either put them in resources (yuck!) or use Pascal instead.

This article presented the basics of XCMD programming and describes how to interface your code to Hypercard. Next month I’ll introduce the callbacks and give some examples how they can make XCMD programming easier and more fun. If you’re already an experienced Macintosh programmer, the above is information enough to get you started on XCMDs. If you’re just getting started, this article should be just enough to help you get started, without being too much, to get you lost.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Yasu 4.0.0 β - System maintenance app; p...
Yasu was created with System Administrators who service large groups of workstations in mind, Yasu (Yet Another System Utility) was made to do a specific group of maintenance tasks quickly within a... Read more
Skype 7.37.0.178 - Voice-over-internet p...
Skype allows you to talk to friends, family and co-workers across the Internet without the inconvenience of long distance telephone charges. Using peer-to-peer data transmission technology, Skype... Read more
EtreCheck 3.0.5 - For troubleshooting yo...
EtreCheck is an app that displays the important details of your system configuration and allow you to copy that information to the Clipboard. It is meant to be used with Apple Support Communities to... Read more
Amadeus Pro 2.3.1 - Multitrack sound rec...
Amadeus Pro lets you use your Mac computer for any audio-related task, such as live audio recording, digitizing tapes and records, converting between a variety of sound formats, etc. Thanks to its... Read more
NeoFinder 6.9.3 - Catalog your external...
NeoFinder (formerly CDFinder) rapidly organizes your data, either on external or internal disks, or any other volumes. It catalogs all your data, so you stay in control of your data archive or disk... Read more
WhatsApp 0.2.1880 - Desktop client for W...
WhatsApp is the desktop client for WhatsApp Messenger, a cross-platform mobile messaging app which allows you to exchange messages without having to pay for SMS. WhatsApp Messenger is available for... Read more
Hazel 4.0.6 - Create rules for organizin...
Hazel is your personal housekeeper, organizing and cleaning folders based on rules you define. Hazel can also manage your trash and uninstall your applications. Organize your files using a familiar... Read more
Apple iBooks Author 2.5 - Create and pub...
Apple iBooks Author helps you create and publish amazing Multi-Touch books for iPad. Now anyone can create stunning iBooks textbooks, cookbooks, history books, picture books, and more for iPad. All... Read more
MYStuff Pro 2.0.26 - $39.99
MYStuff Pro is the most flexible way to create detail-rich inventories for your home or small business. Add items to MYStuff by dragging and dropping existing information, uploading new images, or... Read more
MarsEdit 3.7.8 - Quick and convenient bl...
MarsEdit is a blog editor for OS X that makes editing your blog like writing email, with spell-checking, drafts, multiple windows, and even AppleScript support. It works with with most blog services... Read more

How to get past Vulture Island's tr...
Vulture Island is a colorful and quirky mish-mash of platforming and puzzles. It’s creative and fresh, but sometimes the game can throw a curveball at you, leaving you stuck as to how you should progress. These tips will help you explore smoothly... | Read more »
The new Clash of Kings is just for Weste...
If you’ve played the original Clash of Kings, you’ll probably recognise the city building, alliance forging and strategic battles in Clash of Kings: The West. What sets this version apart is that it’s tailor made for a Western audience and the... | Read more »
Frost - Survival card game (Games)
Frost - Survival card game 1.12.1 Device: iOS Universal Category: Games Price: $3.99, Version: 1.12.1 (iTunes) Description: *Warning: the game will work on iPhone 5C and above and iPad Pro / 4. Other devices are not supported* | Read more »
How to build and care for your team in D...
Before you hit the trail and become a dog sledding legend, there’s actually a fair bit of prep work to be done. In Dog Sled Saga, you’re not only racing, you’re also building and caring for a team of furry friends. There’s a lot to consider—... | Read more »
How to win every race in Dog Sled Saga
If I had to guess, I’d say Dog Sled Saga is the most adorable racing game on the App Store right now. It’s a dog sled racing sim full of adorable, loyal puppies. Just look at those fluffy little tails wagging. Behind that cute, pixelated facade is... | Read more »
Let the war games commence in Gunship Ba...
Buzz Lightyear famously said, “This isn’t flying, this is falling – with style!” In the case of Gunship Battle: Second War, though, this really is flying - with style! The flight simulator app from Joycity puts you in control of 20 faithfully... | Read more »
How to get a high score in Fired Up
Fired Up is Noodlecake Games’ high score chasing, firefighting adventure. You take control of a wayward firefighter who propels himself up the side of a highrise with blasts of water. Sound silly? It is. It’s also pretty difficult. You can’t... | Read more »
NBA 2K17 (Games)
NBA 2K17 1.0 Device: iOS iPhone Category: Games Price: $7.99, Version: 1.0 (iTunes) Description: Following the record-breaking launch of NBA 2K16, the NBA 2K franchise continues to stake its claim as the most authentic sports video... | Read more »
Dog Sled Saga (Games)
Dog Sled Saga 1.0.1 Device: iOS Universal Category: Games Price: $3.99, Version: 1.0.1 (iTunes) Description: A game by Dan + Lisa As a rookie musher, foster a dogsledding team whose skills will grow if they're treated right. Week by... | Read more »
60 Seconds! Atomic Adventure (Games)
60 Seconds! Atomic Adventure 1.2 Device: iOS Universal Category: Games Price: $2.99, Version: 1.2 (iTunes) Description: 60 Seconds! is a dark comedy atomic adventure of scavenge and survival. Collect supplies and rescue your family... | Read more »

Price Scanner via MacPrices.net

21-inch iMacs on sale for up to $120 off MSRP
B&H Photo has 21″ iMacs on sale for up to $120 off MSRP including free shipping plus NY sales tax only: - 21″ 3.1GHz iMac 4K: $1379 $120 off MSRP - 21″ 2.8GHz iMac: $1199.99 $100 off MSRP - 21″ 1... Read more
13-inch 2.7GHz/256GB Retina MacBook Pro on sa...
Amazon.com has the 13″ 2.7GHz/256GB Retina Apple MacBook Pro on sale for $151 off MSRP including free shipping: - 13″ 2.7GHz/256GB Retina MacBook Pro (sku MF840LL/A): $1348 $151 off MSRP Read more
Apple TVs on sale for up to $50 off MSRP
Best Buy has 32GB and 64GB Apple TVs on sale for $40-$50 off MSRP on their online store. Choose free shipping or free local store pickup (if available). Sale prices for online orders only, in-store... Read more
Apple refurbished 13-inch Retina MacBook Pros...
Apple has Certified Refurbished 13″ Retina MacBook Pros available for up to $270 off the cost of new models. An Apple one-year warranty is included with each model, and shipping is free: - 13″ 2.7GHz... Read more
Duplicate Sweeper Free On Mac App Store For O...
To celebrate the launch of Apple’s latest macOS Sierra, Stafford, United Kingdom based Wide Angle Software has announced that its duplicate file finder software, Duplicate Sweeper, is now available... Read more
13-inch Retina MacBook Pros on sale for up to...
B&H Photo has 13″ Retina Apple MacBook Pros on sale for up to $150 off MSRP. Shipping is free, and B&H charges NY tax only: - 13″ 2.7GHz/128GB Retina MacBook Pro: $1174.99 $125 off MSRP - 13... Read more
Evidence Surfaces Pointing To New A10X Chip F...
Citing a job description for a Project Lead position at Apple’s Austin, Texas engineering labs, Motley Fool’s Ashraf Eassa deduces that development is progressing well on Apple’s next-generation in-... Read more
Check Print’R for macOS Allows Anyone to Easi...
Delaware-based Match Software has announced the release and immediate availability of Check Print’R 3.21, an important update to their easy-to-use check printing application for macOS. Check Print’R... Read more
Apple refurbished 11-inch MacBook Airs availa...
Apple has Certified Refurbished 11″ MacBook Airs (the latest models), available for up to $170 off the cost of new models. An Apple one-year warranty is included with each MacBook, and shipping is... Read more
Apple refurbished 15-inch Retina MacBook Pros...
Apple has Certified Refurbished 2015 15″ Retina MacBook Pros available for up to $380 off the cost of new models. An Apple one-year warranty is included with each model, and shipping is free: - 15″ 2... Read more

Jobs Board

Sr. *Apple* Mac Engineer - Net2Source Inc....
…staffing, training and technology. We have following position open with our client. Sr. Apple Mac Engineer6+ Months CTH Start date : 19th Sept Travelling Job If Read more
*Apple* Retail - Multiple Positions-Norfolk,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Restaurant Manager (Neighborhood Captain) - A...
…in every aspect of daily operation. WHY YOU'LL LIKE IT: You'll be the Big Apple . You'll solve problems. You'll get to show your ability to handle the stress and Read more
Lead *Apple* Solutions Consultant - Apple (...
# Lead Apple Solutions Consultant Job Number: 51829230 Detroit, Michigan, United States Posted: Sep. 19, 2016 Weekly Hours: 40.00 **Job Summary** The Lead ASC is an Read more
US- *Apple* Store Leader Program - Apple (Un...
…Summary Learn and grow as you explore the art of leadership at the Apple Store. You'll master our retail business inside and out through training, hands-on Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.