void OpenUserDataRec::EventProcCBEventMouseDown(NavCBRecPtr callBackParms)
{
EventRecord *evt = callBackParms->eventData.eventDataParms.event;
Point where = evt->where;
QDGlobalToLocalPoint(GetWindowPort(callBackParms->window), &where);
ControlRef whichControl = FindControlUnderMouse(where, callBackParms->window, NULL);
if (whichControl != NULL)
{
ControlKind theKind;
GetControlKind(whichControl, &theKind);
// Moving the focus if we clicked in an focusable control
if ((theKind.kind == kControlKindEditUnicodeText) ||
(theKind.kind == kControlKindEditText) ||
(theKind.kind == kControlKindDataBrowser) ||
(theKind.kind == kControlKindListBox))
{
ControlRef currentlyFocusedControl;
GetKeyboardFocus(callBackParms->window, ¤tlyFocusedControl);
if (currentlyFocusedControl != whichControl)
SetKeyboardFocus(callBackParms->window, whichControl, kControlFocusNextPart);
}
HandleControlClick(whichControl, where, evt->modifiers, NULL);
}
}
// --------------------------------------------------------------------------------------
void OpenPrefsDialog(void)
{
DialogRef dialog;
WindowRef dialogWindow;
ControlRef control;
ListHandle iconList;
Cell theCell;
dialog = GetNewDialog(rPrefsDialogPlatinum, NULL, kFirstWindowOfClass);
if (dialog == NULL)
ExitToShell();
SetPortDialogPort(dialog);
dialogWindow = GetDialogWindow(dialog);
SetDialogDefaultItem(dialog, kStdOkItemIndex);
SetDialogCancelItem(dialog, kStdCancelItemIndex);
GetDialogItemAsControl(dialog, iIconList, &control);
GetControlData(control, kControlEntireControl, kControlListBoxListHandleTag,
sizeof(ListHandle), &iconList, NULL);
AddRowsAndDataToIconList(iconList, rIconListIconBaseID);
(*iconList)->selFlags = lOnlyOne;
SetPt(&theCell, 0, 0);
LSetSelect(true, theCell, iconList);
SetKeyboardFocus(dialogWindow, control, kControlFocusNextPart);
gPanelNumber = 0;
DisableMenuItem(GetMenuRef(mDemonstration), iPrefsDialog);
ShowWindow(dialogWindow);
} // OpenPrefsDialog
void aui_Tab::MouseLGrabInside( aui_MouseEvent *mouseData )
{
if ( IsDisabled() ) return;
if ( !GetWhichSeesMouse() || GetWhichSeesMouse() == this )
{
SetWhichSeesMouse( this );
PlaySound( AUI_SOUNDBASE_SOUND_EXECUTE );
HideTipWindow();
SetMouseOwnership();
ReleaseMouseOwnership();
SetKeyboardFocus();
m_mouseCode = AUI_ERRCODE_HANDLEDEXCLUSIVE;
if ( !HandleGameSpecificLeftClick( this ) )
if ( 0 < m_state && m_state < m_numStates - 1 )
SetState( Mod(m_state+1,m_numStates) );
else
SetState( 1 );
m_attributes |= k_CONTROL_ATTRIBUTE_ACTIVE;
m_draw |= m_drawMask & k_AUI_REGION_DRAWFLAG_MOUSELGRABINSIDE;
}
else
MouseLGrabOutside( mouseData );
}
void CInitBrushNameDlg::InitGadgetText(String_32* pString, BOOL resizeDialog /*= TRUE*/)
{
if (pString != NULL)
m_strSuggest = *pString;
SetStringGadgetValue(_R(IDC_EDITBRUSHNAME), *GetSuggestion(&m_strSuggest));
// change the dialog title to "Enter brush name:"
// Errr, NO! This is very bad for translation!
// String_256 Name = TEXT("Create new brush:");
// SetTitlebarName(&Name);
// Show the help button
HideGadget(_R(ID_CC_HELP_BUTTON), FALSE);
// show the group info text
SetStringGadgetValue(_R(IDC_STATICBRUSHGROUP), _R(IDS_BRUSHGROUP));
HideGadget(_R(IDC_STATICBRUSHGROUP), FALSE);
HighlightText(_R(IDC_EDITBRUSHNAME));
SetKeyboardFocus(_R(IDC_EDITBRUSHNAME));
}
void WebAddressDlg::OnCreate()
{
//Set up the dialog in its initial state
SetDialogInitialState();
//And put the keyboard focus in the URL edit field
SetKeyboardFocus(_R(IDC_WEBADDRESS_URL));
HighlightText(_R(IDC_WEBADDRESS_URL));
}
// --------------------------------------------------------------------------------------
ControlRef CreateIconDataBrowser(WindowRef window, const Rect *dbRect, ControlRef *userPanes)
{
ControlRef dataBrowserControl;
DataBrowserListViewColumnDesc columnDesc;
DataBrowserItemID firstItem;
CreateDataBrowserControl(window, dbRect, kDataBrowserListView, &dataBrowserControl);
SetDataBrowserHasScrollBars(dataBrowserControl, false, true);
SetDataBrowserSelectionFlags(dataBrowserControl, kDataBrowserDragSelect |
kDataBrowserSelectOnlyOne);
SetDataBrowserListViewHeaderBtnHeight(dataBrowserControl, 0); // no header button
SetDataBrowserTableViewHiliteStyle(dataBrowserControl, kDataBrowserTableViewFillHilite);
// because kDataBrowserTableViewMinimalHilite would require us to provide a hit test
// callback which we would just return true from anyways
columnDesc.propertyDesc.propertyID = kCategoryProperty;
columnDesc.propertyDesc.propertyType = kDataBrowserCustomType; // because
// kDataBrowserIconAndTextType doesn't draw the way we want
columnDesc.propertyDesc.propertyFlags = kDataBrowserDefaultPropertyFlags |
kDataBrowserListViewSelectionColumn;
columnDesc.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
columnDesc.headerBtnDesc.minimumWidth = kColumnWidth;
columnDesc.headerBtnDesc.maximumWidth = kColumnWidth;
columnDesc.headerBtnDesc.titleOffset = 0;
columnDesc.headerBtnDesc.titleString = NULL;
columnDesc.headerBtnDesc.initialOrder = kDataBrowserOrderIncreasing;
columnDesc.headerBtnDesc.btnFontStyle.flags = 0;
columnDesc.headerBtnDesc.btnContentInfo.contentType = kControlNoContent;
AddDataBrowserListViewColumn(dataBrowserControl, &columnDesc,
kDataBrowserListViewAppendColumn);
/* We need to wait to set the row height until here because
AddDataBrowserListViewColumn will resize the row height. */
#if TARGET_API_MAC_OSX
SetDataBrowserTableViewRowHeight(dataBrowserControl, kRowHeight);
#else // Mac OS 8/9 under CarbonLib adds 1 to the row height you provide
SetDataBrowserTableViewRowHeight(dataBrowserControl, kRowHeight - 1);
#endif
SetDataBrowserListViewUsePlainBackground(dataBrowserControl, true);
if (gCallbackRefCount == 0)
{
gIconDBCallbacks.u.v1.itemNotificationCallback = NewDataBrowserItemNotificationUPP(IconDataBrowserItemSelectionCB);
gIconDBCustomCallbacks.u.v1.drawItemCallback = NewDataBrowserDrawItemUPP(DrawIconDataBrowserItemCB);
}
SetDataBrowserCallbacks(dataBrowserControl, &gIconDBCallbacks);
SetDataBrowserCustomCallbacks(dataBrowserControl, &gIconDBCustomCallbacks);
gCallbackRefCount++;
firstItem = addItemsToIconDB(dataBrowserControl, userPanes);
SetDataBrowserSelectedItems(dataBrowserControl, 1, &firstItem, kDataBrowserItemsAssign);
SetKeyboardFocus(window, dataBrowserControl, kControlFocusNextPart);
return dataBrowserControl;
}
bool LLCrashLoggerMac::init(void)
{
bool ok = LLCrashLogger::init();
if(!ok) return false;
if(mCrashBehavior != CRASH_BEHAVIOR_ASK) return true;
// Real UI...
OSStatus err;
err = CreateNibReference(CFSTR("CrashReporter"), &nib);
if(err == noErr)
{
err = CreateWindowFromNib(nib, CFSTR("CrashReporter"), &gWindow);
}
if(err == noErr)
{
// Set focus to the edit text area
ControlRef textField = NULL;
ControlID id;
id.signature = 'text';
id.id = 0;
// Don't set err if any of this fails, since it's non-critical.
if(GetControlByID(gWindow, &id, &textField) == noErr)
{
SetKeyboardFocus(gWindow, textField, kControlFocusNextPart);
}
}
if(err == noErr)
{
ShowWindow(gWindow);
}
if(err == noErr)
{
// Set up an event handler for the window.
EventTypeSpec handlerEvents[] =
{
{ kEventClassCommand, kEventCommandProcess }
};
InstallWindowEventHandler(
gWindow,
NewEventHandlerUPP(dialogHandler),
GetEventTypeCount (handlerEvents),
handlerEvents,
0,
&gEventHandler);
}
return true;
}
void ImagemapDlg::OnCreate()
{
//Set up the controls from our ImagemapFilterOptions member variables
SetOptions(ms_Options);
//Set up our internal member variables
SetMemberVariables(ms_Options);
//And put the keyboard focus in the Map Name field
SetKeyboardFocus(_R(IDC_IMAGEMAP_MAPNAME));
}
bool wxMacSearchFieldControl::SetFocus()
{
// NB: We have to implement SetFocus a little differently because kControlFocusNextPart
// leads to setting the focus on the search icon rather than the text area.
// We get around this by explicitly telling the control to set focus to the
// text area.
OSStatus err = SetKeyboardFocus( GetControlOwner( m_controlRef ), m_controlRef, kControlEditTextPart );
if ( err == errCouldntSetFocus )
return false ;
SetUserFocusWindow(GetControlOwner( m_controlRef ) );
return true;
}
//-------------------------------------------------------------------------------------
// Prompt
//-------------------------------------------------------------------------------------
// Put up a modal panel and request some text.
//
CFStringRef
Prompt( CFStringRef inPrompt, CFStringRef inDefaultText )
{
IBNibRef nibRef;
OSStatus err;
WindowRef window;
EventTypeSpec kEvents[] = { { kEventClassCommand, kEventCommandProcess } };
PanelInfo info;
HIViewRef view;
info.window = window;
info.string = NULL;
err = CreateNibReference( CFSTR( "main" ), &nibRef );
require_noerr( err, CantGetNibRef );
err = CreateWindowFromNib( nibRef, CFSTR( "Prompt" ), &window );
require_noerr( err, CantCreateWindow );
DisposeNibReference( nibRef );
if ( inPrompt )
{
HIViewFindByID( HIViewGetRoot( window ), kPromptLabelID, &view );
SetControlData( view, 0, kControlStaticTextCFStringTag, sizeof( CFStringRef ), &inPrompt );
}
HIViewFindByID( HIViewGetRoot( window ), kTextFieldID, &view );
if ( inDefaultText )
SetControlData( view, 0, kControlEditTextCFStringTag, sizeof( CFStringRef ), &inDefaultText );
SetKeyboardFocus( window, view, kControlFocusNextPart );
InstallWindowEventHandler( window, InputPanelHandler, GetEventTypeCount( kEvents ),
kEvents, &info, NULL );
ShowWindow( window );
info.window = window;
RunAppModalLoopForWindow( window );
DisposeWindow( window );
CantCreateWindow:
CantGetNibRef:
return info.string;
}
static void RunDialogTheMacOS8or9Way(DialogRef theDialog)
{
SInt16 itemHit;
ControlRef theControl;
ControlRef theTextControl;
BringToFront(GetDialogWindow(theDialog));
do {
ModalDialog(MyMacOS8or9DialogFilter, &itemHit);
switch (itemHit)
{
case 2:
{
// we still enable or disable the user pane depending on whether the box is checked or not
GetDialogItemAsControl(theDialog, itemHit, &theControl);
SInt32 enable = GetControl32BitValue(theControl);
SetControl32BitValue(theControl, 1 - enable);
GetDialogItemAsControl(theDialog, 13, &theControl);
if (!enable)
ActivateControl(theControl);
else
DeactivateControl(theControl);
}
break;
case 9: case 10:
{
// we got a click in an edit text control, if didn't have the focus, let's set it
GetDialogItemAsControl(theDialog, itemHit, &theTextControl);
ControlRef currentFocus;
GetKeyboardFocus(GetDialogWindow(theDialog), ¤tFocus);
if (currentFocus != theTextControl)
SetKeyboardFocus(GetDialogWindow(theDialog), theTextControl, kControlFocusNextPart);
}
break;
}
} while (!(itemHit == ok));
DisposeDialog(theDialog);
}
void aui_Button::MouseLGrabInside( aui_MouseEvent *mouseData )
{
if (IsDisabled()) {
if (g_soundManager) {
g_soundManager->AddSound(SOUNDTYPE_SFX, 0,
gamesounds_GetGameSoundID(GAMESOUNDS_GENERALFAIL), 0, 0);
}
return;
}
if ( !GetWhichSeesMouse() || GetWhichSeesMouse() == this )
{
SetWhichSeesMouse( this );
PlaySound( AUI_SOUNDBASE_SOUND_ENGAGE );
HideTipWindow();
SetMouseOwnership();
SetKeyboardFocus();
m_mouseCode = AUI_ERRCODE_HANDLEDEXCLUSIVE;
m_attributes |= k_CONTROL_ATTRIBUTE_DOWN;
m_attributes |= k_CONTROL_ATTRIBUTE_ACTIVE;
m_draw |= m_drawMask & k_AUI_REGION_DRAWFLAG_MOUSELGRABINSIDE;
m_isRepeating = TRUE;
m_repeatCount = 0;
m_startWaitTime = mouseData->time;
if ( m_ActionFunc )
m_ActionFunc( this, AUI_BUTTON_ACTION_PRESS, 0, m_cookie );
else if ( m_action )
m_action->Execute( this, AUI_BUTTON_ACTION_PRESS, 0 );
}
else
MouseLGrabOutside( mouseData );
}
void IGraphicsCarbon::CreateTextEntry(IControl* pControl, IText* pText, IRECT* pTextRect, const char* pString, IParam* pParam)
{
ControlRef control = 0;
if (!pControl || mTextEntryView || !mIsComposited) return;
Rect r = { pTextRect->T, pTextRect->L, pTextRect->B, pTextRect->R };
// these adjustments should make it the same as the cocoa one, i.e. the same size as the pTextRect, but with the extra blue rim often this is too small
//Rect r = { pTextRect->T+4, pTextRect->L+3, pTextRect->B-3, pTextRect->R -3 };
if (CreateEditUnicodeTextControl(NULL, &r, NULL, false, NULL, &control) != noErr) return;
HIViewAddSubview(mView, control);
const EventTypeSpec events[] =
{
{ kEventClassKeyboard, kEventRawKeyDown },
{ kEventClassKeyboard, kEventRawKeyRepeat }
};
InstallControlEventHandler(control, TextEntryHandler, GetEventTypeCount(events), events, this, &mTextEntryHandler);
mTextEntryView = control;
if (pString[0] != '\0')
{
CFStringRef str = CFStringCreateWithCString(NULL, pString, kCFStringEncodingUTF8);
if (str)
{
SetControlData(mTextEntryView, kControlEditTextPart, kControlEditTextCFStringTag, sizeof(str), &str);
CFRelease(str);
}
ControlEditTextSelectionRec sel;
sel.selStart = 0;
sel.selEnd = strlen(pString);
SetControlData(mTextEntryView, kControlEditTextPart, kControlEditTextSelectionTag, sizeof(sel), &sel);
}
int just = 0;
switch ( pText->mAlign )
{
case IText::kAlignNear:
just = teJustLeft;
break;
case IText::kAlignCenter:
just = teCenter;
break;
case IText::kAlignFar:
just = teJustRight;
break;
default:
just = teCenter;
break;
}
ControlFontStyleRec font = { kControlUseJustMask | kControlUseSizeMask | kControlUseFontMask, 0, pText->mSize, 0, 0, just, 0, 0 };
CFStringRef str = CFStringCreateWithCString(NULL, pText->mFont, kCFStringEncodingUTF8);
font.font = ATSFontFamilyFindFromName(str, kATSOptionFlagsDefault);
SetControlData(mTextEntryView, kControlEditTextPart, kControlFontStyleTag, sizeof(font), &font);
CFRelease(str);
Boolean singleLineStyle = true;
SetControlData(mTextEntryView, kControlEditTextPart, kControlEditTextSingleLineTag, sizeof (Boolean), &singleLineStyle);
HIViewSetVisible(mTextEntryView, true);
HIViewAdvanceFocus(mTextEntryView, 0);
SetKeyboardFocus(mWindow, mTextEntryView, kControlEditTextPart);
SetUserFocusWindow(mWindow);
mEdControl = pControl;
mEdParam = pParam;
}
static WindowRef DrawDialogTheMacOSXWay(void)
{
// Create a window. "DLOG:257" is the name of the window object. This name is set in
// InterfaceBuilder when the resource file is imported.
OSStatus status = noErr;
IBNibRef nibRef;
WindowRef window = NULL;
static HIObjectClassRef theClass;
if (theClass == NULL)
{
static EventTypeSpec kFactoryEvents[] =
{
{ kEventClassHIObject, kEventHIObjectConstruct },
{ kEventClassHIObject, kEventHIObjectInitialize },
{ kEventClassHIObject, kEventHIObjectDestruct },
{ kEventClassControl, kEventControlHitTest },
{ kEventClassControl, kEventControlTrack },
{ kEventClassControl, kEventControlBoundsChanged },
{ kEventClassControl, kEventControlDraw }
};
HIObjectRegisterSubclass(kCustomSpotViewClassID, kHIViewClassID, 0, CustomSpotViewHandler, GetEventTypeCount(kFactoryEvents), kFactoryEvents, 0, &theClass);
}
status = CreateNibReference(CFSTR("main"), &nibRef);
require_noerr(status, CantGetNibRef);
status = CreateWindowFromNib(nibRef, CFSTR("DLOG:257"), &window);
require_noerr(status, CantCreateWindow);
// Let's react to User's commands.
EventTypeSpec eventTypeCP = {kEventClassCommand, kEventCommandProcess};
InstallEventHandler(GetWindowEventTarget(window), MacOSXDialogCommandProcess, 1, &eventTypeCP, window, NULL);
// we still assign the key filter on our edit text box so that only digits can be entered
HIViewID hidnst = {0, 9};
HIViewRef numEditText;
HIViewFindByID(HIViewGetRoot(window), hidnst, &numEditText);
ControlKeyFilterUPP keyFilter = MyEditKeyFilter;
SetControlData(numEditText, kControlEntireControl, kControlEditTextKeyFilterTag, sizeof(keyFilter), &keyFilter);
SetKeyboardFocus(window, numEditText, kControlFocusNextPart);
// we still set the action proc for the scroll bar so that the PageUp/PageDown/Up/Down buttons work
// and still associate the previous edit text box with the scroll bar so it gets updated
HIViewID hidsb = {0, 14};
HIViewRef scrollBar;
HIViewFindByID(HIViewGetRoot(window), hidsb, &scrollBar);
SetControlAction(scrollBar, ScrollBar32BitActionProc);
SetControlReference(scrollBar, (SInt32)numEditText);
// Move it!
MoveWindow(window, 854, 271, false);
// and use the replacement for ModalDialog
// one good thing is that our behaviors are no longer half-done at the dialog level
// and half-done at the control level, they are all handled by the view handlers
ShowWindow(window);
CantCreateWindow:
CantGetNibRef:
return (window);
}
/* YASTControlCarbonEventHandler defines the main entry point for all
of the carbon event handlers installed for the YASTControl. */
static pascal OSStatus YASTControlCarbonEventHandler(
EventHandlerCallRef myHandler,
EventRef event,
void* userData) {
#pragma unused ( myHandler )
OSStatus err, returnedResult;
YASTControlVarsPtr varsp;
UInt32 eclass, ekind;
/* set up locals */
eclass = GetEventClass(event);
ekind = GetEventKind(event);
varsp = (YASTControlVarsPtr) userData;
returnedResult = eventNotHandledErr;
/* dispatch the event by class*/
switch (eclass) {
case kEventClassWindow:
if ( ekind == kEventWindowCursorChange ) {
Point where;
UInt32 modifiers;
Boolean cursorWasSet;
/* get the mouse position */
err = GetEventParameter( event, kEventParamMouseLocation,
typeQDPoint, NULL, sizeof(where), NULL, &where);
if (err == noErr) {
err = GetEventParameter( event, kEventParamKeyModifiers,
typeUInt32, NULL, sizeof(modifiers), NULL, &modifiers);
if (err == noErr) {
SetPort(varsp->fGrafPtr);
GlobalToLocal(&where);
if (PtInRect(where, &varsp->fRBounds)) {
err = HandleControlSetCursor( varsp->fControl, where, modifiers, &cursorWasSet);
if (err != noErr) cursorWasSet = false;
if ( ! cursorWasSet ) InitCursor();
returnedResult = noErr;
}
}
}
}
break;
case kEventClassMouse:
/* handle mouse downs in the control, but only if the
control is in focus. */
if ( ekind == kEventMouseDown ) {
EventRecord outEvent;
if ( varsp->fInFocus ) {
if (ConvertEventRefToEventRecord( event, &outEvent)) {
TXNClick( varsp->fTXNObject, &outEvent);
}
returnedResult = noErr;
}
}
break;
case kEventClassTextInput:
if ( ekind == kEventUnicodeForKeyEvent
&& varsp->fTabMovesFocus) {
UniChar mUnicodeText[8];
UInt32 bytecount, nchars;
/* get the character */
err = GetEventParameter(event, kEventParamTextInputSendText,
typeUnicodeText, NULL, sizeof(mUnicodeText),
&bytecount, (char*) mUnicodeText);
if ((err == noErr)
&& (bytecount >= sizeof(UniChar))) {
nchars = ( bytecount / sizeof(UniChar) );
/* if it's not the tab key, forget it... */
if ( mUnicodeText[0] == '\t' ) {
EventRef rawKeyEvent;
Boolean shiftDown;
/* is the shift key held down? */
shiftDown = false;
err = GetEventParameter(event, kEventParamTextInputSendKeyboardEvent,
typeEventRef, NULL, sizeof(rawKeyEvent), NULL, &rawKeyEvent);
if (err == noErr) {
UInt32 modifiers;
err = GetEventParameter(rawKeyEvent, kEventParamKeyModifiers,
typeUInt32, NULL, sizeof(modifiers), NULL, &modifiers);
if (err == noErr) {
shiftDown = ( (modifiers & shiftKey) != 0 );
}
}
/* advance the keyboard focus, backwards if shift is down */
if (shiftDown)
ReverseKeyboardFocus( varsp->fWindow );
else AdvanceKeyboardFocus( varsp->fWindow );
/* noErr lets the CEM know we handled the event */
returnedResult = noErr;
}
}
}
break;
case kEventClassControl:
switch (ekind) {
case kEventControlSetFocusPart:
{ ControlPartCode thePart;
err = GetEventParameter(event, kEventParamControlPart,
typeControlPartCode, NULL, sizeof(thePart), NULL, &thePart);
if (err == noErr) {
switch (thePart) {
default:
case kControlFocusNoPart: /* turn off focus */
if ( varsp->fInFocus ) {
TXNFocus( varsp->fTXNObject, false);
varsp->fInFocus = false;
}
thePart = kControlFocusNoPart;
break;
case kYASTControlOnlyPart: /* turn on focus */
if ( ! varsp->fInFocus ) {
TXNFocus( varsp->fTXNObject, true);
varsp->fInFocus = true;
}
thePart = kYASTControlOnlyPart;
break;
case kControlFocusPrevPart: /* toggle focus on/off */
case kControlFocusNextPart:
varsp->fInFocus = ! varsp->fInFocus;
TXNFocus( varsp->fTXNObject, varsp->fInFocus);
thePart = (varsp->fInFocus ? kYASTControlOnlyPart : kControlFocusNoPart);
break;
}
SetPort(varsp->fGrafPtr);
/* calculate the next highlight state */
SetTextActivation(varsp, varsp->fIsActive && varsp->fInFocus);
/* redraw the text fram and focus rectangle to indicate the
new focus state */
DrawThemeEditTextFrame(&varsp->fRTextOutline,
varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
RedrawFocusOutline(varsp);
}
/* pass back the foocus part code */
err = SetEventParameter( event, kEventParamControlPart,
typeControlPartCode, sizeof(thePart), &thePart);
returnedResult = err;
}
break;
case kEventControlHitTest:
/* this event does not necessairly mean that a mouse click
has occured. Here we are simply testing to see if a particular
point is located inside of the control. More complicated controls
would return different part codes for different parts of
themselves; but, since YASTControls only advertise one part, the
hit test here is more or less a boolean test. */
{ ControlPartCode thePart;
Point where;
err = GetEventParameter(event, kEventParamMouseLocation,
typeQDPoint, NULL, sizeof(where), NULL, &where);
if (err == noErr) {
if (PtInRect(where, &varsp->fRTextArea)) {
thePart = kYASTControlOnlyPart;
} else thePart = 0;
err = SetEventParameter( event, kEventParamControlPart,
typeControlPartCode, sizeof(thePart), &thePart);
}
returnedResult = err;
}
break;
case kEventControlClick:
/* here we handle focus switching on the control. Actual tracking
of mouse down events in the control is performed in the kEventClassMouse
mouse down handler above. */
if ( ! varsp->fInFocus ) {
SetKeyboardFocus(varsp->fWindow, varsp->fControl, kYASTControlOnlyPart);
returnedResult = noErr;
}
break;
case kEventControlBoundsChanged:
/* we moved, or switched size - recalculate our rectangles */
{ Rect bounds;
err = GetEventParameter(event, kEventParamCurrentBounds,
typeQDRectangle, NULL, sizeof(bounds), NULL, &bounds);
if (err == noErr) {
YASTControlCalculateBounds(varsp, &bounds);
TXNSetFrameBounds( varsp->fTXNObject,
varsp->fRTextArea.top, varsp->fRTextArea.left,
varsp->fRTextArea.bottom, varsp->fRTextArea.right,
varsp->fTXNFrameID);
}
}
break;
case kEventControlActivate:
case kEventControlDeactivate:
{ SetPort(varsp->fGrafPtr);
varsp->fIsActive = (ekind == kEventControlActivate);
SetTextActivation(varsp, varsp->fIsActive && varsp->fInFocus);
/* redraw the frame */
DrawThemeEditTextFrame(&varsp->fRTextOutline,
varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
RedrawFocusOutline(varsp);
returnedResult = noErr;
}
break;
case kEventControlDraw:
/* redraw the control */
SetPort(varsp->fGrafPtr);
/* update the text region */
TXNDraw(varsp->fTXNObject, NULL);
/* restore the drawing environment */
/* draw the text frame and focus frame (if necessary) */
DrawThemeEditTextFrame(&varsp->fRTextOutline,
varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
RedrawFocusOutline(varsp);
returnedResult = noErr;
break;
case kEventControlSetCursor:
/* cursor adjustment */
{ SetPortWindowPort(varsp->fWindow);
TXNAdjustCursor( varsp->fTXNObject, varsp->fRTextOutlineRegion);
returnedResult = noErr;
}
break;
case kEventControlDispose:
/* RemoveEventHandler(varsp->fControlEvents); -- this call has been
left out on purpose because it will be called automatically when the
control is disposed. */
RemoveEventHandler(varsp->fWindowEvents);
TXNDeleteObject(varsp->fTXNObject);
DisposeRgn(varsp->fRTextOutlineRegion);
free(varsp);
/* returnedResult = noErr; -- this has been left out on purpose
because we want the dispatching to continue and dispose of the control */
break;
case kEventControlSetData:
{ ResType inTagName;
Size inBufferSize;
void * inBuffer;
err = GetEventParameter( event, kEventParamControlDataTag, typeEnumeration,
NULL, sizeof(inTagName), NULL, &inTagName);
if (err == noErr) {
err = GetEventParameter( event, kEventParamControlDataBuffer, typePtr,
NULL, sizeof(inBuffer), NULL, &inBuffer);
if (err == noErr) {
err = GetEventParameter( event, kEventParamControlDataBufferSize, typeLongInteger,
NULL, sizeof(inBufferSize), NULL, &inBufferSize);
if (err == noErr) {
err = YASTControlSetData(varsp, inTagName, inBuffer, inBufferSize);
}
}
}
returnedResult = err;
}
break;
case kEventControlGetData:
{ ResType inTagName;
Size inBufferSize, outBufferSize;
void * inBuffer;
err = GetEventParameter( event, kEventParamControlDataTag, typeEnumeration,
NULL, sizeof(inTagName), NULL, &inTagName);
if (err == noErr) {
err = GetEventParameter( event, kEventParamControlDataBuffer, typePtr,
NULL, sizeof(inBuffer), NULL, &inBuffer);
if (err == noErr) {
err = GetEventParameter( event, kEventParamControlDataBufferSize, typeLongInteger,
NULL, sizeof(inBufferSize), NULL, &inBufferSize);
if (err == noErr) {
err = YASTControlGetData(varsp, inTagName, inBuffer, inBufferSize, &outBufferSize);
if (err == noErr) {
err = SetEventParameter( event, kEventParamControlDataBufferSize,
typeLongInteger, sizeof(outBufferSize), &outBufferSize);
}
}
}
}
returnedResult = err;
}
break;
}
break;
case kEventClassCommand:
if ( ekind == kEventProcessCommand ) {
HICommand command;
err = GetEventParameter( event, kEventParamDirectObject,
typeHICommand, NULL, sizeof(command), NULL, &command);
if (err == noErr) {
switch (command.commandID) {
case kHICommandUndo:
TXNUndo(varsp->fTXNObject);
returnedResult = noErr;
break;
case kHICommandRedo:
TXNRedo(varsp->fTXNObject);
returnedResult = noErr;
break;
case kHICommandCut:
ClearCurrentScrap();
err = TXNCut(varsp->fTXNObject);
if (err == noErr)
err = TXNConvertToPublicScrap();
returnedResult = err;
break;
case kHICommandCopy:
ClearCurrentScrap();
err = TXNCopy(varsp->fTXNObject);
if (err == noErr)
err = TXNConvertToPublicScrap();
returnedResult = err;
break;
case kHICommandPaste:
err = TXNConvertFromPublicScrap();
if (err == noErr)
err = TXNPaste(varsp->fTXNObject);
returnedResult = err;
break;
case kHICommandClear:
err = TXNClear(varsp->fTXNObject);
returnedResult = err;
break;
case kHICommandSelectAll:
err = TXNSetSelection(varsp->fTXNObject, kTXNStartOffset, kTXNEndOffset);
returnedResult = err;
break;
}
}
} else if ( ekind == kEventCommandUpdateStatus ) {
HICommand command;
TXNOffset oStartOffset, oEndOffset;
TXNActionKey oActionKey;
err = GetEventParameter( event, kEventParamDirectObject, typeHICommand,
NULL, sizeof(command), NULL, &command);
if ((err == noErr)
&& ((command.attributes & kHICommandFromMenu) != 0)) {
switch (command.commandID) {
case kHICommandUndo:
if (TXNCanUndo(varsp->fTXNObject, &oActionKey)) {
EnableMenuItem(command.menu.menuRef, 0); /* required pre OS 10.2 */
EnableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
} else DisableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
returnedResult = noErr;
break;
case kHICommandRedo:
if (TXNCanRedo(varsp->fTXNObject, &oActionKey)) {
EnableMenuItem(command.menu.menuRef, 0); /* required pre OS 10.2 */
EnableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
} else DisableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
returnedResult = noErr;
break;
case kHICommandCut:
case kHICommandCopy:
case kHICommandClear:
TXNGetSelection(varsp->fTXNObject, &oStartOffset, &oEndOffset);
if (oStartOffset != oEndOffset) {
EnableMenuItem(command.menu.menuRef, 0); /* required pre OS 10.2 */
EnableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
} else DisableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
returnedResult = noErr;
break;
case kHICommandPaste:
if (TXNIsScrapPastable()) {
EnableMenuItem(command.menu.menuRef, 0); /* required pre OS 10.2 */
EnableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
} else DisableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
returnedResult = noErr;
break;
case kHICommandSelectAll:
if(TXNDataSize(varsp->fTXNObject) > 0) {
EnableMenuItem(command.menu.menuRef, 0); /* required pre OS 10.2 */
EnableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
} else DisableMenuItem(command.menu.menuRef, command.menu.menuItemIndex);
returnedResult = noErr;
break;
}
}
}
break;
}
return returnedResult;
}
static DialogRef DrawDialogTheMacOS8or9Way(void)
{
short i;
ControlRef theControl;
DialogRef theDialog = GetNewDialog(257, NULL, (WindowRef)-1L);
if (theDialog == NULL) return(NULL);
// Let's get a pulsing blue default button!
GetDialogItemAsControl(theDialog, 1, &theControl);
SetWindowDefaultButton(GetDialogWindow(theDialog), theControl);
// Setting the check box
GetDialogItemAsControl(theDialog, 2, &theControl);
SetControl32BitValue(theControl, 1);
// We need to autoembed our radio buttons in the radio group
// so that they work automatically
for (i = 4; i <= 8; i++)
{
GetDialogItemAsControl(theDialog, i, &theControl);
AutoEmbedControl(theControl, GetDialogWindow(theDialog));
}
// we assign a key filter on our edit text box so that only digits can be entered
ControlRef theTextControl;
ControlKeyFilterUPP keyFilter = MyEditKeyFilter;
GetDialogItemAsControl(theDialog, 9, &theTextControl);
SetKeyboardFocus(GetDialogWindow(theDialog), theTextControl, kControlFocusNextPart);
SetControlData(theTextControl, kControlEntireControl, kControlEditTextKeyFilterTag, sizeof(keyFilter), &keyFilter);
// Setting the action proc for the scroll bar so that the PageUp/PageDown/Up/Down buttons work
// We also associate the previous edit text box with the scroll bar so it gets updated
GetDialogItemAsControl(theDialog, 14, &theControl);
SetControlAction(theControl, ScrollBar32BitActionProc);
SetControl32BitMaximum(theControl, 0x7fffffff);
SetControlReference(theControl, (SInt32)theTextControl);
// The static text control is created as a resource but we could only set its title and
// not its content. We set the content now!
GetDialogItemAsControl(theDialog, 15, &theControl);
Str255 theTitle;
GetControlTitle(theControl, theTitle);
SetControlData(theControl, kControlEntireControl, kControlStaticTextTextTag, theTitle[0], &theTitle[1]);
// We set up our User Pane Control with the draw, hit test, and track (actually action) procs
GetDialogItemAsControl(theDialog, 13, &theControl);
Rect bounds;
GetControlBounds(theControl, &bounds);
gUserH = (bounds.left + bounds.right) / 2;
gUserV = (bounds.top + bounds.bottom) / 2;
ControlUserPaneDrawUPP userPaneDraw = MyUserPaneDrawProc;
SetControlData(theControl, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(userPaneDraw), &userPaneDraw);
ControlUserPaneHitTestUPP userPaneHitTest = MyUserPaneHitTestProc;
SetControlData(theControl, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(userPaneHitTest), &userPaneHitTest);
SetControlAction(theControl, MoveSpotActionProc);
ShowWindow(GetDialogWindow(theDialog));
return(theDialog);
}
void FilterWidget::activate(void)
{
SetKeyboardFocus(HIViewGetWindow(searchField), searchField, kControlFocusNoPart);
SetKeyboardFocus(HIViewGetWindow(searchField), searchField, kControlFocusNextPart);
setText(text());
}
void SetClientStateWithEventMask (ClientData *pCD, int newState, Time setTime, unsigned int event_mask)
{
ClientData *pcdLeader;
int currentState;
WmScreenData *pSD = PSD_FOR_CLIENT(pCD);
#ifdef WSM
Boolean notShowing = (newState & UNSEEN_STATE);
#endif /* WSM */
currentState = pCD->clientState;
if (currentState == newState)
{
/* no change in state */
return;
}
/*
* Undo the old state and setup the new state. If this is a transient
* window then insure that it is put in a state that is compatible
* with its transient leader (e.g., it cannot be minimized separately).
*/
pcdLeader = (pCD->transientLeader) ? FindTransientTreeLeader (pCD) : pCD;
#ifdef WSM
SetClientWsIndex (pCD);
#endif /* WSM */
if (pCD->transientLeader)
{
if ((pcdLeader->clientState == MINIMIZED_STATE) &&
(newState != WITHDRAWN_STATE))
{
newState = MINIMIZED_STATE;
#ifdef WSM
if (notShowing)
{
newState |= UNSEEN_STATE;
}
#endif /* WSM */
}
else if ((newState == MINIMIZED_STATE) &&
(pcdLeader->clientState != MINIMIZED_STATE))
{
if (currentState == WITHDRAWN_STATE)
{
newState = NORMAL_STATE;
#ifdef WSM
if (notShowing)
{
newState |= UNSEEN_STATE;
}
#endif /* WSM */
}
else
{
newState = currentState;
#ifdef WSM
if (notShowing)
{
newState |= UNSEEN_STATE;
}
#endif /* WSM */
}
}
if (newState == currentState)
{
return;
}
}
switch (newState)
{
#ifdef WSM
case UNSEEN_STATE | WITHDRAWN_STATE:
#else
case WITHDRAWN_STATE:
#endif /* WSM */
{
/*
* Free window manager resources (frame and icon). The
* WM_STATE property is set in WithdrawWindow.
*/
UnManageWindow (pCD);
break;
}
case NORMAL_STATE:
case MAXIMIZED_STATE:
{
SetupWindowStateWithEventMask (pCD, newState, setTime, event_mask);
#ifdef WSM
XMapWindow (DISPLAY, pCD->client);
XMapWindow (DISPLAY, pCD->clientFrameWin);
#if defined(PANELIST)
WmStopWaiting(); /* in WmIPC.c */
#endif /* PANELIST */
#endif /* WSM */
break;
}
case MINIMIZED_STATE:
{
Boolean clientHasFocus;
/*
* Transient windows are minimized with the rest of the transient
* tree, including the transient leader.
*/
if ((pCD->clientState == NORMAL_STATE) ||
(pCD->clientState == MAXIMIZED_STATE))
{
if ((wmGD.keyboardFocus == pCD) ||
(pCD->transientChildren && wmGD.keyboardFocus &&
(pCD == FindTransientTreeLeader (wmGD.keyboardFocus))))
{
clientHasFocus = True;
}
else
{
clientHasFocus = False;
}
if (clientHasFocus ||
((wmGD.nextKeyboardFocus == pCD) ||
(pCD->transientChildren && wmGD.keyboardFocus &&
(pCD == FindTransientTreeLeader (wmGD.nextKeyboardFocus)))))
{
/*
* Give up the keyboard focus when minimized (including
* the case in which an associated transient window has
* the focus). Immediately remove the focus indication
* from the window being minimized.
*/
if (wmGD.autoKeyFocus &&
(wmGD.keyboardFocusPolicy == KEYBOARD_FOCUS_EXPLICIT))
{
AutoResetKeyFocus (pcdLeader, setTime);
}
else
{
Do_Focus_Key (NULL, setTime,
ALWAYS_SET_FOCUS | WORKSPACE_IF_NULL);
}
if (clientHasFocus)
{
SetKeyboardFocus (NULL, 0);
}
}
/* unmap main client and all transients */
UnmapClients (pCD, event_mask);
}
/*
* Display the icon for the minimized client.
*/
if (ICON_FRAME_WIN(pCD))
{
#ifdef WSM
if (pCD->clientState & UNSEEN_STATE)
{
if (pCD->iconWindow)
{
XMapWindow (DISPLAY, pCD->iconWindow);
}
XMapWindow (DISPLAY, ICON_FRAME_WIN(pCD));
}
ShowAllIconsForMinimizedClient (pCD);
#else /* WSM */
ShowIconForMinimizedClient (pSD->pActiveWS, pCD);
#endif /* WSM */
}
SetClientWMState (pCD, IconicState, MINIMIZED_STATE);
if ((pSD->useIconBox) && P_ICON_BOX(pCD))
{
if ((pCD->clientFlags & ICON_BOX) && ACTIVE_ICON_TEXT_WIN)
{
/*
* Hide active icon text window and reparent it to
* root
*/
HideActiveIconText((WmScreenData *)NULL);
pSD->activeLabelParent = ACTIVE_ROOT;
XReparentWindow(DISPLAY, ACTIVE_ICON_TEXT_WIN ,
ACTIVE_ROOT, 0, 0 );
}
if (ICON_FRAME_WIN(pCD))
{
/*
* force icon appearance in icon box to change
*/
IconExposureProc (pCD, True);
}
}
break;
}
#ifdef WSM
case UNSEEN_STATE | NORMAL_STATE:
case UNSEEN_STATE | MAXIMIZED_STATE:
case UNSEEN_STATE | MINIMIZED_STATE:
{
if (wmGD.keyboardFocus == pCD)
{
/*
* Give up the keyboard focus
*/
Do_Focus_Key ((ClientData *)NULL,
CurrentTime, ALWAYS_SET_FOCUS);
SetKeyboardFocus (NULL, 0);
}
if (!(pCD->clientState & UNSEEN_STATE) &&
(((pCD->clientState & ~UNSEEN_STATE) == NORMAL_STATE) ||
((pCD->clientState & ~UNSEEN_STATE) == MAXIMIZED_STATE)))
{
/* unmap main client and all transients */
UnmapClients (pcdLeader, event_mask);
}
if (pCD->clientFrameWin)
{
if (!P_ICON_BOX(pCD))
{
if (ICON_FRAME_WIN(pCD))
{
XUnmapWindow (DISPLAY, ICON_FRAME_WIN(pCD));
}
if (pCD->iconWindow)
XUnmapWindow (DISPLAY, pCD->iconWindow);
}
}
switch (newState & ~UNSEEN_STATE)
{
case MINIMIZED_STATE:
SetClientWMState (pCD, IconicState, newState);
break;
case NORMAL_STATE:
case MAXIMIZED_STATE:
default:
SetClientWMState (pCD, NormalState, newState);
break;
}
}
break;
#endif /* WSM */
}
} /* END OF FUNCTION SetClientStateWithEventMask */
void ConfigureCheat (void)
{
if (!cartOpen)
return;
OSStatus err;
IBNibRef nibRef;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
err = CreateWindowFromNib(nibRef, CFSTR("CheatEntry"), &wRef);
if (err == noErr)
{
DataBrowserCallbacks callbacks;
EventHandlerRef eref;
EventHandlerUPP eUPP;
EventTypeSpec events[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus },
{ kEventClassWindow, kEventWindowClose } };
HIViewRef ctl, root;
HIViewID cid;
root = HIViewGetRoot(wRef);
cid.id = 0;
cid.signature = kDataBrowser;
HIViewFindByID(root, cid, &dbRef);
#ifdef MAC_PANTHER_SUPPORT
if (systemVersion < 0x1040)
{
HISize minSize;
Rect rct;
GetWindowBounds(wRef, kWindowContentRgn, &rct);
minSize.width = (float) (rct.right - rct.left);
minSize.height = (float) (rct.bottom - rct.top );
err = SetWindowResizeLimits(wRef, &minSize, NULL);
}
#endif
callbacks.version = kDataBrowserLatestCallbacks;
err = InitDataBrowserCallbacks(&callbacks);
callbacks.u.v1.itemDataCallback = NewDataBrowserItemDataUPP(DBClientDataCallback);
callbacks.u.v1.itemCompareCallback = NewDataBrowserItemCompareUPP(DBCompareCallBack);
callbacks.u.v1.itemNotificationCallback = NewDataBrowserItemNotificationUPP(DBItemNotificationCallBack);
err = SetDataBrowserCallbacks(dbRef, &callbacks);
if (systemVersion >= 0x1040)
err = DataBrowserChangeAttributes(dbRef, kDataBrowserAttributeListViewAlternatingRowColors, kDataBrowserAttributeNone);
InitCheatItems();
ImportCheatItems();
DataBrowserItemID *id;
id = new DataBrowserItemID[MAC_MAX_CHEATS];
if (!id)
QuitWithFatalError(0, "cheat 01");
numofcheats = 0;
for (unsigned int i = 0; i < MAC_MAX_CHEATS; i++)
{
if (citem[i].valid)
{
id[numofcheats] = citem[i].id;
numofcheats++;
}
}
if (numofcheats)
err = AddDataBrowserItems(dbRef, kDataBrowserNoItem, numofcheats, id, kDataBrowserItemNoProperty);
delete [] id;
cid.signature = kNewButton;
HIViewFindByID(root, cid, &ctl);
if (numofcheats == MAC_MAX_CHEATS)
err = DeactivateControl(ctl);
else
err = ActivateControl(ctl);
cid.signature = kAllButton;
HIViewFindByID(root, cid, &ctl);
if (numofcheats == 0)
err = DeactivateControl(ctl);
else
err = ActivateControl(ctl);
cid.signature = kDelButton;
HIViewFindByID(root, cid, &ctl);
err = DeactivateControl(ctl);
eUPP = NewEventHandlerUPP(CheatEventHandler);
err = InstallWindowEventHandler(wRef, eUPP, GetEventTypeCount(events), events, (void *) wRef, &eref);
err = SetKeyboardFocus(wRef, dbRef, kControlFocusNextPart);
MoveWindowPosition(wRef, kWindowCheatEntry, true);
ShowWindow(wRef);
err = RunAppModalLoopForWindow(wRef);
HideWindow(wRef);
SaveWindowPosition(wRef, kWindowCheatEntry);
err = RemoveEventHandler(eref);
DisposeEventHandlerUPP(eUPP);
DisposeDataBrowserItemNotificationUPP(callbacks.u.v1.itemNotificationCallback);
DisposeDataBrowserItemCompareUPP(callbacks.u.v1.itemCompareCallback);
DisposeDataBrowserItemDataUPP(callbacks.u.v1.itemDataCallback);
CFRelease(wRef);
DetachCheatItems();
}
DisposeNibReference(nibRef);
}
}
void ctp2_HyperTextBox::MouseLGrabInside( aui_MouseEvent *mouseData )
{
if (IsDisabled()) return;
if ( !GetWhichSeesMouse() || GetWhichSeesMouse() == this )
{
SetWhichSeesMouse( this );
PlaySound( AUI_SOUNDBASE_SOUND_ENGAGE );
HideTipWindow();
SetMouseOwnership();
SetKeyboardFocus();
m_mouseCode = AUI_ERRCODE_HANDLEDEXCLUSIVE;
m_attributes |= k_CONTROL_ATTRIBUTE_DOWN;
m_attributes |= k_CONTROL_ATTRIBUTE_ACTIVE;
m_draw |= m_drawMask & k_AUI_REGION_DRAWFLAG_MOUSELGRABINSIDE;
POINT pos;
pos.x = mouseData->position.x - m_x;
pos.y = mouseData->position.y - m_y;
pos.y += m_ranger->GetValueY();
m_selectedHyperLink = NULL;
ListPos lp = m_hyperLinkList->GetHeadPosition();
for ( uint32 i = 0;i < m_hyperLinkList->L();i++ ) {
ctp2_HyperLink *hl = m_hyperLinkList->GetNext( lp );
RECT rect;
rect.left = hl->m_static->X();
rect.top = hl->m_static->Y();
rect.right = rect.left + hl->m_static->Width();
rect.bottom = rect.top + hl->m_static->Height();
if ( PtInRect(&rect, pos) ) {
hl->m_frame = TRUE;
hl->m_static->SetTextColor( hl->m_selectColor );
m_selectedHyperLink = hl;
}
else {
hl->m_frame = FALSE;
hl->m_static->SetTextColor( hl->m_oldColor );
}
}
}
else
MouseLGrabOutside( mouseData );
}
// --------------------------------------------------------------------------------------
void OpenPrefsDialog(void)
{
ListDefSpec listSpec;
DialogRef dialog;
WindowRef dialogWindow;
EventTypeSpec dialogEvents[] = {
{kEventClassControl, kEventControlHit}
};
ControlID controlID = {kAppSignature, 0};
ControlRef control;
EventTypeSpec listBoxControlEvents[] = {
{kEventClassTextInput,
kEventTextInputUnicodeForKeyEvent}
};
ListHandle iconList;
Cell theCell;
listSpec.defType = kListDefUserProcType;
listSpec.u.userProc = NewListDefUPP(IconListDef); // this is automatically disposed
// when the program exits
RegisterListDefinition(kIconListLDEF, &listSpec);
dialog = GetNewDialog(rPrefsDialog, NULL, kFirstWindowOfClass);
if (dialog == NULL)
ExitToShell();
SetPortDialogPort(dialog);
dialogWindow = GetDialogWindow(dialog);
// install window handlers
ChangeWindowAttributes(dialogWindow, kWindowStandardHandlerAttribute, kWindowNoAttributes);
gDialogEventHandler = NewEventHandlerUPP(dialogEventHandler);
InstallWindowEventHandler(dialogWindow, gDialogEventHandler,
GetEventTypeCount(dialogEvents), dialogEvents, (void *)dialog,
NULL);
GetDialogItemAsControl(dialog, kStdOkItemIndex, &control); // set control IDs to
controlID.id = kStdOkItemIndex; // match dialog item
SetControlID(control, &controlID); // indices which are
SetWindowDefaultButton(dialogWindow, control); // not tracked by any
// standard handlers
GetDialogItemAsControl(dialog, kStdCancelItemIndex, &control); // also set the default
controlID.id = kStdCancelItemIndex; // and cancel buttons (because Mac OS 8/9
SetControlID(control, &controlID); // under CarbonLib doesn't respect the
SetWindowCancelButton(dialogWindow, control); // dialog's default and cancel buttons)
GetDialogItemAsControl(dialog, iIconList, &control);
controlID.id = iIconList;
SetControlID(control, &controlID);
/* We need to postprocess keyboard events on the icon list so that we can change
panels after the user changes the selected cell by using the keyboard. */
gListBoxControlEventHandler = NewEventHandlerUPP(listBoxControlEventHandler);
InstallControlEventHandler(control, gListBoxControlEventHandler,
GetEventTypeCount(listBoxControlEvents), listBoxControlEvents,
(void *)dialog, NULL);
GetControlData(control, kControlEntireControl, kControlListBoxListHandleTag,
sizeof(ListHandle), &iconList, NULL);
AddRowsAndDataToIconList(iconList, rIconListIconBaseID);
SetListSelectionFlags(iconList, lOnlyOne);
SetPt(&theCell, 0, 0);
LSetSelect(true, theCell, iconList);
SetKeyboardFocus(dialogWindow, control, kControlFocusNextPart);
gPanelNumber = 0;
SetPrefsDialogHelpTags(dialog);
DisableMenuItem(GetMenuRef(mDemonstration), iPrefsDialog);
ShowWindow(dialogWindow);
} // OpenPrefsDialog
void CNameBrushDlg::InitGadgetText(String_32* pString, BOOL resizeDialog /*= TRUE*/)
{
if (pString != NULL)
m_strSuggest = *pString;
SetStringGadgetValue(_R(IDC_EDITBRUSHNAME), *GetSuggestion(&m_strSuggest));
HighlightText(_R(IDC_EDITBRUSHNAME));
SetKeyboardFocus(_R(IDC_EDITBRUSHNAME));
// change the dialog title to "Enter brush name:"
String_256 Name = TEXT("Enter brush name:");
SetTitlebarName(&Name);
if (resizeDialog)
{
// what we want to do is shrink the dialog by the size of the label and then hide it
RECT LabelRect;
GetGadgetPosition(_R(IDC_STATICBRUSHGROUP), &LabelRect);
// hide the label
HideGadget(_R(IDC_STATICBRUSHGROUP), TRUE);
// get the size of this dialog
RECT DialogRect;
GetWindowPosition(&DialogRect);
// subtract the size of the label
INT32 Subtract = LabelRect.bottom - LabelRect.top;
DialogRect.bottom -= Subtract;
// We want to move up the buttons
RECT OkRect;
if (GetGadgetPosition(_R(IDOK), &OkRect))
{
OkRect.top -= Subtract;
OkRect.bottom -= Subtract;
INT32 Width = OkRect.right - OkRect.left;
Width = (Width * 2) / 3;
OkRect.left += Width ;
OkRect.right += Width;
SetGadgetPosition(_R(IDOK), OkRect);
}
RECT CancelRect;
if (GetGadgetPosition(_R(IDCANCEL), &CancelRect))
{
CancelRect.top -= Subtract;
CancelRect.bottom -= Subtract;
INT32 Width = CancelRect.right - CancelRect.left;
Width = (Width * 2) / 3;
CancelRect.left += Width;
CancelRect.right += Width;
SetGadgetPosition(_R(IDCANCEL), CancelRect);
}
// Reset the window
SetWindowPosition(DialogRect);
// Hide the help button
HideGadget(_R(ID_CC_HELP_BUTTON), TRUE);
}
}
void URLImportDlg::OnCreate()
{
//Put the keyboard focus in the edit field
SetKeyboardFocus(_R(IDC_URLIMPORT_URL));
}
MsgResult ToolnameDlg::Message(Msg* Message)
{
if (IS_OUR_DIALOG_MSG(Message))
{
DialogMsg* Msg = (DialogMsg*)Message;
BOOL EndDialog = FALSE;
switch (Msg->DlgMsg)
{
case DIM_CREATE:
SetKeyboardFocus (_R(IDC_EDITNEWBARNAME)) ;
HighlightText (_R(IDC_EDITNEWBARNAME)) ;
break ;
case DIM_COMMIT:
{
// Accept all changes that the user wants to make to toolbars...
BOOL VV;
String_32 NewBarName = GetStringGadgetValue(_R(IDC_EDITNEWBARNAME),&VV);
if(NewBarName.Length()==0)
{
UINT32 Number = DialogBarOp::FindUniqueBarNumber();
NewBarName._MakeMsg(TEXT("Bar #1%ld"),Number);
}
DialogBarOp* pNewBar = new DialogBarOp(NewBarName);
if (pNewBar)
{
pNewBar->SetDockBarType(DOCKBAR_FLOAT);
pNewBar->Create();
// The Create function sends a message which we intercept to update
// the list of bars in the Toolbars... dialog.
// this is very dangerous in fact it blows up..
// so I have removed it .. chris.
/* if (pNewBar)
{
// Find toolbar dialog and close it...
ToolbarDlg* pToolbarDlg = ToolbarDlg::GetToolbarDlg();
if (pToolbarDlg)
{
pToolbarDlg->Close();
pToolbarDlg->End();
}
}
*/
ToolbarDlg* pToolbarDlg = ToolbarDlg::GetToolbarDlg();
pToolbarDlg->ShowToolbarList();
}
EndDialog = TRUE;
}
break;
case DIM_CANCEL:
// Cancel all changes the user wants to make to toolbars...
EndDialog = TRUE;
break;
// default:
}
if (EndDialog) // Dialog communication over
{
Close(); // Close the dialog
End(); // Destroy dialog
}
// return (DLG_EAT_IF_HUNGRY(Msg));
}
// return OK;
// Pass everything on to the base-class . . .
return DialogOp::Message(Message);
}
