static int CreateApplicationWindow (AWindowRecord *wr, char *fname, short h, short v, short dh, short dv)
{
Rect r;
GrafPtr myPort;
PaletteHandle myPalette;
char name[80];
/* init AWindowRecord */
wr->theWindow = (WindowPtr) wr;
/* read in resources */
if (GetNewCWindow(appWinId,(Ptr)wr,(WindowPtr) -1)==NULL)
{
return(1);
}
myPalette = GetNewPalette(defaultPaletteId);
SetPalette(wr->theWindow,myPalette,false);
/* move and size window */
myPort = (GrafPtr) wr->theWindow;
SetPort(myPort);
MoveWindow(wr->theWindow,h,v,false);
SizeWindow(wr->theWindow,dh+15,dv+15,false);
strcpy(name,fname);
SetWTitle(wr->theWindow,c2pstr(name));
ShowWindow(wr->theWindow);
SelectWindow(wr->theWindow);
DrawGrowIcon(wr->theWindow);
r = myPort->portRect;
TextFont(kFontIDMonaco);
/* get the scroll bars */
wr->vScrollBar = GetNewControl(vScrollBarId,wr->theWindow);
wr->hScrollBar = GetNewControl(hScrollBarId,wr->theWindow);
/* set correct size of the scroll bars */
MoveControl(wr->vScrollBar,r.right-15,-1);
SizeControl(wr->vScrollBar,16,r.bottom-13);
SetControlMinimum(wr->vScrollBar,0);
SetControlMaximum(wr->vScrollBar,0);
SetControlValue(wr->vScrollBar,0);
ShowControl(wr->vScrollBar);
MoveControl(wr->hScrollBar,-1,r.bottom-15);
SizeControl(wr->hScrollBar,r.right-13,16);
SetControlMinimum(wr->hScrollBar,0);
SetControlMaximum(wr->hScrollBar,0);
SetControlValue(wr->hScrollBar,0);
ShowControl(wr->hScrollBar);
DrawControls(wr->theWindow);
SetRect(&(wr->usableRect),0,0,dh,dv);
return(0);
}
static void window_adjust_scrollbars(WindowRef windowRef)
{
IMAGE *img;
Rect portRect;
img = (IMAGE*)GetWRefCon(windowRef);
GetWindowPortBounds(windowRef,&portRect);
/* Move the crollbars to the edges of the window */
HideControl(img->scrollbarVertRef);
HideControl(img->scrollbarHorizRef);
MoveControl(img->scrollbarVertRef,portRect.right - kScrollBarWidth,
portRect.top - 1);
MoveControl(img->scrollbarHorizRef,portRect.left - 1,
portRect.bottom - kScrollBarWidth);
SizeControl(img->scrollbarVertRef,kScrollBarWidth + 1,
portRect.bottom - portRect.top - kScrollBarWidth + 1);
SizeControl(img->scrollbarHorizRef, portRect.right - portRect.left - kScrollBarWidth + 1,
kScrollBarWidth + 1);
/* Adjust the scroll position showing */
if (img->pixmapHdl)
{
PixMap *pixmap = *(img->pixmapHdl);
int visibleHeight = portRect.bottom - portRect.top - kScrollBarWidth;
int visibleWidth = portRect.right - portRect.left - kScrollBarWidth;
if (pixmap->bounds.bottom > visibleHeight)
{
SetControl32BitMaximum(img->scrollbarVertRef,
pixmap->bounds.bottom - visibleHeight);
SetControlViewSize(img->scrollbarVertRef,visibleHeight);
}
else
SetControlMaximum(img->scrollbarVertRef, 0);
if (pixmap->bounds.right > visibleWidth)
{
SetControl32BitMaximum(img->scrollbarHorizRef,
pixmap->bounds.right - visibleWidth);
SetControlViewSize(img->scrollbarHorizRef, visibleWidth);
}
else
SetControlMaximum(img->scrollbarHorizRef, 0);
}
ShowControl(img->scrollbarVertRef);
ShowControl(img->scrollbarHorizRef);
}
void
InitScrollBar(ControlHandle sb)
{
short lines;
short max;
short height;
TEPtr te;
TEHandle currTE;
switch(gCurrWin)
{
case kLicenseID:
currTE = gControls->lw->licTxt;
break;
default:
ErrorHandler(eUnknownDlgID, nil);
break;
}
lines = TEGetHeight((**currTE).nLines,0,currTE) / kScrollAmount;
te = *currTE; // point to TERec for convenience
height = te->viewRect.bottom - te->viewRect.top;
max = lines - (height / kScrollAmount);
if (height % kScrollAmount) max++;
if ( max < 0 ) max = 0;
SetControlMaximum(sb, max);
}
void PreferencesDialog::initDialog()
{
ControlHandle popupButtonControl;
ControlID popupButtonControlID = {kAppSignature, 130};
MenuRef menu;
GetControlByID(preferencesWindow, &popupButtonControlID, &popupButtonControl);
GetControlData(popupButtonControl, kControlEntireControl, kControlPopupButtonMenuRefTag, sizeof(menu), &menu, NULL);
unsigned int nPorts = midiin ? midiin->getPortCount() : 0;
if (nPorts)
{
UInt32 numItems = CountMenuItems(menu);
DeleteMenuItems(menu, 1, numItems);
// Check inputs.
std::string portName;
unsigned int nSelectedDevice = 0;
for (unsigned int i = 0; i < nPorts; i++ )
{
try
{
portName = midiin->getPortName(i);
}
catch (RtMidiError &error)
{
error.printMessage();
}
if (strcmp(portName.c_str(), m_dataBase->restore(KEY_MIDIDEVICE)->getStringValue()) == 0)
nSelectedDevice = i;
CFStringRef CFStrPortName = CFStringCreateWithCString(NULL, portName.c_str(), kCFStringEncodingASCII);
AppendMenuItemTextWithCFString(menu, CFStrPortName, 0, kMIDIDeviceBaseCommand + i, 0);
CFRelease(CFStrPortName);
}
/*AppendMenuItemTextWithCFString(menu, CFSTR("Temp1"), 0, kMIDIDeviceBaseCommand + 1, 0);
AppendMenuItemTextWithCFString(menu, CFSTR("Temp2"), 0, kMIDIDeviceBaseCommand + 2, 0);
nPorts+=2;*/
SetControlMaximum(popupButtonControl, nPorts);
SetControlValue(popupButtonControl, nSelectedDevice + 1);
storeMidiDeviceName(nSelectedDevice);
EnableControl(popupButtonControl);
}
else
{
DisableControl(popupButtonControl);
}
updateControls();
updateSliderVelocityAmplify();
}
void
XGProgress::SetMaxValue (long max)
{
if (fMax == max)
return;
fMax = max;
if (fValue > fMax)
fValue = fMax;
if (fMax <= 16384)
fScale = 1;
else
fScale = fMax / 16384;
#if OPT_MACOS
if (fControl) {
XGDraw draw(this, false);
SetControlMaximum(fControl, fMax / fScale);
SetControlValue(fControl, fValue / fScale);
return;
}
#endif
#if OPT_WINOS
if (fControl) {
::SendMessage(fControl, PBM_SETRANGE, 0, MAKELPARAM(fMin / fScale, fMax / fScale));
return;
}
#endif
InvalView();
}
OSStatus setProgress(int cur, int max)
{
OSStatus err;
ControlRef progressBar = NULL;
ControlID id;
id.signature = 'prog';
id.id = 0;
err = GetControlByID(gWindow, &id, &progressBar);
if(err == noErr)
{
Boolean indeterminate;
if(max == 0)
{
indeterminate = true;
err = SetControlData(progressBar, kControlEntireControl, kControlProgressBarIndeterminateTag, sizeof(Boolean), (Ptr)&indeterminate);
}
else
{
double percentage = (double)cur / (double)max;
SetControlMinimum(progressBar, 0);
SetControlMaximum(progressBar, 100);
SetControlValue(progressBar, (SInt16)(percentage * 100));
indeterminate = false;
err = SetControlData(progressBar, kControlEntireControl, kControlProgressBarIndeterminateTag, sizeof(Boolean), (Ptr)&indeterminate);
Draw1Control(progressBar);
}
}
return(err);
}
void
AddServiceToPopupMenu(char * serviceType, UInt16 serviceLen, UInt16 * serviceMenuItem)
{
ControlID controlID = { kNSLSample, kServicesTypePopup };
ControlRef control;
CFStringRef tempService = NULL;
CFStringRef menuText = NULL;
char tempServiceString[kMaxTypeNameLength];
CFComparisonResult result = -1;
MenuRef menu;
OSStatus err = noErr;
short itemCount, i;
if (serviceType)
{
err = GetControlByID(gMainWindow, &controlID, &control);
if (err == noErr)
{
strncpy(tempServiceString, serviceType, serviceLen);
tempServiceString[serviceLen] = '\0';
for (i = 0; i < serviceLen; i++) tempServiceString[i] = toupper(tempServiceString[i]);
tempService = CFStringCreateWithCString(NULL, tempServiceString, CFStringGetSystemEncoding());
if (tempService)
{
menu = GetControlPopupMenuHandle(control);
itemCount = CountMenuItems(menu);
for (i = 1; i <= itemCount; i ++)
{
CopyMenuItemTextAsCFString(menu, i , &menuText);
if (menuText)
{
result = CFStringCompare(menuText, tempService, kCFCompareCaseInsensitive);
if (result == kCFCompareEqualTo)
{
if (serviceMenuItem) *serviceMenuItem = i;
break;
}
}
}
if (result != kCFCompareEqualTo)
{
err = AppendMenuItemTextWithCFString(menu, tempService, 0, 0, serviceMenuItem);
if (err == noErr)
{
SetControlMaximum(control, itemCount + 1);
if (serviceMenuItem) *serviceMenuItem = itemCount + 1;
}
CFRelease(tempService);
}
}
}
}
}
static void progress_update(void *param, int action, int phase, int iprogress)
{
struct progress *p = (struct progress *) param;
unsigned progress = iprogress;
int position;
if (action < PROGFN_READY && p->nphases < phase)
p->nphases = phase;
switch (action) {
case PROGFN_INITIALISE:
p->nphases = 0;
break;
case PROGFN_LIN_PHASE:
p->phases[phase-1].exponential = 0;
p->phases[phase-1].mult = p->phases[phase].total / progress;
break;
case PROGFN_EXP_PHASE:
p->phases[phase-1].exponential = 1;
p->phases[phase-1].param = 0x10000 + progress;
p->phases[phase-1].current = p->phases[phase-1].total;
p->phases[phase-1].n = 0;
break;
case PROGFN_PHASE_EXTENT:
p->phases[phase-1].total = progress;
break;
case PROGFN_READY:
{
unsigned total = 0;
int i;
for (i = 0; i < p->nphases; i++) {
p->phases[i].startpoint = total;
total += p->phases[i].total;
}
p->total = total;
p->divisor = ((p->total + PROGRESSRANGE - 1) / PROGRESSRANGE);
p->range = p->total / p->divisor;
SetControlMaximum(p->progbar, p->range);
}
break;
case PROGFN_PROGRESS:
if (p->phases[phase-1].exponential) {
while (p->phases[phase-1].n < progress) {
p->phases[phase-1].n++;
p->phases[phase-1].current *= p->phases[phase-1].param;
p->phases[phase-1].current /= 0x10000;
}
position = (p->phases[phase-1].startpoint +
p->phases[phase-1].total - p->phases[phase-1].current);
} else {
position = (p->phases[phase-1].startpoint +
progress * p->phases[phase-1].mult);
}
SetControlValue(p->progbar, position / p->divisor);
break;
}
}
OSStatus
SyncPopupButtonToMenu( ControlRef popupButton )
{
OSStatus err;
MenuRef menu;
err = GetPopupButtonMenuRef( popupButton, &menu );
if ( err == noErr )
{
if ( CountMenuItems( menu ) >= 1 )
{
SetControlMaximum( popupButton, CountMenuItems( menu ) );
SetControlMinimum( popupButton, 1 );
}
else
{
SetControlMinimum( popupButton, 0 );
SetControlMaximum( popupButton, 0 );
}
}
return err;
}
void XGPopControl::ReloadItems (void)
{
MenuHandle menu;
int ix, len;
char buf[256];
if (!fControl)
return;
XGDraw draw(this,false);
menu = GetMenuHandle();
if (!menu)
return;
#if TARGET_CARBON
for (ix = CountMenuItems(menu); ix > 0; ix--) DeleteMenuItem(menu, ix);
#else
for (ix = CountMItems(menu); ix > 0; ix--) DeleteMenuItem(menu, ix);
#endif
for (ix = 0; ix < fList.GetNumStrings(); ix++) {
fList.GetString(ix, buf);
len = strlen(buf);
memmove(&buf[1], buf, len);
buf[0] = len;
AppendMenu(menu, "\px");
SetMenuItemText(menu, ix + 1, (unsigned char *)buf);
}
#if TARGET_CARBON
SetControlMaximum(fControl, CountMenuItems(menu));
#else
SetControlMaximum(fControl, CountMItems(menu));
#endif
SetControlValue(fControl, fValue + 1);
}
static void mac_clickkey(WindowPtr window, EventRecord *event)
{
short item;
DialogRef dialog;
KeyState *ks = mac_windowkey(window);
dialog = GetDialogFromWindow(window);
if (DialogSelect(event, &dialog, &item))
switch (item) {
case wiKeyGenerate:
SetControlMaximum(ks->progress, 1024);
ks->entropy = snewn(1024, unsigned int);
ks->entropy_required = 1024;
ks->entropy_got = 0;
ks->collecting_entropy = TRUE;
/* Do something */
break;
}
}
/* SetPopMenuMax(theDialog, popupItemNumber)
The Mac OS Control Manager needs to be told how many items are in the menu each time we change it.
Thread Safety: SetPopMenuMax is not thread-safe.
*/
static int
SetPopMenuMax(DialogPtr theDialog, int popupItemNumber)
{
ControlHandle controlH;
MenuHandle mH;
int numMenuItems;
int err;
if (err = XOPGetDialogItemAsControl(theDialog, popupItemNumber, &controlH))
return err;
if (err = GetDialogPopupMenuMenuHandle(theDialog, popupItemNumber, &mH))
return err;
numMenuItems = CountMenuItems(mH); // Number of items in the menu.
SetControlMaximum(controlH, numMenuItems); // Tell the control manager.
return 0;
}
void
OPL_LoginDialog::fill_dir_menu(char *path)
{
char *tmp_dir, *prov, *dir;
MenuRef items_m;
int i = -1;
ControlRef f_select;
getControl(kLoginDIR, &f_select);
if (!path || !(prov = strdup (path)))
return;
if (prov[strlen(prov) - 1] == '/' && strlen(prov) > 1)
prov[strlen(prov) - 1] = 0;
items_m = GetControlPopupMenuHandle (f_select);
DeleteMenuItems (items_m, 1, CountMenuItems (items_m));
/* Add the root directory */
AppendMenuItemTextWithCFString(items_m, CFSTR("/"), 0, 0, NULL);
for (tmp_dir = prov, dir = NULL; tmp_dir;
tmp_dir = strchr (tmp_dir + 1, '/'))
{
if (strchr (tmp_dir + 1, '/'))
{
dir = strchr (tmp_dir + 1, '/');
*dir = 0;
}
AppendMenuItemTextWithCFString(items_m, OPL_char_to_CFString(prov), 0, 0, NULL);
if (dir)
*dir = '/';
}
i = CountMenuItems (items_m);
SetControlMaximum (f_select, i);
SetControlValue (f_select, i);
if (cur_dir)
free(cur_dir);
cur_dir = prov;
}
static void fill_dir_menu(TDSNCHOOSER *dsnchoose_t, char *path)
{
char *curr_dir, *prov, *dir;
MenuRef items_m;
int i = -1;
CFStringRef str;
ControlRef f_select = dsnchoose_t->fdir;
if (!path || !(prov = strdup (path)))
return;
if (prov[strlen(prov) - 1] == '/' && strlen(prov) > 1)
prov[strlen(prov) - 1] = 0;
items_m = GetControlPopupMenuHandle (f_select);
DeleteMenuItems (items_m, 1, CountMenuItems (items_m));
/* Add the root directory */
AppendMenuItemTextWithCFString(items_m, CFSTR("/"), 0, 0, NULL);
if (strlen(prov) > 1)
for (curr_dir = prov, dir = NULL; curr_dir;
curr_dir = strchr (curr_dir + 1, '/'))
{
if (strchr (curr_dir + 1, '/'))
{
dir = strchr (curr_dir + 1, '/');
*dir = 0;
}
str = CFStringCreateWithCString(NULL, prov, kCFStringEncodingUTF8);
AppendMenuItemTextWithCFString(items_m, str, 0, 0, NULL);
if (dir)
*dir = '/';
}
i = CountMenuItems (items_m);
SetControlMaximum (f_select, i);
SetControlValue (f_select, i);
strncpy(dsnchoose_t->curr_dir, prov, sizeof(dsnchoose_t->curr_dir));
}
void
ShowTerminalWin(void)
{
Str255 next, back;
Handle rectH;
Rect viewRect;
short reserr;
MenuHandle popupMenu;
PopupPrivateData ** pvtDataHdl;
unsigned char * currMenuItem;
short i, vRefNum;
long cwdDirID, dirID;
Boolean isDir = false;
Str255 pModulesDir;
OSErr err = noErr;
GrafPtr oldPort;
GetPort(&oldPort);
if (gWPtr != NULL)
{
SetPort(gWPtr);
gCurrWin = kTerminalID;
/* gControls->tw = (TermWin*) NewPtrClear(sizeof(TermWin)); */
GetResourcedString(next, rInstList, sInstallBtn);
GetResourcedString(back, rInstList, sBackBtn);
// malloc and get control
rectH = Get1Resource('RECT', rStartMsgBox);
reserr = ResError();
if (reserr == noErr && rectH != NULL)
{
viewRect = (Rect) **((Rect **)rectH);
ReleaseResource(rectH);
}
else
{
ErrorHandler(reserr, nil);
return;
}
gControls->tw->siteSelector = NULL;
gControls->tw->saveBitsCheckbox = NULL;
gControls->tw->startMsgBox = viewRect;
gControls->tw->startMsg = TENew(&viewRect, &viewRect);
if (gControls->tw->startMsg == NULL)
{
ErrorHandler(eMem, nil);
return;
}
// save bits after download and install
/* get the "Installer Modules" relative subdir */
ERR_CHECK(GetCWD(&cwdDirID, &vRefNum));
GetIndString(pModulesDir, rStringList, sInstModules);
GetDirectoryID(vRefNum, cwdDirID, pModulesDir, &dirID, &isDir);
if (isDir)
{
if (!ExistArchives(vRefNum, dirID)) // going to download
{
if (gControls->cfg->numSites > 0)
{
// download settings groupbox
Str255 dlSettingsGBTitle;
gControls->tw->dlSettingsGB = GetNewControl(rDLSettingsGB, gWPtr);
if (gControls->tw->dlSettingsGB)
{
GetResourcedString(dlSettingsGBTitle, rInstList, sDLSettings);
SetControlTitle(gControls->tw->dlSettingsGB, dlSettingsGBTitle);
ShowControl(gControls->tw->dlSettingsGB);
}
// site selector label
Str255 siteSelMsgStr;
gControls->tw->siteSelMsg = GetNewControl(rSiteSelMsg, gWPtr);
if (gControls->tw->siteSelMsg)
{
GetResourcedString(siteSelMsgStr, rInstList, sSiteSelMsg);
SetControlData(gControls->tw->siteSelMsg, kControlNoPart,
kControlStaticTextTextTag, siteSelMsgStr[0], (Ptr)&siteSelMsgStr[1]);
ShowControl(gControls->tw->siteSelMsg);
}
// site selector
gControls->tw->siteSelector = GetNewControl( rSiteSelector, gWPtr );
if (!gControls->tw->siteSelector)
{
ErrorHandler(eMem, nil);
return;
}
// populate popup button menus
HLock((Handle)gControls->tw->siteSelector);
pvtDataHdl = (PopupPrivateData **) (*(gControls->tw->siteSelector))->contrlData;
HLock((Handle)pvtDataHdl);
popupMenu = (MenuHandle) (**pvtDataHdl).mHandle;
for (i=0; i<gControls->cfg->numSites; i++)
{
HLock(gControls->cfg->site[i].desc);
currMenuItem = CToPascal(*gControls->cfg->site[i].desc);
HUnlock(gControls->cfg->site[i].desc);
InsertMenuItem( popupMenu, currMenuItem, i );
}
HUnlock((Handle)pvtDataHdl);
HUnlock((Handle)gControls->tw->siteSelector);
SetControlMaximum(gControls->tw->siteSelector, gControls->cfg->numSites);
SetControlValue(gControls->tw->siteSelector, gControls->opt->siteChoice);
ShowControl(gControls->tw->siteSelector);
}
// show check box and message
gControls->tw->saveBitsCheckbox = GetNewControl( rSaveCheckbox, gWPtr );
if (!gControls->tw->saveBitsCheckbox)
{
ErrorHandler(eMem, nil);
return;
}
if (gControls->opt->saveBits)
SetControlValue(gControls->tw->saveBitsCheckbox, 1);
ShowControl(gControls->tw->saveBitsCheckbox);
// get rect for save bits message
rectH = Get1Resource('RECT', rSaveBitsMsgBox);
reserr = ResError();
if (reserr == noErr && rectH != NULL)
{
gControls->tw->saveBitsMsgBox = (Rect) **((Rect **)rectH);
DisposeHandle(rectH);
}
else
{
ErrorHandler(reserr, nil);
return;
}
// get text edit record for save bits message
gControls->tw->saveBitsMsg = TENew(&gControls->tw->saveBitsMsgBox,
&gControls->tw->saveBitsMsgBox );
if (gControls->tw->saveBitsMsg == NULL)
{
ErrorHandler(eMem, nil);
return;
}
HLock(gControls->cfg->saveBitsMsg);
TESetText(*gControls->cfg->saveBitsMsg, strlen(*gControls->cfg->saveBitsMsg),
gControls->tw->saveBitsMsg);
HUnlock(gControls->cfg->saveBitsMsg);
// show save bits msg
TEUpdate(&gControls->tw->saveBitsMsgBox, gControls->tw->saveBitsMsg);
// proxy settings button
gControls->tw->proxySettingsBtn = GetNewControl(rProxySettgBtn, gWPtr);
if (!gControls->tw->proxySettingsBtn)
{
ErrorHandler(eMem, nil);
return;
}
Str255 proxySettingsTitle;
GetResourcedString(proxySettingsTitle, rInstList, sProxySettings);
SetControlTitle(gControls->tw->proxySettingsBtn, proxySettingsTitle);
ShowControl(gControls->tw->proxySettingsBtn);
}
}
// populate control
HLock(gControls->cfg->startMsg);
TESetText(*gControls->cfg->startMsg, strlen(*gControls->cfg->startMsg),
gControls->tw->startMsg);
HUnlock(gControls->cfg->startMsg);
// show controls
TEUpdate(&viewRect, gControls->tw->startMsg);
ShowNavButtons( back, next );
}
SetPort(oldPort);
}
OSErr
RunAllXPIs(short xpiVRefNum, long xpiDirID, short vRefNum, long dirID)
{
OSErr err = noErr;
FSSpec tgtDirSpec, xpiStubDirSpec, xpiSpec;
XPI_InitProc xpi_initProc;
XPI_InstallProc xpi_installProc;
XPI_ExitProc xpi_exitProc;
CFragConnectionID connID;
nsresult rv = NS_OK;
StringPtr pcurrArchive;
int i, len, compsDone = 0, numXPIs, currXPICount = 0, instChoice = gControls->opt->instChoice-1;
Boolean isCurrXPI = false, indeterminateFlag = false;
Str255 installingStr, msg;
StringPtr pTargetSubfolder = "\p"; /* subfolder is optional so init empty */
long dummyDirID = 0;
err = FSMakeFSSpec(vRefNum, dirID, kViewerFolder, &xpiStubDirSpec); /* xpistub dir */
if (gControls->cfg->targetSubfolder)
{
HLock(gControls->cfg->targetSubfolder);
if (*gControls->cfg->targetSubfolder)
pTargetSubfolder = CToPascal(*gControls->cfg->targetSubfolder);
HUnlock(gControls->cfg->targetSubfolder);
}
err = FSMakeFSSpec(gControls->opt->vRefNum, gControls->opt->dirID, /* program dir */
pTargetSubfolder, &tgtDirSpec);
if (err == fnfErr)
err = FSpDirCreate(&tgtDirSpec, smSystemScript, &dummyDirID);
if (err != noErr)
{
ErrorHandler(err, nil);
return err;
}
ERR_CHECK_MSG(LoadXPIStub(&xpi_initProc, &xpi_installProc, &xpi_exitProc, &connID, xpiStubDirSpec, msg), err, msg);
XPI_ERR_CHECK(xpi_initProc( xpiStubDirSpec, tgtDirSpec, NULL, xpicbProgress ));
// init overall xpi indicator
numXPIs = CountSelectedXPIs();
if (gControls->tw->allProgressBar)
{
SetControlMaximum(gControls->tw->allProgressBar, numXPIs*2); // numXPIs * 2 so that prog bar moves more
SetControlData(gControls->tw->allProgressBar, kControlNoPart, kControlProgressBarIndeterminateTag,
sizeof(indeterminateFlag), (Ptr) &indeterminateFlag);
SetControlValue(gControls->tw->allProgressBar, 0);
Draw1Control(gControls->tw->allProgressBar);
}
if (gControls->tw->xpiProgressBar)
ShowControl(gControls->tw->xpiProgressBar);
// enumerate through all .xpi's
// loop through 0 to kMaxComponents
for(i=0; i<kMaxComponents; i++)
{
BreathFunc();
// general test: if component in setup type
if ( (gControls->cfg->st[instChoice].comp[i] == kInSetupType) &&
(compsDone < gControls->cfg->st[instChoice].numComps) )
{
// if custom and selected, or not custom setup type
// add file to buffer
if ( ((instChoice == gControls->cfg->numSetupTypes-1) &&
(gControls->cfg->comp[i].selected == true)) ||
(instChoice < gControls->cfg->numSetupTypes-1) )
{
// if LAUNCHAPP and DOWNLOAD_ONLY attr wasn't set
if (!gControls->cfg->comp[i].launchapp && !gControls->cfg->comp[i].download_only)
{
HLock(gControls->cfg->comp[i].archive);
pcurrArchive = CToPascal(*gControls->cfg->comp[i].archive);
HUnlock(gControls->cfg->comp[i].archive);
isCurrXPI = IsArchiveXPI(pcurrArchive);
err = FSMakeFSSpec(xpiVRefNum, xpiDirID, pcurrArchive, &xpiSpec);
if (err==noErr && isCurrXPI)
{
// update package display name
if (gControls->tw->allProgressMsg)
{
ProgressMsgInit();
GetResourcedString(installingStr, rInstList, sInstalling);
TEInsert(&installingStr[1], installingStr[0], gControls->tw->allProgressMsg);
HLock(gControls->cfg->comp[i].shortDesc);
len = strlen(*gControls->cfg->comp[i].shortDesc);
TEInsert(*gControls->cfg->comp[i].shortDesc, (len>64?64:len), gControls->tw->allProgressMsg);
HUnlock(gControls->cfg->comp[i].shortDesc);
}
err = RunXPI(xpiSpec, &xpi_installProc);
BreathFunc();
if (err != NS_OK)
break;
// update progess bar
if (gControls->tw->allProgressBar)
SetControlValue(gControls->tw->allProgressBar,
GetControlValue(gControls->tw->allProgressBar)+1);
}
if (pcurrArchive)
DisposePtr((Ptr) pcurrArchive);
}
compsDone++;
}
}
else if (compsDone >= gControls->cfg->st[instChoice].numComps)
break;
}
xpi_exitProc();
UnloadXPIStub(&connID);
if (pTargetSubfolder)
DisposePtr((Ptr)pTargetSubfolder);
return err;
}
void
xpicbProgress(const char* msg, PRInt32 val, PRInt32 max)
{
Boolean indeterminateFlag = false;
Rect r;
Str255 installingStr, fileStr, ofStr;
char *valStr, *maxStr, *leaf;
StringPtr pleaf = nil;
long last;
GrafPtr oldPort;
GetPort(&oldPort);
if (gWPtr)
{
SetPort(gWPtr);
if (gControls->tw->xpiProgressBar)
{
if (!bProgMsgInit)
ProgressMsgInit();
if (max!=0 && !bMaxDiscovered)
{
SetControlData(gControls->tw->xpiProgressBar, kControlNoPart, kControlProgressBarIndeterminateTag,
sizeof(indeterminateFlag), (Ptr) &indeterminateFlag);
SetControlMaximum(gControls->tw->xpiProgressBar, max);
if (gControls->tw->allProgressBar)
SetControlValue(gControls->tw->allProgressBar,
GetControlValue(gControls->tw->allProgressBar)+1);
bMaxDiscovered = true;
}
else if (!bMaxDiscovered)
{
if (gWPtr)
IdleControls(gWPtr);
if (gControls->tw->xpiProgressMsg)
{
HLock((Handle)gControls->tw->xpiProgressMsg);
SetRect(&r, (*gControls->tw->xpiProgressMsg)->viewRect.left,
(*gControls->tw->xpiProgressMsg)->viewRect.top,
(*gControls->tw->xpiProgressMsg)->viewRect.right,
(*gControls->tw->xpiProgressMsg)->viewRect.bottom );
HUnlock((Handle)gControls->tw->xpiProgressMsg);
if (msg)
{
EraseRect(&r);
GetResourcedString(installingStr, rInstList, sProcessing);
leaf = strrchr(msg, ':');
if (leaf)
{
pleaf = CToPascal(leaf+1);
pstrcat(installingStr, pleaf);
}
else
{
installingStr[0] = 1;
installingStr[1] = ' ';
}
last = installingStr[0] + 1;
if (last > 255)
last = 255;
installingStr[last] = 0;
if (installingStr[0] > 0)
TESetText(&installingStr[1], installingStr[0], gControls->tw->xpiProgressMsg);
TEUpdate(&r, gControls->tw->xpiProgressMsg);
if (pleaf)
DisposePtr((Ptr) pleaf);
}
}
}
if (bMaxDiscovered)
{
SetControlValue(gControls->tw->xpiProgressBar, val);
if (gControls->tw->xpiProgressMsg)
{
GetResourcedString(installingStr, rInstList, sProcessing);
GetResourcedString(fileStr, rInstList, sFileSp);
GetResourcedString(ofStr, rInstList, sSpOfSp);
HLock((Handle)gControls->tw->xpiProgressMsg);
SetRect(&r, (*gControls->tw->xpiProgressMsg)->viewRect.left,
(*gControls->tw->xpiProgressMsg)->viewRect.top,
(*gControls->tw->xpiProgressMsg)->viewRect.right,
(*gControls->tw->xpiProgressMsg)->viewRect.bottom );
HUnlock((Handle)gControls->tw->xpiProgressMsg);
valStr = ltoa(val);
maxStr = ltoa(max);
EraseRect(&r);
if (valStr && maxStr)
{
TESetText(&installingStr[1], installingStr[0], gControls->tw->xpiProgressMsg);
TEInsert(&fileStr[1], fileStr[0], gControls->tw->xpiProgressMsg);
TEInsert(valStr, strlen(valStr), gControls->tw->xpiProgressMsg);
TEInsert(&ofStr[1], ofStr[0], gControls->tw->xpiProgressMsg);
TEInsert(maxStr, strlen(maxStr), gControls->tw->xpiProgressMsg);
TEUpdate(&r, gControls->tw->xpiProgressMsg);
}
if (valStr)
free(valStr);
if (maxStr)
free(maxStr);
}
}
}
}
SetPort(oldPort);
return;
}
