// --------------------------------------------------------------------------------------
static pascal OSStatus dialogEventHandler(EventHandlerCallRef nextHandler, EventRef event,
void *prefsDialog)
{
#pragma unused (nextHandler)
OSStatus result = eventNotHandledErr;
UInt32 eventClass, eventKind;
ControlRef controlHit;
ControlID controlID;
eventClass = GetEventClass(event);
eventKind = GetEventKind(event);
switch (eventClass)
{
case kEventClassControl:
switch (eventKind)
{
case kEventControlHit:
GetEventParameter(event, kEventParamDirectObject, typeControlRef, NULL,
sizeof(ControlRef), NULL, &controlHit);
GetControlID(controlHit, &controlID);
handleDialogItemHit((DialogRef)prefsDialog, (DialogItemIndex)controlID.id);
result = noErr;
break;
}
break;
}
return result;
}
unsigned CClanMark::Process( unsigned uiMsg, WPARAM wParam, LPARAM lParam )
{
if( uiMsg == WM_LBUTTONDOWN && IsInside( LOWORD( lParam ), HIWORD( lParam )) )
return GetControlID();
return 0;
}
static void CPROC SomeChoiceClicked( uintptr_t psv, PCONTROL pc )
{
PBANNER banner = (PBANNER)psv;
int choice = GetControlID( pc );
#ifdef DEBUG_BANNER_DRAW_UPDATE
lprintf( WIDE( "SOME!" ) );
#endif
banner->flags |= (BANNER_CLOSED);
switch( choice )
{
case IDOK:
banner->flags |= BANNER_OKAY;
case IDCANCEL:
break;
case 3+IDOK:
banner->flags |= BANNER_OKAY;
case 3+IDCANCEL:
banner->flags |= BANNER_EXTENDED_RESULT;
break;
}
{
PTHREAD thread = (banner)->pWaitThread;
if( thread )
{
WakeThread( thread );
}
}
}
unsigned CFriendListItem::Process( unsigned uiMsg, WPARAM wParam, LPARAM lParam )
{
if( !IsInside( LOWORD(lParam), HIWORD( lParam )) ) return 0;
switch( uiMsg )
{
case WM_LBUTTONDOWN:
SetSelected();
return GetControlID();
case WM_LBUTTONDBLCLK:
{
switch( m_btStatus )
{
case FRIEND_STATUS_DELETED:
g_itMGR.OpenMsgBox(CStr::Printf(F_STR_FRIEND_DELETED , m_strName.c_str() ));
g_itMGR.OpenDialog( DLG_TYPE_MEMO, false );
break;
case FRIEND_STATUS_REFUSED:
g_itMGR.OpenMsgBox(CStr::Printf(F_STR_MESSANGER_BLOCKED , m_strName.c_str() ));
break;
default:
{
if( m_btStatus == FRIEND_STATUS_OFFLINE )
{
CTDialog* pDlg = g_itMGR.FindDlg( DLG_TYPE_MEMO );
assert( pDlg );
if( pDlg )
{
CMemoDlg* pMemoDlg = (CMemoDlg*)pDlg;
pMemoDlg->SetTargetName( m_strName.c_str() );
g_itMGR.OpenDialog( DLG_TYPE_MEMO, false );
}
}
else
g_itMGR.OpenPrivateChatDlg( m_dwUserTag, m_btStatus, m_strName.c_str() );
break;
}
}
return GetControlID();
}
default:
break;
}
return 0;
}
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);
}
pascal OSStatus RadioEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData)
{
ControlID cid;
GetControlID(inUserData,&cid);
Size s;
GetControlData(GetControl(40),0,kControlEditTextTextTag,sizeof(proxy)-1,proxy,&s); // get proxy server
proxy[s]=0;
char *url=strdup(urls[cid.id-10]);
// open URL in a new thread (so that main thread is free)
pthread_t tid;
pthread_create(&tid,NULL,OpenURL,url);
pthread_detach(tid);
return noErr;
}
unsigned CJTable::Process( unsigned uiMsg, WPARAM wParam, LPARAM lParam )
{
if( !IsVision() ) return 0;
unsigned uiProcID;
std::vector< CWinCtrl* >::iterator iter;
for( iter = m_ViewItems.begin(); iter != m_ViewItems.end();++iter )
{
uiProcID = (*iter)->Process(uiMsg, wParam, lParam );
if( uiProcID )
{
m_iSelectedItemID = uiProcID;
return GetControlID();
}
}
return 0;
}
OSStatus
TabbedWindow::WindowHandleControlEvent( EventHandlerCallRef handler, EventRef event )
{
OSStatus status = eventNotHandledErr;
// grab the controlRef out of the event
ControlRef controlHitRef;
status = GetEventParameter( event, kEventParamDirectObject, typeControlRef,
NULL, sizeof( ControlRef ), NULL, (void *) &controlHitRef );
require_noerr( status, HandleControlEvent_err );
// grab the id out of the event
ControlID controlHitID;
status = GetControlID( controlHitRef, &controlHitID );
require_noerr( status, HandleControlEvent_err );
status = eventNotHandledErr;
switch( GetEventKind( event ) )
{
// we only handle the kEventControlHit control event
case kEventControlHit:
{
// check to see if the control hit was our happy tab thingy
switch( controlHitID.signature )
{
case kMasterTabControlSignature:
status = this->SwitchTabPane( controlHitRef );
//check_noerr( status );
break;
default:
std::cout << "Some other unidentified control was hit" << std::endl;
status = eventNotHandledErr;
break;
}
}
break;
default:
status = eventNotHandledErr;
break;
}
HandleControlEvent_err:
return status;
}
unsigned int CTListBox::Process( UINT uiMsg,WPARAM wParam,LPARAM lParam )
{
if( !IsVision() ) return 0;
POINT ptMouse = { LOWORD(lParam), HIWORD(lParam ) };
if( uiMsg == WM_LBUTTONDOWN )
int mm = 0;
if( IsSelectable() && ProcessSelectable( uiMsg , wParam, lParam ) )
return m_iControlID;
if( (uiMsg == WM_LBUTTONDOWN || uiMsg == WM_LBUTTONDBLCLK ) && IsInside( ptMouse.x, ptMouse.y ) && IsSelectable() )
{
int iExtent = m_nMaxLnCnt;
int iCount = 0;
RECT rcHitTest = {0,0,0,0};
if( m_nPutLnNum + m_nMaxLnCnt >= (int)m_ITM.size() )///리스트의 최대범위밖으로 안나가도록 수정
iExtent = (int)m_ITM.size() - m_nPutLnNum;
for( int i = m_nPutLnNum; i < m_nPutLnNum + iExtent ; ++i , ++iCount)
{
rcHitTest.left = m_sPosition.x ;
rcHitTest.top = m_sPosition.y + iCount * ( m_iLineSpace + m_iCharHeight );
rcHitTest.right = rcHitTest.left + m_iWidth;
rcHitTest.bottom = rcHitTest.top + m_iCharHeight;
if( PtInRect( &rcHitTest, ptMouse ))
{
m_iSelectedItem = i;
return GetControlID();
}
}
// m_iSelectedItem = -1;
}
return 0;
}
unsigned CClanMemberItem::Process( unsigned uiMsg, WPARAM wParam, LPARAM lParam )
{
if( !IsInside( LOWORD(lParam), HIWORD( lParam )) ) return 0;
switch( uiMsg )
{
case WM_LBUTTONDOWN:
{
CTDialog* pDlg = g_itMGR.FindDlg( DLG_TYPE_CLAN );
if( pDlg )
{
CClanDlg* pClanDlg = (CClanDlg*)pDlg;
pClanDlg->SetSelectedMember( m_iClanPoint );
}
SetSelected();
}
return GetControlID();
default:
break;
}
return 0;
}
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;
}
static pascal OSStatus TabEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData)
{
OSStatus err, result = eventNotHandledErr;
HIViewRef ctl;
HIViewID cid;
SInt32 value;
err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &ctl);
if (err == noErr)
{
GetControlID(ctl, &cid);
value = GetControl32BitValue(ctl);
if ((cid.id == 128) && (value != lastTabIndex))
{
SelectTabPane(ctl, value);
result = noErr;
}
}
return (result);
}
int CKeyboardLayout::GetCurrentControlID(const ScanCode scancode)
{
return GetControlID(scancode, FALSE);
}
static pascal OSStatus MultiCartPaneEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData)
{
OSStatus err, result = eventNotHandledErr;
HIViewRef view;
DragRef drag;
PasteboardRef pasteboard;
PasteboardItemID itemID;
CFArrayRef array;
CFStringRef flavorType;
CFIndex numFlavors;
ItemCount numItems;
int index = *((int *) inUserData);
switch (GetEventClass(inEvent))
{
case kEventClassControl:
{
switch (GetEventKind(inEvent))
{
case kEventControlDraw:
{
err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view);
if (err == noErr)
{
CGContextRef ctx;
err = GetEventParameter(inEvent, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof(CGContextRef), NULL, &ctx);
if (err == noErr)
{
HIThemeFrameDrawInfo info;
HIRect bounds, frame;
HIViewGetBounds(view, &bounds);
CGContextSetRGBFillColor(ctx, 1.0f, 1.0f, 1.0f, 1.0f);
CGContextFillRect(ctx, bounds);
info.version = 0;
info.kind = kHIThemeFrameTextFieldSquare;
info.state = kThemeStateInactive;
info.isFocused = false;
err = HIThemeDrawFrame(&bounds, &info, ctx, kHIThemeOrientationNormal);
if (multiCartDragHilite == index && systemVersion >= 0x1040)
{
err = HIThemeSetStroke(kThemeBrushDragHilite, NULL, ctx, kHIThemeOrientationNormal);
frame = CGRectInset(bounds, 1, 1);
CGContextBeginPath(ctx);
CGContextAddRect(ctx, frame);
CGContextStrokePath(ctx);
}
}
}
result = noErr;
break;
}
case kEventControlDragEnter:
{
err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view);
if (err == noErr)
{
err = GetEventParameter(inEvent, kEventParamDragRef, typeDragRef, NULL, sizeof(DragRef), NULL, &drag);
if (err == noErr)
{
err = GetDragPasteboard(drag, &pasteboard);
if (err == noErr)
{
err = PasteboardGetItemCount(pasteboard, &numItems);
if (err == noErr && numItems == 1)
{
err = PasteboardGetItemIdentifier(pasteboard, 1, &itemID);
if (err == noErr)
{
err = PasteboardCopyItemFlavors(pasteboard, itemID, &array);
if (err == noErr)
{
numFlavors = CFArrayGetCount(array);
for (CFIndex i = 0; i < numFlavors; i++)
{
flavorType = (CFStringRef) CFArrayGetValueAtIndex(array, i);
if (UTTypeConformsTo(flavorType, CFSTR("public.file-url")))
{
Boolean accept = true;
err = SetEventParameter(inEvent, kEventParamControlWouldAcceptDrop, typeBoolean, sizeof(Boolean), &accept);
if (err == noErr)
{
multiCartDragHilite = index;
HIViewSetNeedsDisplay(view, true);
result = noErr;
}
}
}
CFRelease(array);
}
}
}
}
}
}
break;
}
case kEventControlDragWithin:
{
result = noErr;
break;
}
case kEventControlDragLeave:
{
err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view);
if (err == noErr)
{
multiCartDragHilite = -1;
HIViewSetNeedsDisplay(view, true);
}
result = noErr;
break;
}
case kEventControlDragReceive:
{
err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view);
if (err == noErr)
{
err = GetEventParameter(inEvent, kEventParamDragRef, typeDragRef, NULL, sizeof(DragRef), NULL, &drag);
if (err == noErr)
{
multiCartDragHilite = -1;
HIViewSetNeedsDisplay(view, true);
err = GetDragPasteboard(drag, &pasteboard);
if (err == noErr)
{
err = PasteboardGetItemIdentifier(pasteboard, 1, &itemID);
if (err == noErr)
{
err = PasteboardCopyItemFlavors(pasteboard, itemID, &array);
if (err == noErr)
{
numFlavors = CFArrayGetCount(array);
for (CFIndex i = 0; i < numFlavors; i++)
{
flavorType = (CFStringRef) CFArrayGetValueAtIndex(array, i);
if (UTTypeConformsTo(flavorType, CFSTR("public.file-url")))
{
CFDataRef flavorData;
err = PasteboardCopyItemFlavorData(pasteboard, itemID, flavorType, &flavorData);
if (err == noErr)
{
CFIndex dataSize;
UInt8 *data;
dataSize = CFDataGetLength(flavorData);
data = (UInt8 *) malloc(dataSize);
if (data)
{
CFDataGetBytes(flavorData, CFRangeMake(0, dataSize), data);
HIViewRef ctl;
HIViewID cid;
CFStringRef str;
CFURLRef url;
GetControlID(view, &cid);
cid.signature = 'MNAM';
HIViewFindByID(view, cid, &ctl);
url = CFURLCreateWithBytes(kCFAllocatorDefault, data, dataSize, kCFStringEncodingUTF8, NULL);
str = CFURLCopyLastPathComponent(url);
SetStaticTextCFString(ctl, str, true);
CFRelease(str);
str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
if (multiCartPath[cid.id])
CFRelease(multiCartPath[cid.id]);
multiCartPath[cid.id] = str;
CFRelease(url);
result = noErr;
free(data);
}
CFRelease(flavorData);
}
}
}
CFRelease(array);
}
}
}
}
}
}
}
}
}
return (result);
}
// Tracking the mouse in a scroll control via callback
void
MyTrackActionProcedure( ControlRef controlRef, ControlPartCode partCode )
{
OSStatus status;
SInt32 value;
SInt32 textViewDelta, controlDelta, controlMin, controlMax;
TXNScrollUnit scrollUnits;
ControlID controlID = {0,0};
WindowRef window = NULL;
// when user clicks on kControlPageUpPart or kControlPageDownPart
// we need to know the viewRect height and width so we can update
// the scrollbars with a delta of "one page" scrolled
SInt32 viewHeight = 0;
SInt32 viewWidth = 0;
scrollUnits = kTXNScrollUnitsInPixels;
textViewDelta = controlDelta = 0;
// the controlID will tell us if it is a v or h scroller
// based on the arbitrary signature we assigned it in the nib (Hscr or Vscr)
status = GetControlID( controlRef, &controlID );
require_noerr( status, CantGetControlID );
// the window has cached scroll data we need, so we need to get the window
window = GetControlOwner( controlRef );
require( window != NULL, CantGetWindow );
value = GetControl32BitValue( controlRef );
controlMin = GetControl32BitMinimum( controlRef );
controlMax = GetControl32BitMaximum( controlRef );
// calc view width or height ( for page up/down/left/right )
if( controlID.signature == kMyVerticalScrollBar )
viewHeight = TextViewGetHeight( window, kMyMLTEDataStructProperty );
else
viewWidth = TextViewGetWidth( window, kMyMLTEDataStructProperty );
// which part of the scroll control was hit?
switch ( partCode )
{
case kControlDownButtonPart:
textViewDelta = controlDelta = 1;
scrollUnits = kTXNScrollUnitsInPixels; //kTXNScrollUnitsInLines;
break;
case kControlUpButtonPart:
textViewDelta = controlDelta = -1;
scrollUnits = kTXNScrollUnitsInPixels; //kTXNScrollUnitsInLines;
break;
case kControlPageUpPart:
textViewDelta = -1; // units in viewRectHeight/Width(s)
if( controlID.signature == kMyVerticalScrollBar )
controlDelta = ( viewHeight <= kMyINT32_MAX ? viewHeight : kMyINT32_MAX );
else
controlDelta = ( viewWidth <= kMyINT32_MAX ? viewWidth : kMyINT32_MAX );
scrollUnits = kTXNScrollUnitsInViewRects;
controlDelta = -controlDelta;
break;
case kControlPageDownPart:
textViewDelta = 1; // units in viewRectHeight/Width(s)
if( controlID.signature == kMyVerticalScrollBar )
controlDelta = ( viewHeight <= kMyINT32_MAX ? viewHeight : kMyINT32_MAX );
else
controlDelta = ( viewWidth <= kMyINT32_MAX ? viewWidth : kMyINT32_MAX );
scrollUnits = kTXNScrollUnitsInViewRects;
break;
// we really do not want to do anything if the
// kControlIndicatorPart is hit. It should be
// handled by the Live Tracking procedure instead.
case kControlIndicatorPart:
{
SInt32 cacheValue = 0;
scrollUnits = kTXNScrollUnitsInPixels;
// Which scrollbar is getting called by this callback?
if( controlID.signature == kMyVerticalScrollBar )
{
// we can find the degree of the change by comparing to
// our last known value
cacheValue = TextViewGetVertScrollCache( window, kMyMLTEDataStructProperty );
textViewDelta = value - (cacheValue <= kMyINT32_MAX ? cacheValue : kMyINT32_MAX );
}
else // kMyHorizontalScrollBar
{
// we can find the degree of the change by comparing to
// our last known value
cacheValue = TextViewGetHorizScrollCache( window, kMyMLTEDataStructProperty );
textViewDelta = value - (cacheValue <= kMyINT32_MAX ? cacheValue : kMyINT32_MAX );
}
}
break;
default:
break;
}
if ( partCode != kControlIndicatorPart ) // only update the control for non-thumb hits
{
value += controlDelta;
if( value < controlMin ) // don't go past max or min
value = controlMin;
if( value > controlMax )
value = controlMax;
SetControl32BitValue( controlRef, value );
}
status = TextViewCustomScroll( window, controlID.signature, scrollUnits,
textViewDelta, value, kMyMLTEDataStructProperty );
CantGetWindow:
CantGetControlID:
return;
}
int CKeyboardLayout::GetBaseControlID(const ScanCode scancode)
{
return GetControlID(scancode, TRUE);
}
static pascal OSStatus HandlePaneEvents(EventHandlerCallRef handlerRef, EventRef eventRef, void *data)
{
wxMacCarbonEvent event(eventRef);
CustomData *dt = (CustomData *) data;
OSStatus result = eventNotHandledErr;
switch (event.GetClass())
{
case kEventClassControl:
{
ControlRef control;
ControlID cid;
control = event.GetParameter<ControlRef>(kEventParamDirectObject, typeControlRef);
if (control == NULL)
{
break;
}
GetControlID(control, &cid);
if (cid.signature != kCustom)
{
break;
}
switch (cid.id)
{
case kChoice:
{
MenuRef menu = GetControlPopupMenuRef(control);
UInt32 v = GetControl32BitValue(control) - 1;
const size_t numFilters = dt->extensions.GetCount();
if (v < (UInt32) dt->extensions.GetCount())
{
dt->currentfilter = v;
NavCustomControl(dt->context, kNavCtlBrowserRedraw, NULL);
}
}
break;
case kButton:
{
dt->me->ClickButton(GetControl32BitValue(dt->choice) - 1);
}
break;
}
}
break;
case kEventClassAccessibility:
{
switch (event.GetKind())
{
case kEventAccessibleGetNamedAttribute:
{
CFStringRef attr;
require_noerr(event.GetParameter(kEventParamAccessibleAttributeName,
typeCFTypeRef,
sizeof(attr),
&attr), ParameterError);
if (false)
{
}
else if (CFStringCompare(attr, kAXRoleAttribute, 0) == kCFCompareEqualTo)
{
CFStringRef role = kAXGroupRole;
result = event.SetParameter(kEventParamAccessibleAttributeValue,
typeCFStringRef,
sizeof(role),
&role);
require_noerr(result, ParameterError);
}
else if (CFStringCompare(attr, kAXRoleDescriptionAttribute, 0) == kCFCompareEqualTo)
{
CFStringRef role = kAXGroupRole;
CFStringRef desc;
desc = HICopyAccessibilityRoleDescription(role, NULL);
if (desc)
{
result = event.SetParameter(kEventParamAccessibleAttributeValue,
typeCFStringRef,
sizeof(desc),
&desc);
CFRelease(desc);
require_noerr(result, ParameterError);
}
}
else if (CFStringCompare(attr, kAXParentAttribute, 0) == kCFCompareEqualTo)
{
HIViewRef viewRef = HIViewGetSuperview(dt->userpane);
if (viewRef)
{
result = SetElement(event, (HIObjectRef) viewRef, 0,
kEventParamAccessibleAttributeValue);
require_noerr(result, ParameterError);
}
}
else if (CFStringCompare(attr, kAXWindowAttribute, 0) == kCFCompareEqualTo)
{
WindowRef winRef = HIViewGetWindow((HIViewRef) dt->userpane);
if (winRef)
{
result = SetElement(event, (HIObjectRef) winRef, 0,
kEventParamAccessibleAttributeValue);
require_noerr(result, ParameterError);
}
}
else if (CFStringCompare(attr, kAXTopLevelUIElementAttribute, 0) == kCFCompareEqualTo)
{
if (dt->window)
{
result = SetElement(event, (HIObjectRef) dt->window, 0,
kEventParamAccessibleAttributeValue);
require_noerr(result, ParameterError);
}
}
else
{
result = eventNotHandledErr;
}
}
break;
}
}
break;
}
ParameterError:
return result;
}
pascal OSStatus PreferencesDialog::WindowEventHandler(EventHandlerCallRef myHandler, EventRef event, void* userData)
{
OSStatus result = eventNotHandledErr;
UInt32 eventClass, eventKind;
eventClass = GetEventClass(event);
eventKind = GetEventKind(event);
PreferencesDialog* prefDlg = reinterpret_cast<PreferencesDialog*>(userData);
switch (eventClass)
{
case kEventClassControl:
{
ControlRef targetControl = NULL;
ControlID targetControlID;
GetEventParameter(event, kEventParamDirectObject, typeControlRef,
NULL, sizeof(targetControl), NULL, &targetControl);
if (targetControl)
GetControlID(targetControl, &targetControlID);
switch (eventKind)
{
case kEventControlHit:
{
switch (targetControlID.id)
{
// simulate insert key with ctrl+up
case 131:
prefDlg->setFakeInsertKey(GetControl32BitValue(targetControl)-1);
result = noErr;
break;
// 15 bit color toggle
case 132:
prefDlg->toggleUse15BitColorDepth();
result = noErr;
break;
// Enable MIDI device
case 129:
prefDlg->toggleUseMidiDevice();
result = noErr;
break;
// Save MIDI preferences
case 128:
prefDlg->toggleSavePreferences();
result = noErr;
break;
// Record key velocity
case 127:
prefDlg->toggleRecordVelocity();
result = noErr;
break;
// velocity amplify slider
case 125:
{
prefDlg->storeVelocityAmplify(GetControlValue(targetControl));
result = noErr;
break;
}
}
break;
}
}
break;
}
// Handle window close event (= discard)
case kEventClassWindow:
{
switch (eventKind)
{
case kEventWindowClose:
{
prefDlg->restoreDataBase();
prefDlg->hide();
result = noErr;
break;
}
}
break;
}
case kEventClassCommand:
{
switch (eventKind)
{
case kEventCommandProcess:
{
HICommand command;
GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &command);
switch (command.commandID)
{
case kDiscardPreferences:
prefDlg->restoreDataBase();
case kConfirmPreferences:
{
// These two events are better off when sent to the main window
SendEventToWindow(event, prefDlg->mainWindow);
break;
}
default:
// Handle MIDI device selection from pop-up menu
if (command.commandID >= kMIDIDeviceBaseCommand &&
command.commandID <= kMIDIDeviceBaseCommand + prefDlg->getNumMidiDevices())
{
prefDlg->storeMidiDeviceName(command.commandID - kMIDIDeviceBaseCommand);
result = noErr;
}
}
break;
}
}
break;
}
}
return result;
}
/*
Event handler for the content view that gets attached to the menu frame.
The content view will (eventually) contain the menu view.
*/
OSStatus ContentViewEventHandler(
EventHandlerCallRef inCallRef,
EventRef inEvent,
void *refcon)
{
OSStatus retVal = eventNotHandledErr;
if(GetEventClass(inEvent) == kEventClassMenu) {
return noErr;
} else
if(GetEventClass(inEvent) == kEventClassControl) {
HIViewRef hiSelf = NULL;
verify_noerr(GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(hiSelf), NULL, &hiSelf));
if(hiSelf) {
HIRect frame;
HIViewGetFrame(hiSelf, &frame);
switch(GetEventKind(inEvent)) {
case kEventControlAddedSubControl : {
HIViewRef subControl;
ControlID subControlID;
GetEventParameter(inEvent, kEventParamControlSubControl, typeControlRef, NULL, sizeof(subControl), NULL, &subControl );
GetControlID(subControl, &subControlID);
// This should be comparing against kHIViewMenuContentID as shown inside the
// #if 0. At the time of this writing, however, using that constant causes a
// linker error (and a crash if you use ZeroLink). I extracted the signature
// and id by determining the value at run-time the value I compare against.
#if 0
if( kHIViewMenuContentID.signature == subControlID.signature && kHIViewMenuContentID.id == subControlID.id ) {
#else
if( 'menu' == subControlID.signature && 0 == subControlID.id ) {
#endif
// If we have the menu content view then set up some view bindings for it.
HIRect bounds;
HIViewGetBounds(hiSelf, &bounds);
HIViewSetFrame(subControl, &bounds);
HILayoutInfo contentLayout = {
kHILayoutInfoVersionZero,
{
{ NULL, kHILayoutBindTop },
{ NULL, kHILayoutBindLeft },
{ NULL, kHILayoutBindBottom },
{ NULL, kHILayoutBindRight }
},
{
{ NULL, kHILayoutScaleAbsolute, 0 },
{ NULL, kHILayoutScaleAbsolute, 0 }
},
{
{ NULL, kHILayoutPositionTop, 0 },
{ NULL, kHILayoutPositionLeft, 0 }
}
};
verify_noerr(HIViewSetLayoutInfo(subControl, &contentLayout));
}
retVal = noErr;
} break;
case kEventControlGetFrameMetrics :
HIViewFrameMetrics metrics;
// The offset from the frame view to the content view is
// given by the kFrameOffset constant
metrics.top = kFrameOffset;
metrics.left = kFrameOffset;
metrics.right = kFrameOffset;
metrics.bottom = kFrameOffset;
verify_noerr(SetEventParameter(inEvent, kEventParamControlFrameMetrics, typeControlFrameMetrics, sizeof(metrics), &metrics));
retVal = noErr;
break;
case kEventControlBoundsChanged :
case kEventControlOwningWindowChanged : {
// Maintain the QuickDraw port by changing its position to
// match that of the content view.
CGrafPtr windowPort = NULL;
WindowRef window = GetControlOwner(hiSelf);
if(window && (windowPort = GetWindowPort(window))) {
CGrafPtr savePort;
bool swapped = QDSwapPort(windowPort, &savePort);
MovePortTo((short) frame.origin.x, (short) frame.origin.y);
PortSize((short) frame.size.width, (short) frame.size.height);
if(swapped) {
QDSwapPort(savePort, NULL);
}
}
retVal = noErr;
} break;
} // switch
} // if (hiSelf)
}
return retVal;
}
/* ------------------------------------------ CreatePathForEntireStarMenu */
/*
Create a path shape for the star frame.
This looks an awful lot like CreatePathForEntireStarMenu in
StarMenu.cpp but takes the radius to use as a parameter and
then takes into account the kFrameOffest when creating the path.
In true Core Foundation style, this is a CreateXXX routine and the
caller is responsible for freeing the path that is returned.
*/
CGPathRef CreatePathForStarFrame(StarFrameData *menuData, float radius)
{
CGMutablePathRef retVal = CGPathCreateMutable();
MenuItemIndex numItems = CountMenuItems(menuData->menu);
if(numItems > 0) {
const CGPoint fullRadiusPoint = { radius, 0 };
const CGPoint halfRadiusPoint = { ((radius - kFrameOffset) / 2.0) + kFrameOffset , 0 };
float anglePerItem = 2 * pi / (float)numItems; // in radians naturally
float halfAngle = anglePerItem / 2.0;
CGPoint startPoint = halfRadiusPoint;
CGAffineTransform midRotate = CGAffineTransformMakeRotation(halfAngle);
CGPoint midPoint = CGPointApplyAffineTransform(fullRadiusPoint, midRotate);
CGAffineTransform rotateToNext = CGAffineTransformMakeRotation(anglePerItem);
CGPathMoveToPoint(retVal, NULL, startPoint.x, startPoint.y);
CGPathAddLineToPoint(retVal, NULL, midPoint.x, midPoint.y);
for(short ctr = 0; ctr < numItems; ctr++) {
startPoint = CGPointApplyAffineTransform(startPoint, rotateToNext);
midPoint = CGPointApplyAffineTransform(midPoint, rotateToNext);
CGPathAddLineToPoint(retVal, NULL, startPoint.x, startPoint.y);
CGPathAddLineToPoint(retVal, NULL, midPoint.x, midPoint.y);
}
CGPathCloseSubpath(retVal);
}
return retVal;
}
static void HandleCustomMouseDown(NavCBRecPtr callBackParms, CustomData *data)
{
EventRecord *evt = callBackParms->eventData.eventDataParms.event;
Point where = evt->where;
GlobalToLocal(&where);
ControlRef control = FindControlUnderMouse(where, callBackParms->window, NULL);
if (control != NULL)
{
ControlID cid;
GetControlID(control, &cid);
HandleControlClick(control, where, evt->modifiers, (ControlActionUPP)-1L);
if (cid.signature == kCustom)
{
switch (cid.id)
{
case kChoice:
{
MenuRef menu;
UInt32 v;
menu = GetControlPopupMenuRef(control);
v = GetControl32BitValue(control) - 1;
const size_t numFilters = data->extensions.GetCount();
if (v < numFilters)
{
data->currentfilter = v;
if (data->saveMode)
{
int i = data->currentfilter;
wxString extension = data->extensions[i].AfterLast('.') ;
extension.MakeLower() ;
wxString sfilename ;
wxMacCFStringHolder cfString(NavDialogGetSaveFileName(callBackParms->context), false);
sfilename = cfString.AsString() ;
#if 0
int pos = sfilename.Find('.', true) ;
if (pos != wxNOT_FOUND)
{
sfilename = sfilename.Left(pos + 1) + extension;
cfString.Assign(sfilename, wxFONTENCODING_DEFAULT);
NavDialogSetSaveFileName(callBackParms->context, cfString);
}
#endif
}
NavCustomControl(callBackParms->context, kNavCtlBrowserRedraw, NULL);
}
break;
}
case kButton:
{
data->me->ClickButton(GetControl32BitValue(data->choice) - 1);
break;
}
}
}
}
}
