TabbedWindow::TabbedWindow( void )
{
OSStatus status;
IBNibRef nibRef;
fWindowRef = NULL;
static const ControlID tabControlID =
{ kMasterTabControlSignature, kMasterTabControlID };
// Create a Nib reference passing the name of the nib file (without the .nib
// extension) CreateNibReference only searches into the application bundle.
status = CreateNibReference( CFSTR("main"), &nibRef );
require_noerr( status, TabbedWindow_err );
// Then create a window & set menubar based on Nib.
status = CreateWindowFromNib( nibRef, CFSTR("MainWindow"), &fWindowRef );
require_noerr( status, TabbedWindow_err );
status = SetMenuBarFromNib( nibRef, CFSTR( "MenuBar" ) );
require_noerr( status, TabbedWindow_err );
// finsihed with the nib reference
DisposeNibReference(nibRef);
// what events will this window handle?
status = this->RegisterWindowCarbonEventhandler();
require_noerr( status, TabbedWindow_err );
// start with current tab pane set to NULL.
fCurrentTabPane = NULL;
// start with all panes disabled
this->DisableAllPanes();
// Get a reference to the tab control in the window
status = GetControlByID( fWindowRef, &tabControlID, &fTabControlRef );
//check_noerr( status );
// put event handlers on it
status = InstallStandardEventHandler( GetControlEventTarget( fTabControlRef ) );
check_noerr( status );
// Switch to the tab content indicated by current value of the tab control
if( status == noErr )
status = this->SwitchTabPane( fTabControlRef );
// show the new window
ShowWindow( fWindowRef );
TabbedWindow_err:
#if DEBUG_ERROR_LOGS
if( status != noErr )
{
SysBeep(10);
std::cout << "Error in TabbedWindow constructor:" << status << std::endl;
}
#endif
return;
}
void AUPropertyControl::RegisterEvents ()
{
#if !__LP64__
EventTypeSpec events[] = {
{ kEventClassControl, kEventControlValueFieldChanged } // N.B. OS X only
};
WantEventTypes(GetControlEventTarget(mControl), GetEventTypeCount(events), events);
#endif
}
extern OSStatus
HICreateScrollingTextBox(
const HIRect * inBounds, /* can be NULL */
CFStringRef inScrollingText,
Boolean inAutoScroll,
UInt32 inDelayBeforeAutoScroll,
UInt32 inDelayBetweenAutoScroll,
UInt16 inAutoScrollAmount,
HIViewRef * outHIView)
{
*outHIView = NULL;
EventRef theInitializeEvent = NULL;
HIViewRef scrollView;
OSStatus status;
status = CreateEvent(NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), kEventAttributeUserEvent, &theInitializeEvent);
// settings
SetEventParameter(theInitializeEvent, kEventParamScrollingText, typeCFStringRef, sizeof(inScrollingText), &inScrollingText);
SetEventParameter(theInitializeEvent, kEventParamAutoScroll, typeBoolean, sizeof(inAutoScroll), &inAutoScroll);
SetEventParameter(theInitializeEvent, kEventParamDelayBeforeAutoScroll, typeUInt32, sizeof(inDelayBeforeAutoScroll), &inDelayBeforeAutoScroll);
SetEventParameter(theInitializeEvent, kEventParamDelayBetweenAutoScroll, typeUInt32, sizeof(inDelayBetweenAutoScroll), &inDelayBetweenAutoScroll);
SetEventParameter(theInitializeEvent, kEventParamAutoScrollAmount, typeSInt16, sizeof(inAutoScrollAmount), &inAutoScrollAmount);
HIObjectRef hiObject;
status = HIObjectCreate(GetScrollingTextBoxClass(), theInitializeEvent, &hiObject);
HIViewSetVisible((HIViewRef)hiObject, true);
if (!inAutoScroll)
{
//
// Manual scrolling, we need to be embedded in a scroll view
//
status = HIScrollViewCreate(kHIScrollViewOptionsVertScroll, &scrollView);
status = HIViewAddSubview(scrollView, (HIViewRef)hiObject);
if (inBounds != NULL)
HIViewSetFrame(scrollView, inBounds);
EventTypeSpec event = {kEventClassControl, kEventControlDraw};
InstallEventHandler(GetControlEventTarget(scrollView), FrameView, 1, &event, NULL, NULL);
*outHIView = scrollView;
}
else
{
if (inBounds != NULL)
HIViewSetFrame((HIViewRef)hiObject, inBounds);
*outHIView = (HIViewRef)hiObject;
}
return status;
}
void MCRevolutionStackViewRelink(WindowRef p_window, MCStack *p_new_stack)
{
EventRef t_event;
CreateEvent(NULL, 'revo', 'rlnk', GetCurrentEventTime(), 0, &t_event);
SetEventParameter(t_event, 'Stak', typeVoidPtr, sizeof(void *), &p_new_stack);
HIViewRef t_root;
GetRootControl(p_window, &t_root);
HIViewRef t_view;
GetIndexedSubControl(t_root, 1, &t_view);
SendEventToEventTarget(t_event, GetControlEventTarget(t_view));
ReleaseEvent(t_event);
}
/*----------------------------------------------------------------------------------------------------------*/
void myScrollingTextTimeProc(EventLoopTimerRef inTimer, void *inUserData)
{
ScrollingTextBoxData* myData = (ScrollingTextBoxData*)inUserData;
HIPoint where = {0.0, myData->originPoint.y + myData->autoScrollAmount};
// If we reached the end of our text, let's start again
if (where.y >= myData->height - 10.0) where.y = 0.0;
// Creating and sending our ScrollTo event
EventRef theEvent;
CreateEvent(NULL, kEventClassScrollable, kEventScrollableScrollTo, GetCurrentEventTime(), kEventAttributeUserEvent, &theEvent);
SetEventParameter(theEvent, kEventParamOrigin, typeHIPoint, sizeof(where), &where);
SendEventToEventTarget(theEvent, GetControlEventTarget(myData->view));
ReleaseEvent(theEvent);
}
OSStatus
TextViewInstallMenuHandlers( HIViewRef textView )
{
EventTargetRef targetRef = GetControlEventTarget( textView );
static const EventTypeSpec sAppEvents[] =
{
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus }
};
OSStatus status = InstallEventHandler( targetRef, TextViewMenuEventHandler,
GetEventTypeCount( sAppEvents ),
sAppEvents, textView /*userData*/, NULL /*eventHandlerRef*/ );
return status;
}
void AUCarbonViewControl::Bind()
{
#if !__LP64__
mInControlInitialization = 1; // true
AUListenerAddParameter(mListener, this, &mParam);
// will cause an almost-immediate callback
EventTypeSpec events[] = {
{ kEventClassControl, kEventControlValueFieldChanged } // N.B. OS X only
};
WantEventTypes(GetControlEventTarget(mControl), GetEventTypeCount(events), events);
if (mType == kTypeContinuous || mType == kTypeText || mType == kTypeDiscrete) {
EventTypeSpec events[] = {
{ kEventClassControl, kEventControlHit },
{ kEventClassControl, kEventControlClick },
{ kEventClassControl, kEventControlTrack }
};
WantEventTypes(GetControlEventTarget(mControl), GetEventTypeCount(events), events);
}
if (mType == kTypeText) {
EventTypeSpec events[] = {
{ kEventClassControl, kEventControlSetFocusPart }
};
WantEventTypes(GetControlEventTarget(mControl), GetEventTypeCount(events), events);
ControlKeyFilterUPP proc = mParam.ValuesHaveStrings() ? StdKeyFilterCallback : NumericKeyFilterCallback;
// this will fail for a static text field
SetControlData(mControl, 0, kControlEditTextKeyFilterTag, sizeof(proc), &proc);
}
Update(true);
mInControlInitialization = 0; // false
#endif
}
void
create_login (HWND hwnd,
LPCSTR username,
LPCSTR password,
LPCSTR dsn,
TLOGIN * log_t)
{
EventTypeSpec controlSpec = { kEventClassControl, kEventControlHit };
RgnHandle cursorRgn = NULL;
WindowRef wlogin;
ControlRef control;
ControlID controlID;
EventRecord event;
IBNibRef nibRef;
OSStatus err;
char msg[1024];
if (hwnd == NULL)
return;
/* Search the bundle for a .nib file named 'odbcadmin'. */
err =
CreateNibReferenceWithCFBundle (CFBundleGetBundleWithIdentifier (CFSTR
("org.iodbc.drvproxy")), CFSTR ("login"), &nibRef);
if (err == noErr)
{
/* Nib found ... so create the window */
CreateWindowFromNib (nibRef, CFSTR ("Dialog"), &wlogin);
DisposeNibReference (nibRef);
/* Set the title with the DSN */
if (dsn)
{
msg[0] = STRLEN ("Login for ") + STRLEN(dsn);
sprintf (msg+1, "Login for %s", (char*)dsn);
SetWTitle (wlogin, msg);
}
/* Set the control into the structure */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, LBUSER_CNTL, wlogin,
log_t->username);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, LBPASS_CNTL, wlogin,
log_t->password);
log_t->user = log_t->pwd = NULL;
log_t->mainwnd = wlogin;
/* Install handlers for the finish button, the cancel */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, LBOK_CNTL, wlogin, control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (login_ok_clicked), 1, &controlSpec, log_t,
NULL);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, LBCANCEL_CNTL, wlogin,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (login_cancel_clicked), 1, &controlSpec, log_t,
NULL);
SetControlData (log_t->username, 0, kControlEditTextTextTag,
username ? STRLEN (username) : STRLEN(""),
(UInt8 *) username ? username : "");
SetControlData (log_t->password, 0, kControlEditTextPasswordTag,
password ? STRLEN (password) : STRLEN(""),
(UInt8 *) password ? password : "");
/* Show the window and run the loop */
AdvanceKeyboardFocus (wlogin);
ShowWindow (wlogin);
/* The main loop */
while (log_t->mainwnd)
{
switch (WaitNextEvent (everyEvent, &event, 60L, cursorRgn))
{
};
}
}
else
goto error;
return;
error:
fprintf (stderr, "Can't load Window. Err: %d\n", (int) err);
return;
}
OSStatus AUCarbonViewBase::CreateCarbonView(AudioUnit inAudioUnit, WindowRef inWindow, ControlRef inParentControl, const Float32Point &inLocation, const Float32Point &inSize, ControlRef &outParentControl)
{
#if !__LP64__
mEditAudioUnit = inAudioUnit;
mCarbonWindow = inWindow;
WindowAttributes attributes;
verify_noerr(GetWindowAttributes(mCarbonWindow, &attributes));
mCompositWindow = (attributes & kWindowCompositingAttribute) != 0;
Rect area;
area.left = short(inLocation.x); area.top = short(inLocation.y);
area.right = short(area.left + inSize.x); area.bottom = short(area.top + inSize.y);
OSStatus err = ::CreateUserPaneControl(inWindow, &area,
kControlSupportsEmbedding,
&mCarbonPane); // subclass can resize mCarbonPane to taste
verify_noerr(err);
if (err) return err;
outParentControl = mCarbonPane;
// register for mouse-down in our pane -- we want to clear focus
EventTypeSpec paneEvents[] = {
{ kEventClassControl, kEventControlClick }
};
WantEventTypes(GetControlEventTarget(mCarbonPane), GetEventTypeCount(paneEvents), paneEvents);
if (IsCompositWindow()) {
verify_noerr(::HIViewAddSubview(inParentControl, mCarbonPane));
mXOffset = 0;
mYOffset = 0;
}
else {
verify_noerr(::EmbedControl(mCarbonPane, inParentControl));
mXOffset = inLocation.x;
mYOffset = inLocation.y;
}
mBottomRight.h = mBottomRight.v = 0;
SizeControl(mCarbonPane, 0, 0);
if (err = CreateUI(mXOffset, mYOffset))
return err;
// we should only resize the control if a subclass has embedded
// controls in this AND this is done with the EmbedControl call below
// if mBottomRight is STILL equal to zero, then that wasn't done
// so don't size the control
Rect paneBounds;
GetControlBounds(mCarbonPane, &paneBounds);
// only resize mCarbonPane if it has not already been resized during CreateUI
if ((paneBounds.top == paneBounds.bottom) && (paneBounds.left == paneBounds.right)) {
if (mBottomRight.h != 0 && mBottomRight.v != 0)
SizeControl(mCarbonPane, (short) (mBottomRight.h - mXOffset), (short) (mBottomRight.v - mYOffset));
}
if (IsCompositWindow()) {
// prepare for handling scroll-events
EventTypeSpec scrollEvents[] = {
{ kEventClassScrollable, kEventScrollableGetInfo },
{ kEventClassScrollable, kEventScrollableScrollTo }
};
WantEventTypes(GetControlEventTarget(mCarbonPane), GetEventTypeCount(scrollEvents), scrollEvents);
mCurrentScrollPoint.x = mCurrentScrollPoint.y = 0.0f;
}
return err;
#else
return noErr;
#endif
}
LPSTR create_gensetup (HWND hwnd, LPCSTR dsn,
LPCSTR attrs, BOOL add, BOOL *verify_conn)
{
EventTypeSpec controlSpec = { kEventClassControl, kEventControlHit };
RgnHandle cursorRgn = NULL;
TGENSETUP gensetup_t;
ControlID controlID;
WindowRef wgensetup;
ControlRef control;
EventRecord event;
IBNibRef nibRef;
OSStatus err;
char msg[1024];
gensetup_t.verify_conn = true;
/* Search the bundle for a .nib file named 'odbcadmin'. */
/* Search the bundle for a .nib file named 'odbcadmin'. */
err = CreateNibReferenceWithCFBundle (CFBundleGetBundleWithIdentifier (
CFSTR ("org.iodbc.adm")), CFSTR ("gensetup"), &nibRef);
if (err == noErr)
{
/* Nib found ... so create the window */
CreateWindowFromNib (nibRef, CFSTR ("Dialog"), &wgensetup);
DisposeNibReference (nibRef);
/* Set the title with the DSN */
if (dsn)
{
msg[0] = STRLEN ("Setup of ") + STRLEN(dsn);
sprintf (msg+1, "Setup of %s", (char*)dsn);
SetWTitle (wgensetup, msg);
}
/* Install handlers for the finish button, the cancel */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSDSN_CNTL, wgensetup,
gensetup_t.dsn_entry);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSVERIFYCONN_CNTL, wgensetup,
gensetup_t.verify_conn_cb);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSLIST_CNTL, wgensetup,
gensetup_t.key_list);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSKEYWORD_CNTL, wgensetup,
gensetup_t.key_entry);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSVALUE_CNTL, wgensetup,
gensetup_t.value_entry);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSUPDATE_CNTL, wgensetup,
gensetup_t.bupdate);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSADD_CNTL, wgensetup,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (gensetup_add_clicked), 1, &controlSpec,
&gensetup_t, NULL);
InstallEventHandler (GetControlEventTarget (gensetup_t.bupdate),
NewEventHandlerUPP (gensetup_update_clicked), 1, &controlSpec,
&gensetup_t, NULL);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSOK_CNTL, wgensetup,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (gensetup_ok_clicked), 1, &controlSpec,
&gensetup_t, NULL);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSCANCEL_CNTL, wgensetup,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (gensetup_cancel_clicked), 1, &controlSpec,
&gensetup_t, NULL);
/* Parse the attributes line */
gensetup_t.mainwnd = wgensetup;
parse_attribute_line (&gensetup_t, dsn, attrs, add);
AdvanceKeyboardFocus (wgensetup);
/* Show the window and run the loop */
DeactivateControl (gensetup_t.bupdate);
DSNSETUP = &gensetup_t;
ShowWindow (wgensetup);
/* The main loop */
while (gensetup_t.mainwnd)
{
switch (WaitNextEvent (everyEvent, &event, 60L, cursorRgn))
{
};
}
*verify_conn = gensetup_t.verify_conn;
}
else
goto error;
return gensetup_t.connstr;
error:
fprintf (stderr, "Can't load Window. Err: %d\n", (int) err);
return gensetup_t.connstr;
}
BOOL create_confirm_Internal (HWND hwnd,
SQLPOINTER dsn,
SQLPOINTER text,
SQLCHAR waMode)
{
EventTypeSpec controlSpec = { kEventClassControl, kEventControlHit };
RgnHandle cursorRgn = NULL;
ControlID controlID;
ControlRef control;
WindowRef wconfirm;
TCONFIRM confirm_t;
EventRecord event;
IBNibRef nibRef;
CFStringRef msg;
OSStatus err;
/* Search the bundle for a .nib file named 'odbcadmin'. */
err =
CreateNibReferenceWithCFBundle (CFBundleGetBundleWithIdentifier (CFSTR
("org.iodbc.drvproxy")), CFSTR ("confirmation"), &nibRef);
if (err == noErr)
{
/* Nib found ... so create the window */
CreateWindowFromNib (nibRef, CFSTR ("Dialog"), &wconfirm);
DisposeNibReference (nibRef);
/* Set the title with the DSN name */
if (dsn)
{
if (waMode == 'A')
msg = CFStringCreateWithBytes (NULL, (unsigned char*)dsn, STRLEN(dsn),
kCFStringEncodingUTF8, false);
else
msg = convert_wchar_to_CFString((wchar_t*)dsn);
SetWindowTitleWithCFString (wconfirm, msg);
CFRelease(msg);
}
/* Install handlers for the finish button, the cancel */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, CONFYES_CNTL, wconfirm,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (confirmadm_yes_clicked), 1, &controlSpec,
&confirm_t, NULL);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, CONFNO_CNTL, wconfirm,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (confirmadm_no_clicked), 1, &controlSpec,
&confirm_t, NULL);
/* Change the static field with the message */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, CONFTEXT_CNTL, wconfirm,
control);
if (waMode == 'A')
SetControlData (control, 0, kControlEditTextTextTag, STRLEN (text), text);
else
{
msg = convert_wchar_to_CFString((wchar_t*)text);
SetControlData (control, 0, kControlEditTextCFStringTag, sizeof(CFStringRef), &msg);
CFRelease(msg);
}
DrawOneControl (control);
confirm_t.yes_no = FALSE;
confirm_t.mainwnd = wconfirm;
/* Show the window and run the loop */
ShowWindow (wconfirm);
/* The main loop */
while (confirm_t.mainwnd)
WaitNextEvent (everyEvent, &event, 60L, cursorRgn);
}
else
goto error;
return confirm_t.yes_no;
error:
fprintf (stderr, "Can't load Window. Err: %d\n", (int) err);
return confirm_t.yes_no;
}
/*****************************************************
*
* DisplaySimpleWindow ( void )
*
* Purpose: Called to create a new window in response to a kHICommandNew event. Here we create a window, set up the MyMPTaskInfo structure,
* and create an MP thread to monitor our specified directories.
*
*/
static void DisplaySimpleWindow( void )
{
OSStatus err;
OSStatus err1;
WindowRef window;
ControlRef control;
MPTaskID mpTaskID;
MyMPTaskInfo *mpTaskInfo;
FSRef fsRef;
char path[MAXPATHLEN];
DialogRef alertDialog;
static EventHandlerUPP mpWindowEventHandlerUPP;
SInt32 i = -1;
const EventTypeSpec windowEvents[] = {
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassMP, kEventKQueue },
{ kEventClassWindow, kEventWindowClose }
};
err = CreateWindowFromNib( g.mainNib, CFSTR("MainWindow"), &window );
if ( (err != noErr) || (window == NULL) ) goto Bail;
if ( mpWindowEventHandlerUPP == NULL ) mpWindowEventHandlerUPP = NewEventHandlerUPP( MPWindowEventHandlerProc ); // MPWindowEventHandlerProc handles events for this window
err = InstallWindowEventHandler( window, mpWindowEventHandlerUPP, GetEventTypeCount(windowEvents), windowEvents, window, NULL );
// Display the directories we are going to watch in the static text fields. In this sample we hard code the values to a few specific locations
err = FSFindFolder( kUserDomain, kDesktopFolderType, kDontCreateFolder, &fsRef ); // Watch the Desktop folder
err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );
if ( (err == noErr) && (err1 == noErr) )
SetControlCString( window, 'STxt', ++i, path );
err = FSFindFolder( kUserDomain, kDocumentsFolderType, kDontCreateFolder, &fsRef ); // Watch the Documents folder
err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );
if ( (err == noErr) && (err1 == noErr) )
SetControlCString( window, 'STxt', ++i, path );
err = FSFindFolder( kUserDomain, kCurrentUserFolderType, kDontCreateFolder, &fsRef ); // Watch the Users folder
err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );
if ( (err == noErr) && (err1 == noErr) )
SetControlCString( window, 'STxt', ++i, path );
mpTaskInfo = (MyMPTaskInfo*) NewPtrClear( sizeof(MyMPTaskInfo) );
SetWRefCon( window, (long) mpTaskInfo );
for ( mpTaskInfo->count = 0 ; mpTaskInfo->count < kMaxFoldersToWatch ; mpTaskInfo->count++ )
{
GetControlCString( window, 'STxt', mpTaskInfo->count, mpTaskInfo->path[mpTaskInfo->count] ); // This code pretty much just reads back the strings we set above
if ( mpTaskInfo->path[mpTaskInfo->count][0] == '\0' ) break;
// We initialize a number of values which are not be safe to retrieve from an MP thread.
GetControlBySigAndID( window, 'Date', mpTaskInfo->count, &mpTaskInfo->mpControlInfo[mpTaskInfo->count].dateControl );
GetControlBySigAndID( window, 'STxt', mpTaskInfo->count, &control );
mpTaskInfo->mpControlInfo[mpTaskInfo->count].eventTarget = GetControlEventTarget( control );
}
if ( mpTaskInfo->count < 1 )
{
DisposePtr( (Ptr) mpTaskInfo );
goto Bail;
}
// Create our MP thread and pass in mpTaskInfo. MyMPTask is responsible for watching the passed in directories, and posting notifications of changes.
err = MPCreateTask( MyMPTask, (void *) mpTaskInfo, 0, NULL, 0, 0, kNilOptions, &mpTaskID );
if ( err != noErr ) // Alert if an error occured
{
CreateStandardAlert( kAlertStopAlert, CFSTR("MPCreateTask returned an error! Will not create window."), NULL, NULL, &alertDialog );
RunStandardAlert( alertDialog, NULL, NULL );
goto Bail;
}
ShowWindow( window );
Bail:
return;
}
LPSTR create_keyval (WindowRef wnd, LPCSTR attrs, BOOL *verify_conn)
{
EventTypeSpec controlSpec = { kEventClassControl, kEventControlHit };
RgnHandle cursorRgn = NULL;
TKEYVAL keyval_t;
ControlID controlID;
WindowRef wkeyval;
ControlRef control;
EventRecord event;
IBNibRef nibRef;
OSStatus err;
/* Search the bundle for a .nib file named 'odbcadmin'. */
err = CreateNibReferenceWithCFBundle (CFBundleGetBundleWithIdentifier (
CFSTR ("org.iodbc.adm")), CFSTR ("keyval"), &nibRef);
if (err == noErr)
{
/* Nib found ... so create the window */
CreateWindowFromNib (nibRef, CFSTR ("Dialog"), &wkeyval);
DisposeNibReference (nibRef);
/* Install handlers for the finish button, the cancel */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSVERIFYCONN_CNTL, wkeyval,
keyval_t.verify_conn_cb);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSLIST_CNTL, wkeyval,
keyval_t.key_list);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSKEYWORD_CNTL, wkeyval,
keyval_t.key_entry);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSVALUE_CNTL, wkeyval,
keyval_t.value_entry);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSUPDATE_CNTL, wkeyval,
keyval_t.bupdate);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSADD_CNTL, wkeyval,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (keyval_add_clicked), 1, &controlSpec,
&keyval_t, NULL);
InstallEventHandler (GetControlEventTarget (keyval_t.bupdate),
NewEventHandlerUPP (keyval_update_clicked), 1, &controlSpec,
&keyval_t, NULL);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSOK_CNTL, wkeyval,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (keyval_ok_clicked), 1, &controlSpec,
&keyval_t, NULL);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, GSCANCEL_CNTL, wkeyval,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (keyval_cancel_clicked), 1, &controlSpec,
&keyval_t, NULL);
/* Parse the attributes line */
keyval_t.mainwnd = wkeyval;
addkeywords_to_list (keyval_t.key_list, attrs, &keyval_t);
AdvanceKeyboardFocus (wkeyval);
/* Show the window and run the loop */
DeactivateControl (keyval_t.bupdate);
KEYVAL = &keyval_t;
ShowSheetWindow(wkeyval, wnd);
/* The main loop */
while (keyval_t.mainwnd)
WaitNextEvent (everyEvent, &event, 60L, cursorRgn);
if (keyval_t.connstr)
*verify_conn = keyval_t.verify_conn;
}
else
goto error;
return keyval_t.connstr;
error:
fprintf (stderr, "Can't load Window. Err: %d\n", (int) err);
return keyval_t.connstr;
}
void
create_driverchooser (HWND hwnd, TDRIVERCHOOSER * choose_t)
{
EventTypeSpec controlSpec = { kEventClassControl, kEventControlHit };
RgnHandle cursorRgn = NULL;
WindowRef wdrvchooser;
ControlID controlID;
EventRecord event;
IBNibRef nibRef;
OSStatus err;
if (hwnd == NULL)
return;
/* Search the bundle for a .nib file named 'odbcadmin'. */
err =
CreateNibReferenceWithCFBundle (CFBundleGetBundleWithIdentifier (CFSTR
("org.iodbc.adm")), CFSTR ("odbcdriver"), &nibRef);
if (err == noErr)
{
/* Nib found ... so create the window */
CreateWindowFromNib (nibRef, CFSTR ("Dialog"), &wdrvchooser);
DisposeNibReference (nibRef);
/* Set the control into the structure */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, DCLIST_CNTL, wdrvchooser,
choose_t->driverlist);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, DCFINISH_CNTL, wdrvchooser,
choose_t->b_add);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, DCCANCEL_CNTL, wdrvchooser,
choose_t->b_remove);
choose_t->driver = NULL;
choose_t->mainwnd = wdrvchooser;
/* Install handlers for the finish button, the cancel */
InstallEventHandler (GetControlEventTarget (choose_t->b_add),
NewEventHandlerUPP (driverchooser_ok_clicked), 1, &controlSpec,
choose_t, NULL);
InstallEventHandler (GetControlEventTarget (choose_t->b_remove),
NewEventHandlerUPP (driverchooser_cancel_clicked), 1, &controlSpec,
choose_t, NULL);
Drivers_nrows = 0;
adddrivers_to_list (choose_t->driverlist, choose_t->mainwnd, TRUE);
/* Show the window and run the loop */
choose_t->b_configure = NULL;
DRIVERCHOOSER = choose_t;
DeactivateControl (DRIVERCHOOSER->b_add);
ShowWindow (wdrvchooser);
/* The main loop */
while (choose_t->mainwnd)
WaitNextEvent (everyEvent, &event, 60L, cursorRgn);
}
else
goto error;
return;
error:
choose_t->driver = NULL;
fprintf (stderr, "Can't load Window. Err: %d\n", (int) err);
return;
}
/*
Handle events of kEventClassControl that get sent to the Frame
*/
OSStatus HandleStarFrameControlEvents(
EventHandlerCallRef inCallRef,
EventRef inEvent,
StarFrameData* frameData)
{
OSStatus retVal = eventNotHandledErr;
switch(GetEventKind(inEvent)) {
case kEventControlInitialize :
retVal = HandleStarFrameInitialize(inCallRef, inEvent, frameData);
break;
case kEventControlOwningWindowChanged : {
// We only want the star-shaped opaque area of our frame view to
// draw. Everything else should be transparent. To accomplish that
// we change the features of the owning window so that only the
// content we draw shows up on screen
WindowRef newWindow = GetControlOwner(frameData->hiSelf);
HIWindowChangeFeatures(newWindow, 0, kWindowIsOpaque);
} break;
case kEventControlBoundsChanged : {
retVal = HandleStarFrameBoundsChanged(inCallRef, inEvent, frameData);
} break;
case kEventControlDraw : {
HIRect bounds;
CGContextRef cgContext;
HIViewGetBounds(frameData->hiSelf, &bounds);
float radius = fmin(CGRectGetWidth(bounds) / 2.0, CGRectGetHeight(bounds) / 2.0);
GetEventParameter(inEvent, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof(cgContext), NULL, &cgContext );
if(NULL != cgContext) {
HIThemeMenuDrawInfo drawInfo;
CGPathRef starPath = CreatePathForStarFrame(frameData, radius);
drawInfo.version = 0;
drawInfo.menuType = frameData->menuType;
// HIThemeDrawMenuBackground is designed to draw the pin striped background
// of standard menus. Our menu is a star and so HIThemeDrawMenuBackground may not be
// appropriate in this case. Nevertheless, we'll draw the standard menu background for
// this menu and clip it to a star.
CGContextClearRect(cgContext, bounds);
CGContextSaveGState(cgContext);
CGContextTranslateCTM(cgContext, radius, radius);
CGContextAddPath(cgContext, starPath);
CGContextClip(cgContext);
CGContextTranslateCTM(cgContext, -radius, -radius);
HIThemeDrawMenuBackground(&bounds, &drawInfo, cgContext, kHIThemeOrientationNormal);
CGContextRestoreGState(cgContext);
// The pin striping looks a bit odd sort of floating out by itself. We'll also add
// a lovely gray line to help emphasize the boundary
CGContextTranslateCTM(cgContext, radius, radius);
CGContextAddPath(cgContext, starPath);
CGContextSetRGBStrokeColor(cgContext, 0.8, 0.8, 0.8, 1.0);
CGContextSetLineWidth(cgContext, 1.0);
CGContextStrokePath(cgContext);
CGPathRelease(starPath);
starPath = NULL;
}
retVal = noErr;
} break;
// Mac OS X v10.4 introduced a Window Manager bug.
// The workaround is to implement the kEventControlGetFrameMetrics handler.
// Even after the bug is fixed, the workaround will not be harmful.
case kEventControlGetFrameMetrics: {
HIViewRef contentView = NULL;
// If we can find our content view, ask it for our metrics
verify_noerr(HIViewFindByID(frameData->hiSelf, kHIViewWindowContentID, &contentView));
if(NULL != contentView) {
retVal = SendEventToEventTargetWithOptions( inEvent, GetControlEventTarget( contentView ), kEventTargetDontPropagate );
}
} break;
default:
break;
}
return retVal;
}
OSStatus YASTControlAttachToExistingControl(ControlRef theControl) {
OSStatus err;
YASTControlVars *varsp;
UInt32 outCommandID;
EventHandlerRef controlEvents, windowEvents;
TXNObject theTXNObject;
RgnHandle outlineRegion;
/* set up our locals */
controlEvents = windowEvents = NULL;
theTXNObject = NULL;
outlineRegion = NULL;
varsp = NULL;
err = noErr;
/* allocate our private storage and set up initial settings*/
varsp = (YASTControlVars *) malloc(sizeof(YASTControlVars));
if (varsp == NULL) {
err = memFullErr;
} else {
varsp->fInFocus = false;
varsp->fIsActive = true;
varsp->fTXNObjectActive = false;
varsp->fControl = theControl;
varsp->fTabMovesFocus = true;
varsp->fDrawFocusBox = true;
varsp->fFocusDrawState = false;
varsp->fIsReadOnly = false;
varsp->fRTextOutlineRegion = NULL;
varsp->fWindow = GetControlOwner(theControl);
varsp->fGrafPtr = GetWindowPort(varsp->fWindow);
}
/* set our control's command id. we don't actually use it, but it must
be non-zero for our control to be sent command events. only set it
if it has not already been set. */
err = GetControlCommandID(theControl, &outCommandID);
if (err == noErr) {
if (outCommandID == 0) {
err = SetControlCommandID(theControl, 1);
}
}
/* calculate the rectangles used by the control */
if (err == noErr) {
outlineRegion = NewRgn();
if (outlineRegion == NULL) {
err = memFullErr;
} else {
Rect bounds;
varsp->fRTextOutlineRegion = outlineRegion;
GetControlBounds(theControl, &bounds);
YASTControlCalculateBounds(varsp, &bounds);
}
}
/* create the new edit field */
if (err == noErr) {
err = TXNNewObject(NULL, varsp->fWindow, &varsp->fRTextArea,
kTXNWantVScrollBarMask | kTXNAlwaysWrapAtViewEdgeMask,
kTXNTextEditStyleFrameType, kTXNTextensionFile, kTXNSystemDefaultEncoding,
&theTXNObject, &varsp->fTXNFrameID, (TXNObjectRefcon) varsp);
if (err == noErr) {
varsp->fTXNObject = theTXNObject;
}
}
/* set the field's background */
if (err == noErr) {
RGBColor rgbWhite = {0xFFFF, 0xFFFF, 0xFFFF};
TXNBackground tback;
tback.bgType = kTXNBackgroundTypeRGB;
tback.bg.color = rgbWhite;
TXNSetBackground( varsp->fTXNObject, &tback);
}
/* set the margins for easier selection and display */
if (err == noErr) {
TXNControlData txnCControlData;
TXNControlTag txnControlTag = kTXNMarginsTag;
TXNMargins txnMargins = { 2, 3, 2, 1 }; /* t,l,b,r */
txnCControlData.marginsPtr = &txnMargins;
(void) TXNSetTXNObjectControls( varsp->fTXNObject, false, 1, &txnControlTag, &txnCControlData );
}
/* install our carbon event handlers */
if (err == noErr) {
static EventHandlerUPP gTPEventHandlerUPP = NULL;
if (gTPEventHandlerUPP == NULL)
gTPEventHandlerUPP = NewEventHandlerUPP(YASTControlCarbonEventHandler);
/* carbon event handlers for the control */
err = InstallEventHandler( GetControlEventTarget( theControl ),
gTPEventHandlerUPP,
(sizeof(gYASTControlEvents)/sizeof(EventTypeSpec)),
gYASTControlEvents,
varsp, &controlEvents);
if (err == noErr) {
varsp->fControlEvents = windowEvents;
/* carbon event handlers for the control's window */
err = InstallEventHandler( GetWindowEventTarget( varsp->fWindow ),
gTPEventHandlerUPP, (sizeof(gYASTControlWindowEvents)/sizeof(EventTypeSpec)),
gYASTControlWindowEvents, varsp, &windowEvents);
if (err == noErr) {
varsp->fWindowEvents = windowEvents;
}
}
}
/* perform final activations and setup for our text field. Here,
we assume that the window is going to be the 'active' window. */
if (err == noErr) {
SetTextActivation(varsp, (varsp->fIsActive && varsp->fInFocus));
}
/* clean up on error */
if (err != noErr) {
if (controlEvents != NULL) RemoveEventHandler(controlEvents);
if (windowEvents != NULL) RemoveEventHandler(windowEvents);
if (theTXNObject != NULL) TXNDeleteObject(theTXNObject);
if (outlineRegion != NULL) DisposeRgn(outlineRegion);
if (varsp != NULL) free((void*) varsp);
}
/* all done */
return err;
}