1443 lines
47 KiB
C++
1443 lines
47 KiB
C++
/*
|
|
File: TView.cp
|
|
|
|
Version: 1.0
|
|
|
|
Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc.
|
|
("Apple") in consideration of your agreement to the following terms, and your
|
|
use, installation, modification or redistribution of this Apple software
|
|
constitutes acceptance of these terms. If you do not agree with these terms,
|
|
please do not use, install, modify or redistribute this Apple software.
|
|
|
|
In consideration of your agreement to abide by the following terms, and subject
|
|
to these terms, Apple grants you a personal, non-exclusive license, under AppleÕs
|
|
copyrights in this original Apple software (the "Apple Software"), to use,
|
|
reproduce, modify and redistribute the Apple Software, with or without
|
|
modifications, in source and/or binary forms; provided that if you redistribute
|
|
the Apple Software in its entirety and without modifications, you must retain
|
|
this notice and the following text and disclaimers in all such redistributions of
|
|
the Apple Software. Neither the name, trademarks, service marks or logos of
|
|
Apple Computer, Inc. may be used to endorse or promote products derived from the
|
|
Apple Software without specific prior written permission from Apple. Except as
|
|
expressly stated in this notice, no other rights or licenses, express or implied,
|
|
are granted by Apple herein, including but not limited to any patent rights that
|
|
may be infringed by your derivative works or by other works in which the Apple
|
|
Software may be incorporated.
|
|
|
|
The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO
|
|
WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
|
|
WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
|
|
COMBINATION WITH YOUR PRODUCTS.
|
|
|
|
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
|
|
OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
|
|
(INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
|
|
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
Copyright © 2002 Apple Computer, Inc., All Rights Reserved
|
|
*/
|
|
|
|
/*
|
|
NOTE: This is NOWHERE near a completely exhaustive implementation of a view. There are
|
|
many more carbon events one could intercept and hook into this.
|
|
*/
|
|
|
|
#include "TView.h"
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// constants
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
const EventTypeSpec kHIObjectEvents[] =
|
|
{ { kEventClassHIObject, kEventHIObjectConstruct },
|
|
{ kEventClassHIObject, kEventHIObjectInitialize },
|
|
{ kEventClassHIObject, kEventHIObjectDestruct }
|
|
};
|
|
|
|
const EventTypeSpec kHIViewEvents[] =
|
|
{ { kEventClassCommand, kEventCommandProcess },
|
|
{ kEventClassCommand, kEventCommandUpdateStatus },
|
|
|
|
{ kEventClassControl, kEventControlInitialize },
|
|
{ kEventClassControl, kEventControlDraw },
|
|
{ kEventClassControl, kEventControlHitTest },
|
|
{ kEventClassControl, kEventControlGetPartRegion },
|
|
{ kEventClassControl, kEventControlGetData },
|
|
{ kEventClassControl, kEventControlSetData },
|
|
{ kEventClassControl, kEventControlGetOptimalBounds },
|
|
{ kEventClassControl, kEventControlBoundsChanged },
|
|
{ kEventClassControl, kEventControlTrack },
|
|
{ kEventClassControl, kEventControlGetSizeConstraints },
|
|
{ kEventClassControl, kEventControlHit },
|
|
|
|
{ kEventClassControl, kEventControlHiliteChanged },
|
|
{ kEventClassControl, kEventControlActivate },
|
|
{ kEventClassControl, kEventControlDeactivate },
|
|
{ kEventClassControl, kEventControlValueFieldChanged },
|
|
{ kEventClassControl, kEventControlTitleChanged },
|
|
{ kEventClassControl, kEventControlEnabledStateChanged },
|
|
};
|
|
|
|
// This param name was accidentally left unexported for
|
|
// the release of Jaguar.
|
|
const EventParamName kEventParamControlLikesDrag = 'cldg';
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// TView constructor
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
TView::TView(
|
|
HIViewRef inControl )
|
|
: fViewRef( inControl )
|
|
{
|
|
verify_noerr( InstallEventHandler( GetControlEventTarget( fViewRef ), ViewEventHandler,
|
|
GetEventTypeCount( kHIViewEvents ), kHIViewEvents, this, &fHandler ) );
|
|
|
|
mouseEventHandler = NULL;
|
|
fAutoInvalidateFlags = 0;
|
|
debugPrint = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// TView destructor
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
TView::~TView()
|
|
{
|
|
// If we have installed our custom mouse events handler on the window,
|
|
// go forth and remove it. Note: -1 is used to indicate that no handler has
|
|
// been installed yet, but we want to once we get a window.
|
|
if ( mouseEventHandler != NULL && mouseEventHandler != reinterpret_cast<void*>( -1 ) )
|
|
RemoveEventHandler( mouseEventHandler );
|
|
mouseEventHandler = NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Initialize
|
|
//-----------------------------------------------------------------------------------
|
|
// Called during HIObject construction, this is your subclasses' chance to extract
|
|
// any parameters it might have added to the initialization event passed into the
|
|
// HIObjectCreate call.
|
|
//
|
|
OSStatus TView::Initialize( TCarbonEvent& /*inEvent*/ )
|
|
{
|
|
return noErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetBehaviors
|
|
//-----------------------------------------------------------------------------------
|
|
// Returns our behaviors. Any subclass that overrides this should OR in its behaviors
|
|
// into the inherited behaviors.
|
|
//
|
|
UInt32 TView::GetBehaviors()
|
|
{
|
|
return kControlSupportsDataAccess | kControlSupportsGetRegion;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Draw
|
|
//-----------------------------------------------------------------------------------
|
|
// Draw your view. You should draw based on VIEW coordinates, not frame coordinates.
|
|
//
|
|
void TView::Draw(
|
|
RgnHandle /*inLimitRgn*/,
|
|
CGContextRef /*inContext*/ )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// HitTest
|
|
//-----------------------------------------------------------------------------------
|
|
// Asks your view to return what part of itself (if any) is hit by the point given
|
|
// to it. The point is in VIEW coordinates, so you should get the view rect to do
|
|
// bounds checking.
|
|
//
|
|
ControlPartCode TView::HitTest(
|
|
const HIPoint& /*inWhere*/ )
|
|
{
|
|
return kControlNoPart;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetRegion
|
|
//-----------------------------------------------------------------------------------
|
|
// This is called when someone wants to know certain metrics regarding this view.
|
|
// The base class does nothing. Subclasses should handle their own parts, such as
|
|
// the content region by overriding this method. The structure region is, by default,
|
|
// the view's bounds. If a subclass does not have a region for a given part, it
|
|
// should always call the inherited method.
|
|
//
|
|
OSStatus TView::GetRegion(
|
|
ControlPartCode inPart,
|
|
RgnHandle outRgn )
|
|
{
|
|
#pragma unused( inPart, outRgn )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// PrintDebugInfo
|
|
//-----------------------------------------------------------------------------------
|
|
// This is called when asked to print debugging information.
|
|
//
|
|
void TView::PrintDebugInfo()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetData
|
|
//-----------------------------------------------------------------------------------
|
|
// Gets some data from our view. Subclasses should override to handle their own
|
|
// defined data tags. If a tag is not understood by the subclass, it should call the
|
|
// inherited method. As a convienience, we map the request for ControlKind into our
|
|
// GetKind method.
|
|
//
|
|
OSStatus TView::GetData(
|
|
OSType inTag,
|
|
ControlPartCode inPart,
|
|
Size inSize,
|
|
Size* outSize,
|
|
void* inPtr )
|
|
{
|
|
#pragma unused( inPart )
|
|
|
|
OSStatus err = noErr;
|
|
|
|
switch( inTag )
|
|
{
|
|
case kControlKindTag:
|
|
if ( inPtr )
|
|
{
|
|
if ( inSize != sizeof( ControlKind ) )
|
|
err = errDataSizeMismatch;
|
|
else
|
|
( *(ControlKind *) inPtr ) = GetKind();
|
|
}
|
|
*outSize = sizeof( ControlKind );
|
|
break;
|
|
|
|
default:
|
|
err = eventNotHandledErr;
|
|
break;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// SetData
|
|
//-----------------------------------------------------------------------------------
|
|
// Sets some data on our control. Subclasses should override to handle their own
|
|
// defined data tags. If a tag is not understood by the subclass, it should call the
|
|
// inherited method.
|
|
//
|
|
OSStatus TView::SetData(
|
|
OSType inTag,
|
|
ControlPartCode inPart,
|
|
Size inSize,
|
|
const void* inPtr )
|
|
{
|
|
#pragma unused( inTag, inPart, inSize, inPtr )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetOptimalSize
|
|
//-----------------------------------------------------------------------------------
|
|
// Someone wants to know this view's optimal size and text baseline, probably to help
|
|
// do some type of layout. The base class does nothing, but subclasses should
|
|
// override and do something meaningful here.
|
|
//
|
|
OSStatus TView::GetOptimalSize(
|
|
HISize* outSize,
|
|
float* outBaseLine )
|
|
{
|
|
#pragma unused( outSize, outBaseLine )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetSizeConstraints
|
|
//-----------------------------------------------------------------------------------
|
|
// Someone wants to know this view's minimum and maximum sizes, probably to help
|
|
// do some type of layout. The base class does nothing, but subclasses should
|
|
// override and do something meaningful here.
|
|
//
|
|
OSStatus TView::GetSizeConstraints(
|
|
HISize* outMin,
|
|
HISize* outMax )
|
|
{
|
|
#pragma unused( outMin, outMax )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// BoundsChanged
|
|
//-----------------------------------------------------------------------------------
|
|
// The bounds of our view have changed. Subclasses can override here to make note
|
|
// of it and flush caches, etc. The base class does nothing.
|
|
//
|
|
OSStatus TView::BoundsChanged(
|
|
UInt32 inOptions,
|
|
const HIRect& inOriginalBounds,
|
|
const HIRect& inCurrentBounds,
|
|
RgnHandle inInvalRgn )
|
|
{
|
|
#pragma unused( inOptions, inOriginalBounds, inCurrentBounds, inInvalRgn )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// ControlHit
|
|
//-----------------------------------------------------------------------------------
|
|
// The was hit. Subclasses can overide to care about what part was hit.
|
|
//
|
|
OSStatus TView::ControlHit(
|
|
ControlPartCode inPart,
|
|
UInt32 inModifiers )
|
|
{
|
|
#pragma unused( inPart, inModifiers )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// HiliteChanged
|
|
//-----------------------------------------------------------------------------------
|
|
// The hilite of our view has changed. Subclasses can override here to make note
|
|
// of it and flush caches, etc. The base class does nothing.
|
|
//
|
|
OSStatus TView::HiliteChanged(
|
|
ControlPartCode inOriginalPart,
|
|
ControlPartCode inCurrentPart,
|
|
RgnHandle inInvalRgn )
|
|
{
|
|
#pragma unused( inOriginalPart, inCurrentPart, inInvalRgn )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// DragEnter
|
|
//-----------------------------------------------------------------------------------
|
|
// A drag has entered our bounds. The Drag and Drop interface also should have been
|
|
// activated or else this method will NOT be called. If true is returned, this view
|
|
// likes the drag and will receive drag within/leave/receive messages as appropriate.
|
|
// If false is returned, it is assumed the drag is not valid for this view, and no
|
|
// further drag activity will flow into this view unless the drag leaves and is
|
|
// re-entered.
|
|
//
|
|
bool TView::DragEnter(
|
|
DragRef inDrag )
|
|
{
|
|
#pragma unused( inDrag )
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// DragWithin
|
|
//-----------------------------------------------------------------------------------
|
|
// A drag has moved within our bounds. In order for this method to be called, the
|
|
// view must have signaled the drag as being desirable in the DragEnter method. The
|
|
// Drag and Drop interface also should have been activated.
|
|
//
|
|
bool TView::DragWithin(
|
|
DragRef inDrag )
|
|
{
|
|
#pragma unused( inDrag )
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// DragLeave
|
|
//-----------------------------------------------------------------------------------
|
|
// A drag has left. Deal with it. Subclasses should override as necessary. The
|
|
// Drag and Drop interface should be activated in order for this method to be valid.
|
|
// The drag must have also been accepted in the DragEnter method, else this method
|
|
// will NOT be called.
|
|
//
|
|
bool TView::DragLeave(
|
|
DragRef inDrag )
|
|
{
|
|
#pragma unused( inDrag )
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// DragReceive
|
|
//-----------------------------------------------------------------------------------
|
|
// Deal with receiving a drag. By default we return dragNotAcceptedErr. I'm not sure
|
|
// if this is correct, or eventNotHandledErr. Time will tell...
|
|
//
|
|
OSStatus TView::DragReceive(
|
|
DragRef inDrag )
|
|
{
|
|
#pragma unused( inDrag )
|
|
|
|
return dragNotAcceptedErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Track
|
|
//-----------------------------------------------------------------------------------
|
|
// Default tracking method. Subclasses should override as necessary. We do nothing
|
|
// here in the base class, so we return eventNotHandledErr.
|
|
//
|
|
OSStatus TView::Track(
|
|
TCarbonEvent& inEvent,
|
|
ControlPartCode* outPart )
|
|
{
|
|
#pragma unused( inEvent, outPart )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// SetFocusPart
|
|
//-----------------------------------------------------------------------------------
|
|
// Handle focusing. Our base behavior is to punt.
|
|
//
|
|
OSStatus TView::SetFocusPart(
|
|
ControlPartCode inDesiredFocus,
|
|
RgnHandle inInvalidRgn,
|
|
Boolean inFocusEverything,
|
|
ControlPartCode* outActualFocus )
|
|
{
|
|
#pragma unused( inDesiredFocus, inInvalidRgn, inFocusEverything, outActualFocus )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// ProcessCommand
|
|
//-----------------------------------------------------------------------------------
|
|
// Process a command. Subclasses should override as necessary.
|
|
//
|
|
OSStatus TView::ProcessCommand(
|
|
const HICommand& inCommand )
|
|
{
|
|
#pragma unused( inCommand )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// UpdateCommandStatus
|
|
//-----------------------------------------------------------------------------------
|
|
// Update the status for a command. Subclasses should override as necessary.
|
|
//
|
|
OSStatus
|
|
TView::UpdateCommandStatus(
|
|
const HICommand& inCommand )
|
|
{
|
|
#pragma unused( inCommand )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
OSStatus TView::MouseDown(HIPoint& /*inMouseLocation*/, UInt32 /*inKeyModifiers*/, EventMouseButton /*inMouseButton*/, UInt32 /*inClickCount*/ ,
|
|
TCarbonEvent& /*inEvent*/)
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
OSStatus TView::MouseUp(HIPoint& /*inMouseLocation*/, UInt32 /*inKeyModifiers*/, EventMouseButton /*inMouseButton*/, UInt32 /*inClickCount*/ )
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
OSStatus TView::MouseDragged(HIPoint& /*inMouseLocation*/, UInt32 /*inKeyModifiers*/, EventMouseButton /*inMouseButton*/, UInt32 /*inClickCount*/ )
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
OSStatus TView::MouseEntered(HIPoint& /*inMouseLocation*/, UInt32 /*inKeyModifiers*/, EventMouseButton /*inMouseButton*/, UInt32 /*inClickCount*/ )
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
OSStatus TView::MouseExited(HIPoint& /*inMouseLocation*/, UInt32 /*inKeyModifiers*/, EventMouseButton /*inMouseButton*/, UInt32 /*inClickCount*/ )
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
OSStatus TView::MouseWheelMoved( EventMouseWheelAxis /*inAxis*/, SInt32 /*inDelta*/, UInt32 /*inKeyModifiers*/ )
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
OSStatus TView::ContextualMenuClick( HIPoint& /*inMouseLocation*/ )
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// ActivateInterface
|
|
//-----------------------------------------------------------------------------------
|
|
// This routine is used to allow a subclass to turn on a specific event or suite of
|
|
// events, like Drag and Drop. This allows us to keep event traffic down if we are
|
|
// not interested, but register for the events if we are.
|
|
//
|
|
OSStatus TView::ActivateInterface(
|
|
TView::Interface inInterface )
|
|
{
|
|
OSStatus result = noErr;
|
|
|
|
switch( inInterface )
|
|
{
|
|
case kDragAndDrop:
|
|
{
|
|
static const EventTypeSpec kDragEvents[] =
|
|
{
|
|
{ kEventClassControl, kEventControlDragEnter },
|
|
{ kEventClassControl, kEventControlDragLeave },
|
|
{ kEventClassControl, kEventControlDragWithin },
|
|
{ kEventClassControl, kEventControlDragReceive }
|
|
};
|
|
|
|
result = AddEventTypesToHandler( fHandler, GetEventTypeCount( kDragEvents ),
|
|
kDragEvents );
|
|
|
|
SetControlDragTrackingEnabled( GetViewRef(), true);
|
|
}
|
|
break;
|
|
|
|
case kKeyboardFocus:
|
|
{
|
|
static const EventTypeSpec kKeyboardFocusEvents[] =
|
|
{
|
|
{ kEventClassControl, kEventControlSetFocusPart },
|
|
{ kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
|
|
};
|
|
|
|
result = AddEventTypesToHandler( fHandler, GetEventTypeCount( kKeyboardFocusEvents ),
|
|
kKeyboardFocusEvents );
|
|
}
|
|
break;
|
|
|
|
case kMouse:
|
|
{
|
|
if ( mouseEventHandler == NULL )
|
|
{
|
|
// This case is quite different: Mouse events are delivered to the window, not the controls.
|
|
// mouse wheel events are the exception: They ARE delivered to the control
|
|
static const EventTypeSpec kControlMouseEvents[] =
|
|
{
|
|
{ kEventClassMouse, kEventMouseWheelMoved },
|
|
{ kEventClassControl, kEventControlContextualMenuClick },
|
|
// So we can reinstall our events when the window changes
|
|
{ kEventClassControl, kEventControlOwningWindowChanged },
|
|
};
|
|
|
|
result = AddEventTypesToHandler( fHandler, GetEventTypeCount( kControlMouseEvents ),
|
|
kControlMouseEvents );
|
|
}
|
|
|
|
if ( this->GetOwner() != NULL )
|
|
{
|
|
// We use "-1" to indicate that we want to install an event handler once we get a window
|
|
if ( mouseEventHandler != NULL && mouseEventHandler != reinterpret_cast<void*>( -1 ) )
|
|
{
|
|
result = RemoveEventHandler( mouseEventHandler );
|
|
}
|
|
mouseEventHandler = NULL;
|
|
|
|
static const EventTypeSpec kWindowMouseEvents[] =
|
|
{
|
|
{ kEventClassMouse, kEventMouseDown },
|
|
{ kEventClassMouse, kEventMouseUp },
|
|
{ kEventClassMouse, kEventMouseMoved },
|
|
{ kEventClassMouse, kEventMouseDragged },
|
|
};
|
|
|
|
result = InstallEventHandler( GetWindowEventTarget( this->GetOwner() ), WindowEventHandler,
|
|
GetEventTypeCount( kWindowMouseEvents ), kWindowMouseEvents,
|
|
this, &mouseEventHandler );
|
|
}
|
|
// If we have no window yet. Set the mouseEventHandler to -1 so when we get one we
|
|
// will install the event handler
|
|
else
|
|
{
|
|
mouseEventHandler = reinterpret_cast<EventHandlerRef>( -1 );
|
|
}
|
|
}
|
|
break;
|
|
case kMouseTracking:
|
|
{
|
|
{
|
|
static const EventTypeSpec kControlMouseEvents[] =
|
|
{
|
|
{ kEventClassMouse, kEventMouseEntered }, // only works if mousetracking is started
|
|
{ kEventClassMouse, kEventMouseExited }, // only works if mousetracking is started
|
|
};
|
|
|
|
result = AddEventTypesToHandler( fHandler, GetEventTypeCount( kControlMouseEvents ),
|
|
kControlMouseEvents );
|
|
}
|
|
}
|
|
|
|
//default:
|
|
// assert( false );
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
OSStatus TView::InstallTimer( EventTimerInterval inFireDelay, EventLoopTimerRef* outTimer )
|
|
{
|
|
return InstallEventLoopTimer( GetCurrentEventLoop(), inFireDelay, inFireDelay, TimerEventHandler, this, outTimer );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// RegisterSubclass
|
|
//-----------------------------------------------------------------------------------
|
|
// This routine should be called by subclasses so they can be created as HIObjects.
|
|
//
|
|
OSStatus TView::RegisterSubclass(
|
|
CFStringRef inID,
|
|
ConstructProc inProc )
|
|
{
|
|
return HIObjectRegisterSubclass( inID, kHIViewClassID, 0, ObjectEventHandler,
|
|
GetEventTypeCount( kHIObjectEvents ), kHIObjectEvents, (void*) inProc, NULL );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// ObjectEventHandler
|
|
//-----------------------------------------------------------------------------------
|
|
// Our static event handler proc. We handle any HIObject based events directly in
|
|
// here at present.
|
|
//
|
|
pascal OSStatus TView::ObjectEventHandler(
|
|
EventHandlerCallRef inCallRef,
|
|
EventRef inEvent,
|
|
void* inUserData )
|
|
{
|
|
OSStatus result = eventNotHandledErr;
|
|
TView* view = (TView*) inUserData;
|
|
TCarbonEvent event( inEvent );
|
|
|
|
switch ( event.GetClass() )
|
|
{
|
|
case kEventClassHIObject:
|
|
switch ( event.GetKind() )
|
|
{
|
|
case kEventHIObjectConstruct:
|
|
{
|
|
ControlRef control; // ControlRefs are HIObjectRefs
|
|
TView* view;
|
|
|
|
result = event.GetParameter<HIObjectRef>( kEventParamHIObjectInstance,
|
|
typeHIObjectRef, (HIObjectRef*)&control );
|
|
require_noerr( result, ParameterMissing );
|
|
|
|
// on entry for our construct event, we're passed the
|
|
// creation proc we registered with for this class.
|
|
// we use it now to create the instance, and then we
|
|
// replace the instance parameter data with said instance
|
|
// as type void.
|
|
|
|
result = (*(ConstructProc)inUserData)( control, &view );
|
|
if ( result == noErr )
|
|
event.SetParameter<TViewPtr>( kEventParamHIObjectInstance,
|
|
typeVoidPtr, view );
|
|
}
|
|
break;
|
|
|
|
case kEventHIObjectInitialize:
|
|
result = CallNextEventHandler( inCallRef, inEvent );
|
|
if ( result == noErr )
|
|
result = view->Initialize( event );
|
|
break;
|
|
|
|
case kEventHIObjectDestruct:
|
|
delete view;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
ParameterMissing:
|
|
|
|
return result;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// ViewEventHandler
|
|
//-----------------------------------------------------------------------------------
|
|
// Our static event handler proc. We handle all non-HIObject events here.
|
|
//
|
|
pascal OSStatus TView::ViewEventHandler(
|
|
EventHandlerCallRef inCallRef,
|
|
EventRef inEvent,
|
|
void* inUserData )
|
|
{
|
|
OSStatus result;
|
|
TView* view = (TView*) inUserData;
|
|
TCarbonEvent event( inEvent );
|
|
//if (view->debugPrint)
|
|
// fprintf(stderr,"TView::ViewEventHandler\n");
|
|
result = view->HandleEvent( inCallRef, event );
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
pascal OSStatus TView::WindowEventHandler(
|
|
EventHandlerCallRef inCallRef,
|
|
EventRef inEvent,
|
|
void* inUserData )
|
|
{
|
|
TView* view = reinterpret_cast<TView*>( inUserData );
|
|
TCarbonEvent event( inEvent );
|
|
|
|
const WindowRef window = view->GetOwner();
|
|
if (NULL == window)
|
|
return eventNotHandledErr;
|
|
|
|
// If the window is not active, let the standard window handler execute.
|
|
if ( ! IsWindowActive( window ) ) return eventNotHandledErr;
|
|
if (view->debugPrint)
|
|
fprintf(stderr,"TView::WindowEventHandler\n");
|
|
|
|
const HIViewRef rootView = HIViewGetRoot( window );
|
|
if (NULL == rootView)
|
|
return eventNotHandledErr;
|
|
|
|
// TODO: On OS X 10.3, test if this bug still exists
|
|
// This is a hack to work around a bug in the OS. See:
|
|
// http://lists.apple.com/archives/carbon-development/2002/Sep/29/keventmousemovedeventsno.004.txt
|
|
OSStatus err;
|
|
if ( event.GetKind() == kEventMouseMoved )
|
|
{
|
|
// We need to set some parameters correctly
|
|
event.SetParameter( kEventParamWindowRef, window );
|
|
|
|
HIPoint ptMouse;
|
|
event.GetParameter( kEventParamMouseLocation, &ptMouse );
|
|
|
|
// convert screen coords to window relative
|
|
Rect bounds;
|
|
err = GetWindowBounds( window, kWindowStructureRgn, &bounds );
|
|
if( err == noErr )
|
|
{
|
|
ptMouse.x -= bounds.left;
|
|
ptMouse.y -= bounds.top;
|
|
event.SetParameter( kEventParamWindowMouseLocation, ptMouse );
|
|
}
|
|
}
|
|
|
|
HIViewRef targetView = NULL;
|
|
err = HIViewGetViewForMouseEvent( rootView, inEvent, &targetView );
|
|
//if (view->debugPrint)
|
|
// fprintf(stderr,"TView::WindowEventHandler root[%08X] viewRef[%08X] targetView[%08X]\n", rootView, view->GetViewRef(), targetView);
|
|
if ( targetView == view->GetViewRef() || event.GetKind() == kEventMouseDragged )
|
|
{
|
|
return view->HandleEvent( inCallRef, event );
|
|
}
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
pascal void TView::TimerEventHandler( EventLoopTimerRef inTimer, void* view )
|
|
{
|
|
reinterpret_cast<TView*>( view )->TimerFired( inTimer );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// HandleEvent
|
|
//-----------------------------------------------------------------------------------
|
|
// Our object's virtual event handler method. I'm not sure if we need this these days.
|
|
// We used to do various things with it, but those days are long gone...
|
|
//
|
|
OSStatus TView::HandleEvent(
|
|
EventHandlerCallRef inCallRef,
|
|
TCarbonEvent& inEvent )
|
|
{
|
|
#pragma unused( inCallRef )
|
|
|
|
OSStatus result = eventNotHandledErr;
|
|
HIPoint where;
|
|
OSType tag;
|
|
void * ptr;
|
|
Size size, outSize;
|
|
UInt32 features;
|
|
RgnHandle region = NULL;
|
|
ControlPartCode part;
|
|
RgnHandle invalRgn;
|
|
|
|
switch ( inEvent.GetClass() )
|
|
{
|
|
case kEventClassCommand:
|
|
{
|
|
HICommand command;
|
|
|
|
result = inEvent.GetParameter( kEventParamDirectObject, &command );
|
|
require_noerr( result, MissingParameter );
|
|
|
|
switch ( inEvent.GetKind() )
|
|
{
|
|
case kEventCommandProcess:
|
|
result = ProcessCommand( command );
|
|
break;
|
|
|
|
case kEventCommandUpdateStatus:
|
|
result = UpdateCommandStatus( command );
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kEventClassControl:
|
|
switch ( inEvent.GetKind() )
|
|
{
|
|
case kEventControlInitialize:
|
|
features = GetBehaviors();
|
|
inEvent.SetParameter( kEventParamControlFeatures, features );
|
|
result = noErr;
|
|
break;
|
|
|
|
case kEventControlDraw:
|
|
{
|
|
CGContextRef context = NULL;
|
|
|
|
inEvent.GetParameter( kEventParamRgnHandle, ®ion );
|
|
inEvent.GetParameter<CGContextRef>( kEventParamCGContextRef, typeCGContextRef, &context );
|
|
|
|
Draw( region, context );
|
|
result = noErr;
|
|
}
|
|
break;
|
|
|
|
case kEventControlHitTest:
|
|
inEvent.GetParameter<HIPoint>( kEventParamMouseLocation, typeHIPoint, &where );
|
|
part = HitTest( where );
|
|
inEvent.SetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, part );
|
|
result = noErr;
|
|
break;
|
|
|
|
case kEventControlGetPartRegion:
|
|
inEvent.GetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, &part );
|
|
inEvent.GetParameter( kEventParamControlRegion, ®ion );
|
|
result = GetRegion( part, region );
|
|
break;
|
|
|
|
case kEventControlGetData:
|
|
inEvent.GetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, &part );
|
|
inEvent.GetParameter<OSType>( kEventParamControlDataTag, typeEnumeration, &tag );
|
|
inEvent.GetParameter<Ptr>( kEventParamControlDataBuffer, typePtr, (Ptr*)&ptr );
|
|
inEvent.GetParameter<Size>( kEventParamControlDataBufferSize, typeLongInteger, &size );
|
|
|
|
result = GetData( tag, part, size, &outSize, ptr );
|
|
|
|
if ( result == noErr )
|
|
verify_noerr( inEvent.SetParameter<Size>( kEventParamControlDataBufferSize, typeLongInteger, outSize ) );
|
|
break;
|
|
|
|
case kEventControlSetData:
|
|
inEvent.GetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, &part );
|
|
inEvent.GetParameter<OSType>( kEventParamControlDataTag, typeEnumeration, &tag );
|
|
inEvent.GetParameter<Ptr>( kEventParamControlDataBuffer, typePtr, (Ptr*)&ptr );
|
|
inEvent.GetParameter<Size>( kEventParamControlDataBufferSize, typeLongInteger, &size );
|
|
|
|
result = SetData( tag, part, size, ptr );
|
|
break;
|
|
|
|
case kEventControlGetOptimalBounds:
|
|
{
|
|
HISize size;
|
|
float floatBaseLine;
|
|
|
|
result = GetOptimalSize( &size, &floatBaseLine );
|
|
if ( result == noErr )
|
|
{
|
|
Rect bounds;
|
|
SInt16 baseLine;
|
|
|
|
GetControlBounds( GetViewRef(), &bounds );
|
|
|
|
bounds.bottom = bounds.top + (SInt16)size.height;
|
|
bounds.right = bounds.left + (SInt16)size.width;
|
|
baseLine = (SInt16)floatBaseLine;
|
|
|
|
inEvent.SetParameter( kEventParamControlOptimalBounds, bounds );
|
|
inEvent.SetParameter<SInt16>( kEventParamControlOptimalBaselineOffset, typeShortInteger, baseLine );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kEventControlBoundsChanged:
|
|
{
|
|
HIRect prevRect, currRect;
|
|
UInt32 attrs;
|
|
|
|
inEvent.GetParameter( kEventParamAttributes, &attrs );
|
|
inEvent.GetParameter( kEventParamOriginalBounds, &prevRect );
|
|
inEvent.GetParameter( kEventParamCurrentBounds, &currRect );
|
|
inEvent.GetParameter( kEventParamControlInvalRgn, &invalRgn );
|
|
|
|
result = BoundsChanged( attrs, prevRect, currRect, invalRgn );
|
|
|
|
if ( mouseEventHandler != NULL )
|
|
{
|
|
ActivateInterface( kMouse );
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case kEventControlHit:
|
|
{
|
|
UInt32 modifiers;
|
|
|
|
inEvent.GetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, &part );
|
|
inEvent.GetParameter( kEventParamKeyModifiers, &modifiers );
|
|
|
|
result = ControlHit( part, modifiers );
|
|
}
|
|
break;
|
|
|
|
case kEventControlHiliteChanged:
|
|
{
|
|
ControlPartCode prevPart, currPart;
|
|
|
|
inEvent.GetParameter<ControlPartCode>( kEventParamControlPreviousPart, typeControlPartCode, &prevPart );
|
|
inEvent.GetParameter<ControlPartCode>( kEventParamControlCurrentPart, typeControlPartCode, &currPart );
|
|
inEvent.GetParameter( kEventParamControlInvalRgn, &invalRgn );
|
|
|
|
result = HiliteChanged( prevPart, currPart, invalRgn );
|
|
|
|
if ( GetAutoInvalidateFlags() & kAutoInvalidateOnHilite )
|
|
Invalidate();
|
|
}
|
|
break;
|
|
|
|
case kEventControlActivate:
|
|
result = ActiveStateChanged();
|
|
|
|
if ( GetAutoInvalidateFlags() & kAutoInvalidateOnActivate )
|
|
Invalidate();
|
|
break;
|
|
|
|
case kEventControlDeactivate:
|
|
result = ActiveStateChanged();
|
|
|
|
if ( GetAutoInvalidateFlags() & kAutoInvalidateOnActivate )
|
|
Invalidate();
|
|
break;
|
|
|
|
case kEventControlValueFieldChanged:
|
|
result = ValueChanged();
|
|
|
|
if ( GetAutoInvalidateFlags() & kAutoInvalidateOnValueChange )
|
|
Invalidate();
|
|
break;
|
|
|
|
case kEventControlTitleChanged:
|
|
result = TitleChanged();
|
|
|
|
if ( GetAutoInvalidateFlags() & kAutoInvalidateOnTitleChange )
|
|
Invalidate();
|
|
break;
|
|
|
|
case kEventControlEnabledStateChanged:
|
|
result = EnabledStateChanged();
|
|
|
|
if ( GetAutoInvalidateFlags() & kAutoInvalidateOnEnable )
|
|
Invalidate();
|
|
break;
|
|
|
|
case kEventControlDragEnter:
|
|
case kEventControlDragLeave:
|
|
case kEventControlDragWithin:
|
|
{
|
|
DragRef drag;
|
|
bool likesDrag;
|
|
|
|
inEvent.GetParameter( kEventParamDragRef, &drag );
|
|
|
|
switch ( inEvent.GetKind() )
|
|
{
|
|
case kEventControlDragEnter:
|
|
likesDrag = DragEnter( drag );
|
|
// Why only if likesDrag? What if it doesn't? No parameter?
|
|
if ( likesDrag )
|
|
result = inEvent.SetParameter( kEventParamControlLikesDrag, likesDrag );
|
|
break;
|
|
|
|
case kEventControlDragLeave:
|
|
DragLeave( drag );
|
|
result = noErr;
|
|
break;
|
|
|
|
case kEventControlDragWithin:
|
|
DragWithin( drag );
|
|
result = noErr;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kEventControlDragReceive:
|
|
{
|
|
DragRef drag;
|
|
|
|
inEvent.GetParameter( kEventParamDragRef, &drag );
|
|
|
|
result = DragReceive( drag );
|
|
}
|
|
break;
|
|
|
|
case kEventControlTrack:
|
|
{
|
|
ControlPartCode part;
|
|
|
|
result = Track( inEvent, &part );
|
|
if ( result == noErr )
|
|
verify_noerr( inEvent.SetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, part ) );
|
|
}
|
|
break;
|
|
|
|
case kEventControlGetSizeConstraints:
|
|
{
|
|
HISize minSize, maxSize;
|
|
|
|
result = GetSizeConstraints( &minSize, &maxSize );
|
|
|
|
if ( result == noErr )
|
|
{
|
|
verify_noerr( inEvent.SetParameter( kEventParamMinimumSize, minSize ) );
|
|
verify_noerr( inEvent.SetParameter( kEventParamMaximumSize, maxSize ) );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kEventControlSetFocusPart:
|
|
{
|
|
ControlPartCode desiredFocus;
|
|
RgnHandle invalidRgn;
|
|
Boolean focusEverything;
|
|
ControlPartCode actualFocus;
|
|
|
|
result = inEvent.GetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, &desiredFocus );
|
|
require_noerr( result, MissingParameter );
|
|
|
|
inEvent.GetParameter( kEventParamControlInvalRgn, &invalidRgn );
|
|
|
|
focusEverything = false; // a good default in case the parameter doesn't exist
|
|
|
|
inEvent.GetParameter( kEventParamControlFocusEverything, &focusEverything );
|
|
|
|
result = SetFocusPart( desiredFocus, invalidRgn, focusEverything, &actualFocus );
|
|
|
|
if ( result == noErr )
|
|
verify_noerr( inEvent.SetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, actualFocus ) );
|
|
}
|
|
break;
|
|
|
|
case kEventControlOwningWindowChanged:
|
|
{
|
|
// If our owning window has changed, reactivate the mouse interface
|
|
if ( mouseEventHandler != NULL )
|
|
{
|
|
ActivateInterface( kMouse );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kEventControlContextualMenuClick:
|
|
{
|
|
HIPoint ptMouse;
|
|
inEvent.GetParameter( kEventParamMouseLocation, &ptMouse );
|
|
result = ContextualMenuClick( ptMouse );
|
|
}
|
|
break;
|
|
|
|
// some other kind of Control event
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case kEventClassTextInput:
|
|
result = TextInput( inEvent );
|
|
break;
|
|
|
|
case kEventClassMouse:
|
|
{
|
|
result = inEvent.GetParameter<HIPoint>( kEventParamWindowMouseLocation, typeHIPoint, &where );
|
|
HIViewConvertPoint( &where, NULL, fViewRef );
|
|
|
|
UInt32 inKeyModifiers;
|
|
result = inEvent.GetParameter( kEventParamKeyModifiers, &inKeyModifiers );
|
|
if( result != noErr )
|
|
inKeyModifiers = 0;
|
|
EventMouseButton inMouseButton = 0;
|
|
result = inEvent.GetParameter<EventMouseButton>( kEventParamMouseButton, typeMouseButton, &inMouseButton );
|
|
if (noErr != result)
|
|
// assume no button is pressed if there is no button info
|
|
inMouseButton = 0;
|
|
UInt32 inClickCount;
|
|
result = inEvent.GetParameter( kEventParamClickCount, &inClickCount );
|
|
if( result != noErr )
|
|
inClickCount = 0;
|
|
|
|
switch ( inEvent.GetKind() )
|
|
{
|
|
case kEventMouseWheelMoved:
|
|
{
|
|
EventMouseWheelAxis inAxis;
|
|
result = inEvent.GetParameter<EventMouseWheelAxis>( kEventParamMouseWheelAxis, typeMouseWheelAxis, &inAxis );
|
|
|
|
SInt32 inDelta;
|
|
result = inEvent.GetParameter<SInt32>( kEventParamMouseWheelDelta, typeSInt32, &inDelta );
|
|
|
|
result = MouseWheelMoved( inAxis, inDelta, inKeyModifiers );
|
|
break;
|
|
}
|
|
case kEventMouseDown:
|
|
result = MouseDown( where, inKeyModifiers, inMouseButton, inClickCount, inEvent );
|
|
break;
|
|
case kEventMouseUp:
|
|
result = MouseUp( where, inKeyModifiers, inMouseButton, inClickCount );
|
|
break;
|
|
case kEventMouseExited:
|
|
result = MouseExited( where, inKeyModifiers, inMouseButton, inClickCount );
|
|
break;
|
|
case kEventMouseEntered:
|
|
result = MouseEntered( where, inKeyModifiers, inMouseButton, inClickCount );
|
|
break;
|
|
case kEventMouseMoved:
|
|
case kEventMouseDragged:
|
|
result = MouseDragged( where, inKeyModifiers, inMouseButton, inClickCount );
|
|
break;
|
|
default:;
|
|
}
|
|
break;
|
|
}
|
|
// some other event class
|
|
default:
|
|
break;
|
|
}
|
|
|
|
MissingParameter:
|
|
return result;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// CreateInitializationEvent
|
|
//-----------------------------------------------------------------------------------
|
|
// Create a basic intialization event containing the parent control and bounds. At
|
|
// present we set the bounds to empty and the parent to NULL. In theory, after creating
|
|
// this event, any subclass could add its own parameter to receive in its
|
|
// Initialize method.
|
|
//
|
|
EventRef TView::CreateInitializationEvent()
|
|
{
|
|
OSStatus result = noErr;
|
|
EventRef event;
|
|
|
|
result = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize,
|
|
GetCurrentEventTime(), 0, &event );
|
|
require_noerr_action( result, CantCreateEvent, event = NULL );
|
|
|
|
CantCreateEvent:
|
|
return event;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Frame
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
HIRect TView::Frame()
|
|
{
|
|
HIRect frame;
|
|
|
|
HIViewGetFrame( GetViewRef(), &frame );
|
|
|
|
return frame;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// SetFrame
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
OSStatus TView::SetFrame(
|
|
const HIRect& inFrame )
|
|
{
|
|
OSStatus err;
|
|
|
|
err = HIViewSetFrame( GetViewRef(), &inFrame );
|
|
|
|
return err;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Bounds
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
HIRect TView::Bounds()
|
|
{
|
|
HIRect bounds;
|
|
|
|
HIViewGetBounds( GetViewRef(), &bounds );
|
|
|
|
return bounds;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Show
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
OSStatus TView::Show()
|
|
{
|
|
return HIViewSetVisible( GetViewRef(), true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Hide
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
OSStatus TView::Hide()
|
|
{
|
|
return HIViewSetVisible( GetViewRef(), false );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetEventTarget
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
EventTargetRef TView::GetEventTarget()
|
|
{
|
|
return HIObjectGetEventTarget( (HIObjectRef) GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// AddSubView
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
OSStatus TView::AddSubView(
|
|
TView* inSubView )
|
|
{
|
|
return HIViewAddSubview( GetViewRef(), inSubView->GetViewRef() );;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// RemoveFromSuperView
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
OSStatus TView::RemoveFromSuperView()
|
|
{
|
|
return HIViewRemoveFromSuperview( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetHilite
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
ControlPartCode TView::GetHilite()
|
|
{
|
|
return GetControlHilite( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetValue
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
SInt32 TView::GetValue()
|
|
{
|
|
return GetControl32BitValue( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// SetValue
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
void TView::SetValue(
|
|
SInt32 inValue )
|
|
{
|
|
SetControl32BitValue( GetViewRef(), inValue );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetMinimum
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
SInt32 TView::GetMinimum()
|
|
{
|
|
return GetControlMinimum( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// SetMinimum
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
void TView::SetMinimum(
|
|
SInt32 inMinimum )
|
|
{
|
|
SetControlMinimum( GetViewRef(), inMinimum );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetMaximum
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
SInt32 TView::GetMaximum()
|
|
{
|
|
return GetControlMaximum( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// SetMaximum
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
void TView::SetMaximum(
|
|
SInt32 inMaximum )
|
|
{
|
|
SetControlMaximum( GetViewRef(), inMaximum );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// GetOwner
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
WindowRef TView::GetOwner()
|
|
{
|
|
return GetControlOwner( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Hilite
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
void TView::Hilite(
|
|
ControlPartCode inPart)
|
|
{
|
|
return HiliteControl( GetViewRef(), inPart );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Invalidate
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
OSStatus TView::Invalidate()
|
|
{
|
|
return HIViewSetNeedsDisplay( GetViewRef(), true );
|
|
}
|
|
|
|
void TView::TimerFired( EventLoopTimerRef inTimer )
|
|
{
|
|
#pragma unused( inTimer )
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// IsVisible
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
Boolean TView::IsVisible()
|
|
{
|
|
return IsControlVisible( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// IsEnabled
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
Boolean TView::IsEnabled()
|
|
{
|
|
return IsControlEnabled( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// IsActive
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
Boolean TView::IsActive()
|
|
{
|
|
return IsControlActive( GetViewRef() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// ActiveStateChanged
|
|
//-----------------------------------------------------------------------------------
|
|
// Default activation method. Subclasses should override as necessary. We do nothing
|
|
// here in the base class, so we return eventNotHandledErr.
|
|
//
|
|
OSStatus TView::ActiveStateChanged()
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// ValueChanged
|
|
//-----------------------------------------------------------------------------------
|
|
// Default value changed method. Subclasses should override as necessary. We do
|
|
// nothing here in the base class, so we return eventNotHandledErr.
|
|
//
|
|
OSStatus TView::ValueChanged()
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// TitleChanged
|
|
//-----------------------------------------------------------------------------------
|
|
// Default title changed method. Subclasses should override as necessary. We
|
|
// do nothing here in the base class, so we return eventNotHandledErr.
|
|
//
|
|
OSStatus TView::TitleChanged()
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// EnabledStateChanged
|
|
//-----------------------------------------------------------------------------------
|
|
// Default enable method. Subclasses should override as necessary. We
|
|
// do nothing here in the base class, so we return eventNotHandledErr.
|
|
//
|
|
OSStatus TView::EnabledStateChanged()
|
|
{
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// TextInput
|
|
//-----------------------------------------------------------------------------------
|
|
// Default text (Unicode) input method. Subclasses should override as necessary. We
|
|
// do nothing here in the base class, so we return eventNotHandledErr.
|
|
//
|
|
OSStatus TView::TextInput(
|
|
TCarbonEvent& inEvent )
|
|
{
|
|
#pragma unused( inEvent )
|
|
|
|
return eventNotHandledErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// ChangeAutoInvalidateFlags
|
|
//-----------------------------------------------------------------------------------
|
|
// Change behavior for auto-invalidating views on certain actions.
|
|
//
|
|
void TView::ChangeAutoInvalidateFlags(
|
|
OptionBits inSetThese,
|
|
OptionBits inClearThese )
|
|
{
|
|
fAutoInvalidateFlags = ( ( fAutoInvalidateFlags | inSetThese ) & ( ~inClearThese ) );
|
|
}
|