// ---------------------------------------------------------------------------
//
// -----------
bool bToolShape::edit_event(EventRef evt, WindowRef wd){
bool b=true;
HICommand cmd;
ControlRef c;
ControlID cid={kShapeEditSign,kShapeCenterID};
if(GetEventClass(evt)==kEventClassCommand){
GetEventParameter(evt,kEventParamDirectObject,typeHICommand,NULL,sizeof(HICommand),NULL,&cmd);
switch(cmd.commandID){
case kHICommandOK:
GetControlByID(wd,&cid,&c);
_ctr=GetControl32BitValue(c);
cid.id=kShapeOpenFicheID;
GetControlByID(wd,&cid,&c);
_opn=GetControl32BitValue(c);
cid.id=kShapeCMMeasID;
GetControlByID(wd,&cid,&c);
_cm=GetControl32BitValue(c);
break;
case kHICommandCancel:
break;
default:
b=false;
break;
}
}
return(b);
}
void doUpdateWindow(EventRecord *eventStrucPtr)
{
IMAGE *img;
WindowRef windowRef;
Rect srcRect, destRect, fillRect;
PixMapHandle srcPixmapHdl, destPixmapHdl;
RGBColor grayColour = { 0xC000,0xC000,0xC000 };
SInt32 hScroll, vScroll;
windowRef = (WindowRef) eventStrucPtr->message;
img = (IMAGE*)GetWRefCon(windowRef);
srcPixmapHdl = img->pixmapHdl;
destPixmapHdl = GetPortPixMap(GetWindowPort(windowRef));
hScroll = GetControl32BitValue(img->scrollbarHorizRef);
vScroll = GetControl32BitValue(img->scrollbarVertRef);
if (srcPixmapHdl)
{
PixMap *pixmap = *srcPixmapHdl;
PixPatHandle hdlPixPat = NewPixPat();
MakeRGBPat(hdlPixPat, &grayColour);
GetWindowPortBounds(windowRef,&destRect);
destRect.right -= kScrollBarWidth;
destRect.bottom -= kScrollBarWidth;
if (destRect.right > pixmap->bounds.right)
{
fillRect.top = destRect.top;
fillRect.bottom = destRect.bottom;
fillRect.left = pixmap->bounds.right;
fillRect.right = destRect.right;
FillCRect(&fillRect, hdlPixPat);
destRect.right = pixmap->bounds.right;
}
if (destRect.bottom > pixmap->bounds.bottom)
{
fillRect.top = pixmap->bounds.bottom;
fillRect.bottom = destRect.bottom;
fillRect.left = destRect.left;
fillRect.right = destRect.right;
FillCRect(&fillRect, hdlPixPat);
destRect.bottom = pixmap->bounds.bottom;
}
DisposePixPat(hdlPixPat);
srcRect = destRect;
srcRect.left += hScroll;
srcRect.right += hScroll;
srcRect.top += vScroll;
srcRect.bottom += vScroll;
CopyBits((BitMap*)*srcPixmapHdl, (BitMap*)*destPixmapHdl,
&srcRect, &destRect, srcCopy, NULL);
}
DrawGrowIcon(windowRef);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// AURenderQualityPopup::HandleControlChange
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void AURenderQualityPopup::HandleControlChange ()
{
UInt32 renderQuality;
int val = GetControl32BitValue(mControl);
switch (val) {
case 1:
renderQuality = kRenderQuality_Max;
break;
case 2:
renderQuality = kRenderQuality_High;
break;
case 3:
renderQuality = kRenderQuality_Medium;
break;
case 4:
renderQuality = kRenderQuality_Low;
break;
case 5:
renderQuality = kRenderQuality_Min;
break;
}
AudioUnitSetProperty (mView->GetEditAudioUnit(),
kAudioUnitProperty_RenderQuality,
kAudioUnitScope_Global,
0,
&renderQuality,
sizeof(renderQuality));
mView->Update (true);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// AURenderQualityPopup::HandlePropertyChange
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void AURenderQualityPopup::HandlePropertyChange(UInt32 quality)
{
int item;
switch (quality) {
case kRenderQuality_Max:
item = 1;
break;
case kRenderQuality_High:
item = 2;
break;
case kRenderQuality_Medium:
item = 3;
break;
case kRenderQuality_Low:
item = 4;
break;
case kRenderQuality_Min:
item = 5;
break;
}
// only set the control value if it is different from the current value
UInt32 value = GetControl32BitValue(mControl);
if (item != (int)value)
SetControl32BitValue(mControl, item);
}
static pascal OSStatus MacOSXDialogCommandProcess(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void* inUserData)
{
HICommand aCommand;
OSStatus status = eventNotHandledErr;
GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &aCommand);
switch (aCommand.commandID)
{
case kHICommandOK:
// we got a valid click on the OK button so let's quit our local run loop
QuitAppModalLoopForWindow((WindowRef) inUserData);
break;
case 'CBED':
{
// we still enable or disable the custom spot view depending on whether the box is checked or not
HIViewRef checkBox = ((HICommandExtended *)&aCommand)->source.control;
SInt32 enable = GetControl32BitValue(checkBox);
HIViewID hidcsv = {0, 13};
HIViewRef customSpotView;
HIViewFindByID(HIViewGetRoot(GetControlOwner(checkBox)), hidcsv, &customSpotView);
if (enable)
ActivateControl(customSpotView);
else
DeactivateControl(customSpotView);
HIViewSetNeedsDisplay(customSpotView, true);
}
break;
}
return status;
}
static pascal OSStatus InputRateTextEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData)
{
OSStatus err, result = eventNotHandledErr;
HIViewRef ctl, slider;
HIViewID cid;
SInt32 value;
char num[10];
err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &ctl);
if (err == noErr)
{
cid.signature = 'snd_';
cid.id = iNibSInputRate;
HIViewFindByID(HIViewGetSuperview(ctl), cid, &slider);
value = GetControl32BitValue(slider);
value /= 50;
value *= 50;
if (value > 33000)
value = 33000;
if (value < 31000)
value = 31000;
SetControl32BitValue(slider, value);
sprintf(num, "%ld", value);
SetEditTextCStr(ctl, num, true);
result = noErr;
}
return (result);
}
/*****************************************************
*
* Handle_PostLittleArrowsClick(inHandlerCallRef, inEvent, inUserData)
*
* Purpose: called to update the static text with the current value of the little arrows control
*
* Inputs: inHandlerCallRef - reference to the current handler call chain
* inEvent - the event
* inUserData - app-specified data you passed in the call to InstallEventHandler
*
* Returns: OSStatus - noErr indicates the event was handled
* eventNotHandledErr indicates the event was not handled and the Toolbox should take over
*/
static pascal OSStatus Handle_PostLittleArrowsClick(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData)
{
OSStatus status = eventNotHandledErr;
ControlRef littleArrows = (ControlRef)inUserData;
SInt32 value = GetControl32BitValue(littleArrows);
HIViewID staticTextID = { 'STTC', 100 };
HIViewRef staticText;
status = HIViewFindByID(HIViewGetRoot(GetControlOwner(littleArrows)), staticTextID, &staticText);
require_noerr(status, HIViewFindByID);
require(littleArrows != NULL, HIViewFindByID);
CFStringRef theValueStr = CFStringCreateWithFormat(NULL, NULL, CFSTR("%ld"), value);
require(theValueStr != NULL, CFStringCreateWithFormat);
HIViewSetText(staticText, theValueStr);
CFRelease(theValueStr);
CFStringCreateWithFormat:
HIViewFindByID:
if (status == noErr)
status = eventNotHandledErr;
return status;
} // Handle_PostLittleArrowsClick
static pascal void LittleArrowsActionProc (HIViewRef arrows, HIViewPartCode partCode)
{
HIViewRef ctl;
HIViewID cid = { 'msc2', iNibMTurboSkipText };
char num[8];
if (partCode == kControlUpButtonPart)
SetControl32BitValue(arrows, GetControl32BitValue(arrows) + 1);
else
if (partCode == kControlDownButtonPart)
SetControl32BitValue(arrows, GetControl32BitValue(arrows) - 1);
HIViewFindByID(HIViewGetSuperview(arrows), cid, &ctl);
sprintf(num, "%ld", GetControl32BitValue(arrows));
SetStaticTextCStr(ctl, num, true);
}
// ---------------------------------------------------------------------------
//
// ------------
bool bvDefScaleRef::wd_event(EventRef evt, WindowRef wd){
bool b=true;
UInt32 clss=GetEventClass(evt);
HICommand cmd;
ControlRef c;
bGenericUnit* u;
if(clss==kEventClassCommand){
GetEventParameter(evt,kEventParamDirectObject,typeHICommand,NULL,sizeof(HICommand),NULL,&cmd);
switch(cmd.commandID){
case kHICommandOK:
write();
break;
case kHICommandCancel:
break;
case kvDefScaleRefPopupCmd:
c=get_control(kvDefScaleRefViewSignature,kvDefScaleRefPopupID);
_idx=GetControl32BitValue(c);
if(_idx>2){
u=_gapp->scaleMgr()->get(_idx-2);
_scale=u->coef();
}
else{
_scale=0;
}
break;
default:
b=false;
break;
}
}
return(b);
}
void AUVPresets::HandleControlChange ()
{
#if !__LP64__
SInt32 i = GetControl32BitValue(mControl);
if (i > 0)
{
AUPreset* preset = (AUPreset*) CFArrayGetValueAtIndex (mPresets, i-1);
verify_noerr(AudioUnitSetProperty (mView->GetEditAudioUnit(),
mPropertyID, // either currentPreset or PresentPreset depending on which is supported
kAudioUnitScope_Global,
0,
preset,
sizeof(AUPreset)));
// when we change a preset we can't expect the AU to update its state
// as it isn't meant to know that its being viewed!
// so we broadcast a notification to all listeners that all parameters on this AU have changed
AudioUnitParameter changedUnit;
changedUnit.mAudioUnit = mView->GetEditAudioUnit();
changedUnit.mParameterID = kAUParameterListener_AnyParameter;
verify_noerr (AUParameterListenerNotify (NULL, NULL, &changedUnit) );
}
#endif
}
// ---------------------------------------------------------------------------
//
// -----------
void bToolPrintArea::puts(WindowRef wd){
ControlRef c;
ControlID cid={kPrintAreaSignature,0};
put_area(wd);
cid.id=kPrintAreaDrawAreaID;
GetControlByID(wd,&cid,&c);
bool vis=GetControl32BitValue(c);
if(vis!=_draw){
clearTempPathContext(true);
_draw=vis;
_gapp->printMgr()->set_print_area(&_vxr);
update(true);
validTempPathContext();
}
else if(_draw){
clearTempPathContext(true);
_gapp->printMgr()->set_print_area(&_vxr);
update(true);
validTempPathContext();
}
else{
_gapp->printMgr()->set_print_area(&_vxr);
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// kChangeDiskStreaming::HandlePropertyChange
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void AUDiskStreamingCheckbox::HandlePropertyChange(UInt32 streaming)
{
// only set the control value if it is different from the current value
UInt32 value = GetControl32BitValue(mControl);
if (streaming != value)
SetControl32BitValue(mControl, streaming);
}
void TrackbarActionProcPtr (ControlRef theControl, ControlPartCode partCode)
{
CvTrackbar * trackbar = icvTrackbarByHandle (theControl);
if (trackbar == NULL)
{
fprintf(stderr,"Erreur recuperation trackbar\n");
return;
}
else
{
if ( trackbar->data )
*trackbar->data = GetControl32BitValue (theControl);
if ( trackbar->notify )
trackbar->notify(GetControl32BitValue (theControl));
}
}
pascal OSStatus DirectEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData)
{
if (GetControl32BitValue(inUserData))
BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY,NULL); // disable proxy
else
BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY,proxy); // enable proxy
return noErr;
}
long AUCarbonViewControl::GetValue()
{
#if !__LP64__
return GetControl32BitValue(mControl);
#else
return 0;
#endif
}
void tool_wind_fill_group_combo(void)
{
int n,group_idx;
char str[256];
CFStringRef cf_str;
HMHelpContentRec tag;
// old settings
group_idx=GetControl32BitValue(group_combo);
// delete old control and menu
DisposeControl(group_combo);
DeleteMenu(160);
DisposeMenu(group_menu);
// recreate the menu
CreateNewMenu(group_combo_menu_id,0,&group_menu);
cf_str=CFStringCreateWithCString(kCFAllocatorDefault,"No Group",kCFStringEncodingMacRoman);
AppendMenuItemTextWithCFString(group_menu,cf_str,0,FOUR_CHAR_CODE('gp01'),NULL);
CFRelease(cf_str);
AppendMenuItemTextWithCFString(group_menu,NULL,kMenuItemAttrSeparator,0,NULL);
for (n=0;n<map.ngroup;n++) {
sprintf(str,"%s (%d)",map.groups[n].name,group_count(n));
cf_str=CFStringCreateWithCString(kCFAllocatorDefault,str,kCFStringEncodingMacRoman);
AppendMenuItemTextWithCFString(group_menu,cf_str,0,FOUR_CHAR_CODE('gp03'),NULL);
CFRelease(cf_str);
}
InsertMenu(group_menu,kInsertHierarchicalMenu);
// recreate the contorl
CreatePopupButtonControl(toolwind,&group_box,NULL,group_combo_menu_id,FALSE,0,0,0,&group_combo);
Draw1Control(group_combo);
// build the help
tag.version=kMacHelpVersion;
tag.tagSide=kHMDefaultSide;
SetRect(&tag.absHotRect,0,0,0,0);
tag.content[kHMMinimumContentIndex].contentType=kHMCFStringContent;
tag.content[kHMMinimumContentIndex].u.tagCFString=CFStringCreateWithCString(NULL,"Segment Groups",kCFStringEncodingMacRoman);
tag.content[kHMMaximumContentIndex].contentType=kHMNoContent;
HMSetControlHelpContent(group_combo,&tag);
// reset the control
SetControl32BitValue(group_combo,group_idx);
}
/*
* update vumeterWindow to reflect actual volume and bandwith information
*/
void CARBON_GUI::updateVumeters() {
ControlID cid= { CARBON_GUI_APP_SIGNATURE , 0 };
ControlRef control;
SInt32 val;
OSStatus err;
/* volume */
cid.id=VUMETER_VOL;
err=GetControlByID(vumeterWindow,&cid,&control);
if(err!=noErr) msg->error("Can't get vbar control (%d)!!",err);
val=GetControl32BitValue(control);
if(val!=vumeter)
{
char vdescr[256];
SetControl32BitValue(control,vumeter);
cid.id=VUMETER_VOL_DESCR;
err=GetControlByID(vumeterWindow,&cid,&control);
if(err!=noErr) msg->error("Can't get volume descr control (%d)!!",err);
sprintf(vdescr,"%d",vumeter);
err=SetControlData(control,0,kControlStaticTextTextTag,strlen(vdescr),vdescr);
}
/* bitrate */
cid.id=VUMETER_BITRATE;
err=GetControlByID(vumeterWindow,&cid,&control);
if(err!=noErr) msg->error("Can't get vbar control (%d)!!",err);
val=GetControl32BitValue(control);
if(val!=vuband)
{
char bpsdescr[256];
SetControl32BitValue(control,vuband);
cid.id=VUMETER_BITRATE_DESCR;
err=GetControlByID(vumeterWindow,&cid,&control);
if(err!=noErr) msg->error("Can't get bps descr control (%d)!!",err);
if(vuband<1000)
sprintf(bpsdescr,"%d B/s",vuband);
else if(vuband>1000 && vuband <1000000)
sprintf(bpsdescr,"%d KB/s",vuband/1000);
else
sprintf(bpsdescr,"%d MB/s",vuband/1000000);
err=SetControlData(control,0,kControlStaticTextTextTag,strlen(bpsdescr),bpsdescr);
}
}
static void ScrollBar32BitActionProc(ControlRef theControl, ControlPartCode partCode)
{
// this is Mac OS 8 or 9 style so the controls can now handle 32 bits value (hence a max of 2147483647)
SInt32 oldValue = GetControl32BitValue(theControl);
switch (partCode)
{
case kControlUpButtonPart: SetControl32BitValue(theControl, oldValue - 1); break;
case kControlDownButtonPart: SetControl32BitValue(theControl, oldValue + 1); break;
case kControlPageUpPart: SetControl32BitValue(theControl, oldValue - 10); break;
case kControlPageDownPart: SetControl32BitValue(theControl, oldValue + 10); break;
}
SInt32 newValue = GetControl32BitValue(theControl);
// let's display the value in the edit text control associated with this control
theControl = (ControlRef)GetControlReference(theControl);
Str255 theStr;
NumToString(newValue, theStr);
SetControlData(theControl, kControlEntireControl, kControlEditTextTextTag, theStr[0], &theStr[1]);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// AURenderQualityPopup::HandleControlChange
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void AUDiskStreamingCheckbox::HandleControlChange ()
{
UInt32 streaming = GetControl32BitValue(mControl);
AudioUnitSetProperty (mView->GetEditAudioUnit(),
kMusicDeviceProperty_StreamFromDisk,
kAudioUnitScope_Global,
0,
&streaming,
sizeof(streaming));
}
pascal void TempoEventHandler(ControlHandle control, SInt16 part)
{
float p=(float)GetControl32BitValue(control);
char c[20];
// set new tempo
BASS_ChannelSetAttribute(chan, BASS_ATTRIB_TEMPO, p);
// update tempo static text
sprintf(c,"Tempo = %d%%", (long)p);
SetStaticText(12,c);
}
//-----------------------------------------------------------------------------
void MadShiftaVerticalFillSlider::draw(DGGraphicsContext * inContext)
{
// draw background
inContext->setFillColor(kControlBackgroundColor);
inContext->fillRect( getBounds() );
// calculate coordinates of "on" portion
inContext->setFillColor(kControlFillColor);
SInt32 min = GetControl32BitMinimum(carbonControl);
SInt32 max = GetControl32BitMaximum(carbonControl);
SInt32 val = GetControl32BitValue(carbonControl);
float valNorm = ((max-min) == 0) ? 0.0f : (float)(val-min) / (float)(max-min);
DGRect onRect( getBounds() );
long onBottom;
if (valNorm > axis)
{
onRect.y = (long) (getBounds()->h * valNorm);
onBottom = (long) (getBounds()->h * axis);
}
else
{
onRect.y = (long) (getBounds()->h * axis);
onBottom = (long) (getBounds()->h * valNorm);
}
onRect.y = getBounds()->h - onRect.y;
onBottom = getBounds()->h - onBottom;
onRect.h = onBottom - onRect.y;
if (onRect.h < 1)
{
onRect.h = 1;
inContext->setFillColor(kControlFillColor_alt);
}
onRect.y += getBounds()->y;
// draw "on" portion
inContext->fillRect(&onRect);
// draw the text display
if (textProc != NULL)
{
char text[kDGTextDisplay_stringSize];
text[0] = 0;
textProc(getAUVP().GetValue(), text, NULL);
DGRect textBounds( getBounds() );
textBounds.y += textY;
textBounds.h = textHeight;
inContext->setFont(kValueDisplayTextFont, kSliderTextSize);
inContext->setColor(kValueDisplayTextColor);
inContext->drawText(&textBounds, text, kDGTextAlign_center);
}
}
// ---------------------------------------------------------------------------
//
// -----------
void bToolPrintArea::pop_kind_action(WindowRef wd){
ControlRef c;
ControlID cid={kPrintAreaSignature,0};
int k;
put_area(wd);
cid.id=kPrintAreaPopKindID;
GetControlByID(wd,&cid,&c);
k=GetControl32BitValue(c);
switch(k){
case kPrintAreaPopKindMenuGeo:
set_as_geo(wd);
cid.id=kPrintAreaFrameCustomSizeID;
GetControlByID(wd,&cid,&c);
ShowControl(c);
cid.id=kPrintAreaFrameStandardSizeID;
GetControlByID(wd,&cid,&c);
HideControl(c);
break;
case kPrintAreaPopKindMenuPix:
set_as_pix(wd);
cid.id=kPrintAreaFrameCustomSizeID;
GetControlByID(wd,&cid,&c);
ShowControl(c);
cid.id=kPrintAreaFrameStandardSizeID;
GetControlByID(wd,&cid,&c);
HideControl(c);
break;
case kPrintAreaPopKindMenuCustom:
set_as_ppsz(wd);
cid.id=kPrintAreaFrameCustomSizeID;
GetControlByID(wd,&cid,&c);
ShowControl(c);
cid.id=kPrintAreaFrameStandardSizeID;
GetControlByID(wd,&cid,&c);
HideControl(c);
break;
case kPrintAreaPopKindMenuStandard:
cid.id=kPrintAreaFrameCustomSizeID;
GetControlByID(wd,&cid,&c);
HideControl(c);
cid.id=kPrintAreaFrameStandardSizeID;
GetControlByID(wd,&cid,&c);
ShowControl(c);
cid.id=kPrintAreaPopSizeID;
GetControlByID(wd,&cid,&c);
SetControl32BitValue(c,_pprkind);
break;
}
_sizekind=k;
}
pascal void TimerProc(EventLoopTimerRef inTimer, void *inUserData)
{
float ratio=BASS_FX_TempoGetRateRatio(chan);
if (!ratio) return;
SetControl32BitValue(GetControl(15),(DWORD)BASS_ChannelBytes2Seconds(chan,BASS_ChannelGetPosition(chan,BASS_POS_BYTE))); // update position
{ // show the approximate position in MM:SS format
char c[50];
DWORD totalsec=GetControl32BitMaximum(GetControl(15))/ratio;
DWORD posec=GetControl32BitValue(GetControl(15))/ratio;
sprintf(c,"Playing position: %02u:%02u / %02u:%02u",posec/60,posec%60,totalsec/60,totalsec%60);
SetStaticText(14,c);
}
}
double AUCarbonViewControl::GetValueFract()
{
#if !__LP64__
SInt32 minimum = GetControl32BitMinimum(mControl);
SInt32 maximum = GetControl32BitMaximum(mControl);
SInt32 cval = GetControl32BitValue(mControl);
double result = double(cval - minimum) / double(maximum - minimum);
// printf("get: min=%ld, max=%ld, value=%ld, result=%f\n", minimum, maximum, cval, result);
return result;
#else
return 0;
#endif
}
static pascal void AutofireSliderActionProc (HIViewRef slider, HIViewPartCode partCode)
{
HIViewRef ctl;
HIViewID cid;
char num[10];
GetControlID(slider, &cid);
cid.signature = 'Num_';
HIViewFindByID(HIViewGetSuperview(slider), cid, &ctl);
sprintf(num, "%ld", GetControl32BitValue(slider));
SetStaticTextCStr(ctl, num, true);
}
static pascal void InputRateSliderActionProc (HIViewRef slider, HIViewPartCode partCode)
{
HIViewRef ctl;
HIViewID cid;
char num[10];
cid.signature = 'snd_';
cid.id = iNibSInputRateText;
HIViewFindByID(HIViewGetSuperview(slider), cid, &ctl);
sprintf(num, "%ld", GetControl32BitValue(slider));
SetStaticTextCStr(ctl, num, true);
}
pascal void actionFunctionScroll(ControlRef controlRef,ControlPartCode controlPartCode)
{
SInt32 scrollDistance, controlValue, oldControlValue, controlMax;
if(controlPartCode != kControlNoPart)
{
if(controlPartCode != kControlIndicatorPart)
{
switch(controlPartCode)
{
case kControlUpButtonPart:
case kControlDownButtonPart:
scrollDistance = 10;
break;
case kControlPageUpPart:
case kControlPageDownPart:
scrollDistance = 100;
break;
default:
scrollDistance = 0;
break;
}
if (scrollDistance)
{
if((controlPartCode == kControlDownButtonPart) ||
(controlPartCode == kControlPageDownPart))
scrollDistance = -scrollDistance;
controlValue = GetControl32BitValue(controlRef);
if(((controlValue == GetControl32BitMaximum(controlRef)) && scrollDistance < 0) ||
((controlValue == GetControl32BitMinimum(controlRef)) && scrollDistance > 0))
return;
oldControlValue = controlValue;
controlMax = GetControl32BitMaximum(controlRef);
controlValue = oldControlValue - scrollDistance;
if(controlValue < 0)
controlValue = 0;
else if(controlValue > controlMax)
controlValue = controlMax;
SetControl32BitValue(controlRef,controlValue);
}
}
}
}
pascal ComponentResult VP8_Encoder_DITLRemove(VP8EncoderGlobals storage,
DialogRef d,
short itemOffset)
{
ControlRef cRef;
UInt32 onePass;
GetDialogItemAsControl(d, kItemOnePass + itemOffset, &cRef);
onePass = GetControl32BitValue(cRef);
(*storage).settings[1] = onePass?1:2;
return noErr;
}
static void AutofireWriteAllSettings (int player, HIViewRef parent)
{
HIViewRef ctl;
HIViewID cid;
AutofireWriteSetting(player * 1, &(autofireRec[player - 1].buttonMask), parent);
AutofireWriteSetting(player * 11, &(autofireRec[player - 1].toggleMask), parent);
AutofireWriteSetting(player * 111, &(autofireRec[player - 1].tcMask), parent);
AutofireWriteSetting(player * 1111, &(autofireRec[player - 1].invertMask), parent);
cid.id = player;
cid.signature = 'Slid';
HIViewFindByID(parent, cid, &ctl);
autofireRec[player - 1].frequency = GetControl32BitValue(ctl);
}
static pascal OSStatus AutofireTabEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData)
{
#pragma unused (inHandlerRef, inUserData)
OSStatus result = eventNotHandledErr;
HIViewRef ctl;
HIViewID cid;
SInt32 value;
GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, nil, sizeof(ControlRef), nil, &ctl);
GetControlID(ctl, &cid);
value = GetControl32BitValue(ctl);
if ((cid.id == 256) && (value != autofireLastTabIndex))
{
AutofireSelectTabPane(ctl, value);
result = noErr;
}
return result;
}
