/////////////////////////////////////////////////////////////////////////////
-// Name: src/osx/carbon/toolbar.cpp
+// Name: src/osx/cocoa/toolbar.mm
// Purpose: wxToolBar
// Author: Stefan Csomor
// Modified by:
// Created: 04/01/98
-// RCS-ID: $Id: toolbar.cpp 54954 2008-08-03 11:27:03Z VZ $
+// RCS-ID: $Id$
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#if wxUSE_TOOLBAR
-#include "wx/toolbar.h"
-
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
+#include "wx/toolbar.h"
#include "wx/app.h"
#include "wx/osx/private.h"
#include "wx/geometry.h"
// private classes
// ----------------------------------------------------------------------------
+class wxToolBarTool;
+
+@interface wxNSToolBarButton : NSButton
+{
+ wxToolBarTool* impl;
+}
+
+- (id)initWithFrame:(NSRect)frame;
+- (void) clickedAction: (id) sender;
+- (void)setImplementation: (wxToolBarTool *) theImplementation;
+- (wxToolBarTool*) implementation;
+- (BOOL) isFlipped;
+
+@end
+
// We have a dual implementation for each tool, WXWidget and NSToolbarItem*
// when embedding native controls in the native toolbar we must make sure the
}
else if ( IsButton() )
{
- curSize = GetToolBar()->GetToolSize();
+ // curSize = GetToolBar()->GetToolSize();
+ NSRect best = [(wxNSToolBarButton*)m_controlHandle frame];
+ curSize = wxSize(best.size.width, best.size.height);
}
else
{
// separator size
curSize = GetToolBar()->GetToolSize();
- if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL )
+ if ( GetToolBar()->IsVertical() )
curSize.y /= 4;
else
curSize.x /= 4;
return wxPoint( m_x, m_y );
}
- bool DoEnable( bool enable );
+ bool Enable( bool enable );
void UpdateImages();
-
+
void UpdateToggleImage( bool toggle );
-
+
void UpdateLabel()
{
+ wxString labelStr = wxStripMenuCodes(m_label);
+ wxCFStringRef l(labelStr, GetToolBarFontEncoding());
+ wxCFStringRef sh( GetShortHelp(), GetToolBarFontEncoding() );
#if wxOSX_USE_NATIVE_TOOLBAR
if ( m_toolbarItem )
{
// strip mnemonics from the label for compatibility with the usual
// labels in wxStaticText sense
- wxString labelStr = wxStripMenuCodes(m_label);
- wxCFStringRef l(labelStr, GetToolBarFontEncoding());
[m_toolbarItem setLabel:l.AsNSString()];
-
- wxCFStringRef sh( GetShortHelp(), GetToolBarFontEncoding() );
+
[m_toolbarItem setToolTip:sh.AsNSString()];
}
#endif
+ if ( IsButton() )
+ [(NSButton*)m_controlHandle setTitle:l.AsNSString()];
+
+ if ( m_controlHandle )
+ {
+ [m_controlHandle setToolTip:sh.AsNSString()];
+ }
}
void Action()
tbar->OnLeftClick( GetId(), IsToggled() );
}
-
+
#if wxOSX_USE_NATIVE_TOOLBAR
void SetToolbarItemRef( NSToolbarItem* ref )
{
{
wxToolBarToolBase::SetLabel(label);
UpdateLabel();
- }
+ }
+
+ virtual bool SetShortHelp(const wxString& help)
+ {
+ if ( !wxToolBarToolBase::SetShortHelp(help) )
+ return false;
+
+ UpdateLabel();
+
+ return true;
+ }
#endif // wxOSX_USE_NATIVE_TOOLBAR
private:
- (void)setImplementation: (wxToolBarTool *) theImplementation;
- (wxToolBarTool*) implementation;
- (void) clickedAction: (id) sender;
+- (BOOL) validateToolbarItem:(NSToolbarItem *)theItem;
@end
-@interface wxNSToolbarDelegate : NSObject
+@interface wxNSToolbarDelegate : NSObject wxOSX_10_6_AND_LATER(<NSToolbarDelegate>)
{
+ bool m_isSelectable;
}
+- (void)setSelectable:(bool) value;
+
- (NSToolbarItem *)toolbar:(NSToolbar *)toolbar itemForItemIdentifier:(NSString *)itemIdentifier willBeInsertedIntoToolbar:(BOOL)flag;
-
+
- (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar*)toolbar;
- (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar*)toolbar;
#endif
-@interface wxNSToolBarButton : NSButton
-{
- wxToolBarTool* impl;
-}
-
-- (id)initWithFrame:(NSRect)frame;
-- (void) clickedAction: (id) sender;
-- (void)setImplementation: (wxToolBarTool *) theImplementation;
-- (wxToolBarTool*) implementation;
-- (BOOL) isFlipped;
-
-@end
-
#if wxOSX_USE_NATIVE_TOOLBAR
@implementation wxNSToolbarItem
- (id)initWithItemIdentifier: (NSString*) identifier
{
- [super initWithItemIdentifier:identifier];
+ self = [super initWithItemIdentifier:identifier];
impl = NULL;
[self setTarget: self];
[self setAction: @selector(clickedAction:)];
return impl;
}
+- (BOOL)validateToolbarItem:(NSToolbarItem *)theItem
+{
+ wxUnusedVar(theItem);
+ return impl->IsEnabled() ? YES:NO;
+}
+
@end
@implementation wxNSToolbarDelegate
+- (id)init
+{
+ m_isSelectable = false;
+ return [super init];
+}
+
+- (void)setSelectable:(bool) value
+{
+ m_isSelectable = true;
+}
+
- (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar*)toolbar
{
wxUnusedVar(toolbar);
- (NSArray *)toolbarSelectableItemIdentifiers:(NSToolbar *)toolbar
{
- wxUnusedVar(toolbar);
- return nil;
+ if ( m_isSelectable )
+ return [[toolbar items] valueForKey:@"itemIdentifier"];
+ else
+ return nil;
}
- (NSToolbarItem*) toolbar:(NSToolbar*) toolbar itemForItemIdentifier:(NSString*) itemIdentifier willBeInsertedIntoToolbar:(BOOL) flag
- (id)initWithFrame:(NSRect)frame
{
- [super initWithFrame:frame];
+ self = [super initWithFrame:frame];
impl = NULL;
[self setTarget: self];
[self setAction: @selector(clickedAction:)];
@end
-bool wxToolBarTool::DoEnable( bool enable )
+bool wxToolBarTool::Enable( bool enable )
{
+ if ( wxToolBarToolBase::Enable( enable ) == false )
+ return false;
+
if ( IsControl() )
{
GetControl()->Enable( enable );
frame.origin.y = mac_y;
[m_controlHandle setFrame:frame];
}
- }
+ }
}
void wxToolBarTool::UpdateImages()
dc.SelectObject( m_alternateBitmap );
dc.SetPen( wxPen(*wxBLACK) );
dc.SetBrush( wxBrush( *wxLIGHT_GREY ));
- dc.DrawRectangle( 0, 0, w, h );
+ dc.DrawRoundedRectangle( 0, 0, w, h, 2 );
dc.DrawBitmap( m_bmpNormal, 0, 0, true );
dc.SelectObject( wxNullBitmap );
-
+
[(NSButton*) m_controlHandle setAlternateImage:m_alternateBitmap.GetNSImage()];
}
UpdateToggleImage( CanBeToggled() && IsToggled() );
else
[m_toolbarItem setImage:m_bmpNormal.GetNSImage()];
}
+ else
#endif
+ {
+ if ( IsButton() )
+ [(NSButton*)m_controlHandle setState:(toggle ? NSOnState : NSOffState)];
+ }
}
wxToolBarTool::wxToolBarTool(
if (parent->IsKindOf(CLASSINFO(wxFrame)) && wxSystemOptions::GetOptionInt(wxT("mac.toolbar.no-native")) != 1)
{
static wxNSToolbarDelegate* controller = nil;
-
+
if ( controller == nil )
controller = [[wxNSToolbarDelegate alloc] init];
wxString identifier = wxString::Format( wxT("%p"), this );
wxCFStringRef cfidentifier(identifier);
NSToolbar* tb = [[NSToolbar alloc] initWithIdentifier:cfidentifier.AsNSString()];
-
+
m_macToolbar = tb ;
-
+
if (m_macToolbar != NULL)
{
[tb setDelegate:controller];
-
+
NSToolbarDisplayMode mode = NSToolbarDisplayModeDefault;
NSToolbarSizeMode displaySize = NSToolbarSizeModeSmall;
}
wxToolBar::~wxToolBar()
-{
-#if wxOSX_USE_NATIVE_TOOLBAR
- if (m_macToolbar != NULL)
+{
+ // removal only works while the toolbar is there
+ wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+ if ( frame && frame->GetToolBar() == this )
{
- // if this is the installed toolbar, then deinstall it
- if (m_macUsesNativeToolbar)
- MacInstallNativeToolbar( false );
-
- [(NSToolbar*)m_macToolbar setDelegate:nil];
- [(NSToolbar*)m_macToolbar release];
- m_macToolbar = NULL;
+ frame->SetToolBar(NULL);
}
-#endif
+
+ [(NSToolbar*)m_macToolbar setDelegate:nil];
+ [(NSToolbar*)m_macToolbar release];
+ m_macToolbar = NULL;
}
bool wxToolBar::Show( bool show )
WXWindow tlw = MacGetTopLevelWindowRef();
float toolbarHeight = 0.0;
NSRect windowFrame = NSMakeRect(0, 0, 0, 0);
-
+
if(m_macToolbar && [(NSToolbar*)m_macToolbar isVisible])
{
windowFrame = [NSWindow contentRectForFrameRect:[tlw frame]
toolbarHeight = NSHeight(windowFrame)
- NSHeight([[tlw contentView] frame]);
}
-
+
if ( width != NULL )
- *width = windowFrame.size.width;
+ *width = (int)windowFrame.size.width;
if ( height != NULL )
- *height = toolbarHeight;
+ *height = (int)toolbarHeight;
}
else
wxToolBarBase::DoGetSize( width, height );
#endif
}
-wxSize wxToolBar::DoGetBestSize() const
+void wxToolBar::DoGetPosition(int*x, int *y) const
{
- int width, height;
+#if wxOSX_USE_NATIVE_TOOLBAR
+ bool ownToolbarInstalled;
+
+ MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
+ if ( ownToolbarInstalled )
+ {
+ WXWindow tlw = MacGetTopLevelWindowRef();
+ float toolbarHeight = 0.0;
+ NSRect windowFrame = NSMakeRect(0, 0, 0, 0);
+
+ if(m_macToolbar && [(NSToolbar*)m_macToolbar isVisible])
+ {
+ windowFrame = [NSWindow contentRectForFrameRect:[tlw frame]
+ styleMask:[tlw styleMask]];
+ toolbarHeight = NSHeight(windowFrame)
+ - NSHeight([[tlw contentView] frame]);
+ }
+
+ // it is extending to the north of the content area
+
+ if ( x != NULL )
+ *x = 0;
+ if ( y != NULL )
+ *y = -toolbarHeight;
+ }
+ else
+ wxToolBarBase::DoGetPosition( x, y );
+
+#else
+ wxToolBarBase::DoGetPosition( x, y );
+#endif
+}
- DoGetSize( &width, &height );
+wxSize wxToolBar::DoGetBestSize() const
+{
+ // was updated in Realize()
+
+ wxSize size = GetMinSize();
- return wxSize( width, height );
+ return size;
}
void wxToolBar::SetWindowStyleFlag( long style )
if (usesNative && (m_macToolbar == NULL))
return bResult;
- if (usesNative && ((GetWindowStyleFlag() & wxTB_VERTICAL) != 0))
+ if (usesNative && HasFlag(wxTB_LEFT|wxTB_RIGHT|wxTB_BOTTOM) )
return bResult;
WXWindow tlw = MacGetTopLevelWindowRef();
bResult = true;
[tlw setToolbar:(NSToolbar*) m_macToolbar];
[(NSToolbar*) m_macToolbar setVisible:YES];
-
- m_peer->Move(0,0,0,0 );
+
+ GetPeer()->Move(0,0,0,0 );
SetSize( wxSIZE_AUTO_WIDTH, 0 );
- m_peer->SetVisibility( false );
+ GetPeer()->SetVisibility( false );
wxToolBarBase::Show( false );
}
}
{
bResult = true;
[(NSToolbar*) m_macToolbar setVisible:NO];
- [tlw setToolbar:nil];
- m_peer->SetVisibility( true );
+ MacUninstallNativeToolbar();
+ GetPeer()->SetVisibility( true );
}
}
// wxLogDebug( wxT(" --> [%lx] - result [%s]"), (long)this, bResult ? wxT("T") : wxT("F") );
return bResult;
}
-#endif
-bool wxToolBar::Realize()
+void wxToolBar::MacUninstallNativeToolbar()
{
- if (m_tools.GetCount() == 0)
- return false;
-
- int maxWidth = 0;
- int maxHeight = 0;
+ if (!m_macToolbar)
+ return;
+
+ WXWindow tlw = MacGetTopLevelWindowRef();
+ if (tlw)
+ [tlw setToolbar:nil];
+}
+#endif
+void wxToolBar::DoLayout()
+{
int maxToolWidth = 0;
int maxToolHeight = 0;
-
- int x = m_xMargin + kwxMacToolBarLeftMargin;
- int y = m_yMargin + kwxMacToolBarTopMargin;
-
+
int tw, th;
GetSize( &tw, &th );
-
+
// find the maximum tool width and height
+ // and the number of stretchable items
+ int numStretchableSpaces = 0;
wxToolBarTool *tool;
wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
while ( node )
if ( tool != NULL )
{
wxSize sz = tool->GetSize();
-
+
if ( sz.x > maxToolWidth )
maxToolWidth = sz.x;
if ( sz.y > maxToolHeight )
maxToolHeight = sz.y;
+ if ( tool->IsStretchableSpace() )
+ numStretchableSpaces++;
}
-
+
node = node->GetNext();
}
- bool lastIsRadio = false;
- bool curIsRadio = false;
-
-#if wxOSX_USE_NATIVE_TOOLBAR
- CFIndex currentPosition = 0;
- bool insertAll = false;
-
- NSToolbar* refTB = (NSToolbar*)m_macToolbar;
- wxFont f;
- wxFontEncoding enc;
- f = GetFont();
- if ( f.IsOk() )
- enc = f.GetEncoding();
- else
- enc = wxFont::GetDefaultEncoding();
-#endif
-
+ // layout non-native toolbar
+
+ bool isHorizontal = !IsVertical();
+
+ int maxWidth = 0;
+ int maxHeight = 0;
+
+ int x = m_xMargin + kwxMacToolBarLeftMargin;
+ int y = m_yMargin + kwxMacToolBarTopMargin;
+
node = m_tools.GetFirst();
while ( node )
{
node = node->GetNext();
continue;
}
-
+
// set tool position:
// for the moment just perform a single row/column alignment
wxSize cursize = tool->GetSize();
maxWidth = x + cursize.x;
if ( y + cursize.y > maxHeight )
maxHeight = y + cursize.y;
-
- if ( GetWindowStyleFlag() & wxTB_VERTICAL )
+
+ // update the item positioning state
+ if ( !isHorizontal )
+ y += cursize.y + kwxMacToolSpacing;
+ else
+ x += cursize.x + kwxMacToolSpacing;
+
+ node = node->GetNext();
+ }
+
+ if ( isHorizontal )
+ {
+ // if not set yet, only one row
+ if ( m_maxRows <= 0 )
+ SetRows( 1 );
+
+ maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
+ m_minWidth = maxWidth;
+ m_minHeight = m_maxHeight = maxToolHeight + 2 * (m_yMargin + kwxMacToolBarTopMargin);
+ }
+ else
+ {
+ // if not set yet, have one column
+ if ( (GetToolsCount() > 0) && (m_maxRows <= 0) )
+ SetRows( GetToolsCount() );
+
+ maxHeight += m_yMargin + kwxMacToolBarTopMargin;
+ m_minHeight = maxHeight;
+ m_minWidth = m_maxWidth = maxToolWidth + 2 * (m_yMargin + kwxMacToolBarTopMargin);
+ }
+
+ int totalStretchableSpace = 0;
+ int spacePerStretchable = 0;
+ if ( numStretchableSpaces > 0 )
+ {
+ if ( isHorizontal )
+ totalStretchableSpace = tw - maxWidth;
+ else
+ totalStretchableSpace = th - maxHeight;
+
+ if ( totalStretchableSpace > 0 )
+ spacePerStretchable = totalStretchableSpace / numStretchableSpaces;
+ }
+
+ // perform real positioning
+
+ x = m_xMargin + kwxMacToolBarLeftMargin;
+ y = m_yMargin + kwxMacToolBarTopMargin;
+
+ node = m_tools.GetFirst();
+ int currentStretchable = 0;
+ while ( node )
+ {
+ tool = (wxToolBarTool*) node->GetData();
+ if ( tool == NULL )
+ {
+ node = node->GetNext();
+ continue;
+ }
+
+ wxSize cursize = tool->GetSize();
+ if ( tool->IsStretchableSpace() )
+ {
+ ++currentStretchable;
+ int thisSpace = currentStretchable == numStretchableSpaces ?
+ totalStretchableSpace - (currentStretchable-1)*spacePerStretchable :
+ spacePerStretchable;
+ if ( isHorizontal )
+ cursize.x += thisSpace;
+ else
+ cursize.y += thisSpace;
+ }
+
+ if ( !isHorizontal )
{
int x1 = x + ( maxToolWidth - cursize.x ) / 2;
tool->SetPosition( wxPoint(x1, y) );
int y1 = y + ( maxToolHeight - cursize.y ) / 2;
tool->SetPosition( wxPoint(x, y1) );
}
-
+
// update the item positioning state
- if ( GetWindowStyleFlag() & wxTB_VERTICAL )
+ if ( !isHorizontal )
y += cursize.y + kwxMacToolSpacing;
else
x += cursize.x + kwxMacToolSpacing;
+
+ node = node->GetNext();
+ }
+
+}
+
+bool wxToolBar::Realize()
+{
+ if ( !wxToolBarBase::Realize() )
+ return false;
+
+ wxToolBarTool *tool;
+ wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
#if wxOSX_USE_NATIVE_TOOLBAR
+ CFIndex currentPosition = 0;
+ bool insertAll = false;
+
+ NSToolbar* refTB = (NSToolbar*)m_macToolbar;
+ wxFont f;
+ wxFontEncoding enc;
+ f = GetFont();
+ if ( f.IsOk() )
+ enc = f.GetEncoding();
+ else
+ enc = wxFont::GetDefaultEncoding();
+
+ node = m_tools.GetFirst();
+ while ( node )
+ {
+ tool = (wxToolBarTool*) node->GetData();
+ if ( tool == NULL )
+ {
+ node = node->GetNext();
+ continue;
+ }
+
// install in native NSToolbar
if ( refTB )
{
// the strings now
wxCFStringRef sh( tool->GetShortHelp(), enc);
[hiItemRef setToolTip:sh.AsNSString()];
-
+
if ( insertAll || (tool->GetIndex() != currentPosition) )
{
if ( !insertAll )
{
insertAll = true;
-
+
// if this is the first tool that gets newly inserted or repositioned
// first remove all 'old' tools from here to the right, because of this
// all following tools will have to be reinserted (insertAll).
for ( wxToolBarToolsList::compatibility_iterator node2 = m_tools.GetLast();
- node2 != node;
- node2 = node2->GetPrevious() )
+ node2 != node;
+ node2 = node2->GetPrevious() )
{
wxToolBarTool *tool2 = (wxToolBarTool*) node2->GetData();
-
+
const long idx = tool2->GetIndex();
if ( idx != -1 )
{
}
}
}
- wxString identifier = wxString::Format( wxT("%ld"), (long) tool );
- wxCFStringRef cfidentifier(identifier);
-
- [refTB insertItemWithItemIdentifier:cfidentifier.AsNSString() atIndex:currentPosition];
+
+ wxCFStringRef cfidentifier;
+ NSString *nsItemId;
+ if (tool->GetStyle() == wxTOOL_STYLE_SEPARATOR)
+ {
+ if ( tool->IsStretchable() )
+ nsItemId = NSToolbarFlexibleSpaceItemIdentifier;
+ else
+ {
+ if ( UMAGetSystemVersion() < 0x1070 )
+ nsItemId = NSToolbarSeparatorItemIdentifier;
+ else
+ nsItemId = NSToolbarSpaceItemIdentifier;
+ }
+ }
+ else
+ {
+ cfidentifier = wxCFStringRef(wxString::Format("%ld", (long)tool));
+ nsItemId = cfidentifier.AsNSString();
+ }
+
+ [refTB insertItemWithItemIdentifier:nsItemId atIndex:currentPosition];
tool->SetIndex( currentPosition );
}
-
+
currentPosition++;
}
}
+ node = node->GetNext();
+ }
+
#endif
-
+
+ DoLayout();
+
+ // adjust radio items
+
+ bool lastIsRadio = false;
+ bool curIsRadio = false;
+
+ node = m_tools.GetFirst();
+ while ( node )
+ {
+ tool = (wxToolBarTool*) node->GetData();
+ if ( tool == NULL )
+ {
+ node = node->GetNext();
+ continue;
+ }
+
// update radio button (and group) state
lastIsRadio = curIsRadio;
curIsRadio = ( tool->IsButton() && (tool->GetKind() == wxITEM_RADIO) );
node = node->GetNext();
}
- if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
- {
- // if not set yet, only one row
- if ( m_maxRows <= 0 )
- SetRows( 1 );
-
- m_minWidth = maxWidth;
- maxWidth = tw;
- maxHeight += m_yMargin + kwxMacToolBarTopMargin;
- m_minHeight = m_maxHeight = maxHeight;
- }
- else
- {
- // if not set yet, have one column
- if ( (GetToolsCount() > 0) && (m_maxRows <= 0) )
- SetRows( GetToolsCount() );
-
- m_minHeight = maxHeight;
- maxHeight = th;
- maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
- m_minWidth = m_maxWidth = maxWidth;
- }
-
-#if 0
- // FIXME: should this be OSX-only?
- {
- bool wantNativeToolbar, ownToolbarInstalled;
-
- // attempt to install the native toolbar
- wantNativeToolbar = ((GetWindowStyleFlag() & wxTB_VERTICAL) == 0);
- MacInstallNativeToolbar( wantNativeToolbar );
- (void)MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
- if (!ownToolbarInstalled)
- {
- SetSize( maxWidth, maxHeight );
- InvalidateBestSize();
- }
- }
-#else
- SetSize( maxWidth, maxHeight );
InvalidateBestSize();
-#endif
-
- SetInitialSize();
+ SetInitialSize( wxSize(m_minWidth, m_minHeight));
+ SendSizeEventToParent();
+
return true;
}
+void wxToolBar::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+{
+ wxToolBarBase::DoSetSize(x, y, width, height, sizeFlags);
+
+ DoLayout();
+}
+
void wxToolBar::SetToolBitmapSize(const wxSize& size)
{
m_defaultWidth = size.x + kwxMacToolBorder;
{
wxWindow::MacSuperChangedPosition();
+ /*
#if wxOSX_USE_NATIVE_TOOLBAR
if (! m_macUsesNativeToolbar )
Realize();
Realize();
#endif
+ */
}
void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap )
return wxEmptyString;
}
-void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
+void wxToolBar::DoEnableTool(wxToolBarToolBase * WXUNUSED(t), bool WXUNUSED(enable))
{
- if ( t != NULL )
- ((wxToolBarTool*)t)->DoEnable( enable );
+ // everything already done in the tool's Enable implementation
}
void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
if (tool == NULL)
return false;
+ long style = GetWindowStyleFlag();
+
wxSize toolSize = GetToolSize();
WXWidget controlHandle = NULL;
NSRect toolrect = NSMakeRect(0, 0, toolSize.x, toolSize.y );
wxASSERT( tool->GetControlHandle() == NULL );
toolSize.x /= 4;
toolSize.y /= 4;
- if ( GetWindowStyleFlag() & wxTB_VERTICAL )
+ if ( IsVertical() )
toolrect.size.height = toolSize.y;
else
toolrect.size.width = toolSize.x;
#if wxOSX_USE_NATIVE_TOOLBAR
if (m_macToolbar != NULL)
{
- NSToolbarItem* item = [[NSToolbarItem alloc] initWithItemIdentifier:NSToolbarSeparatorItemIdentifier];
+ NSString * nsItemId = nil;
+
+ if ( tool->IsStretchable() )
+ nsItemId = NSToolbarFlexibleSpaceItemIdentifier;
+ else
+ {
+ if ( UMAGetSystemVersion() < 0x1070 )
+ nsItemId = NSToolbarSeparatorItemIdentifier;
+ else
+ nsItemId = NSToolbarSpaceItemIdentifier;
+ }
+
+ NSToolbarItem* item = [[NSToolbarItem alloc] initWithItemIdentifier:nsItemId];
tool->SetToolbarItemRef( item );
}
#endif // wxOSX_USE_NATIVE_TOOLBAR
wxNSToolBarButton* v = [[wxNSToolBarButton alloc] initWithFrame:toolrect];
- [v setBezelStyle:NSRegularSquareBezelStyle];
+ [v setBezelStyle:NSSmallSquareBezelStyle];
+ [[v cell] setControlSize:NSSmallControlSize];
+ [v setFont:[NSFont fontWithName:[[v font] fontName] size:[NSFont systemFontSizeForControlSize:NSSmallControlSize]]];
[v setBordered:NO];
- [v setButtonType: ( tool->CanBeToggled() ? NSOnOffButton : NSMomentaryPushInButton )];
+ [v setButtonType: ( tool->CanBeToggled() ? NSToggleButton : NSMomentaryPushInButton )];
[v setImplementation:tool];
controlHandle = v;
-
+
#if wxOSX_USE_NATIVE_TOOLBAR
if (m_macToolbar != NULL)
{
#endif // wxOSX_USE_NATIVE_TOOLBAR
tool->SetControlHandle( controlHandle );
- tool->UpdateImages();
+ if ( !(style & wxTB_NOICONS) )
+ tool->UpdateImages();
tool->UpdateLabel();
-#if 0
- SetBevelButtonTextPlacement( m_controlHandle, kControlBevelButtonPlaceBelowGraphic );
- SetControlTitleWithCFString( m_controlHandle , wxCFStringRef( label, wxFont::GetDefaultEncoding() );
-#endif
+
+ if ( style & wxTB_NOICONS )
+ [v setImagePosition:NSNoImage];
+ else if ( style & wxTB_TEXT )
+ [v setImagePosition:NSImageAbove];
+ else
+ [v setImagePosition:NSImageOnly];
+ [v sizeToFit];
+
#if 0
InstallControlEventHandler(
(WXWidget) controlHandle, GetwxMacToolBarToolEventHandlerUPP(),
if (m_macToolbar != NULL)
{
WXWidget view = (WXWidget) tool->GetControl()->GetHandle() ;
- wxCHECK_MSG( view, false, _T("control must be non-NULL") );
+ wxCHECK_MSG( view, false, wxT("control must be non-NULL") );
wxString identifier = wxString::Format(wxT("%ld"), (long) tool);
wxCFStringRef cfidentifier( identifier, wxFont::GetDefaultEncoding() );
wxToolBarTool *tool2 = (wxToolBarTool*) node->GetData();
wxPoint pt = tool2->GetPosition();
- if ( GetWindowStyleFlag() & wxTB_VERTICAL )
+ if ( IsVertical() )
pt.y -= sz.y;
else
pt.x -= sz.x;
#if wxOSX_USE_NATIVE_TOOLBAR
if ( m_macUsesNativeToolbar )
{
- event.Skip(true);
- return;
+ // nothing to do here
}
+ else
#endif
+ {
+ int w, h;
+ GetSize( &w, &h );
- wxPaintDC dc(this);
-
- int w, h;
- GetSize( &w, &h );
+ wxPaintDC dc(this);
+
+ wxRect rect(0,0,w,h);
+
+ dc.GradientFillLinear( rect , wxColour( 0xCC,0xCC,0xCC ), wxColour( 0xA8,0xA8,0xA8 ) , wxSOUTH );
+ dc.SetPen( wxPen( wxColour( 0x51,0x51,0x51 ) ) );
+ if ( HasFlag(wxTB_LEFT) )
+ dc.DrawLine(w-1, 0, w-1, h);
+ else if ( HasFlag(wxTB_RIGHT) )
+ dc.DrawLine(0, 0, 0, h);
+ else if ( HasFlag(wxTB_BOTTOM) )
+ dc.DrawLine(0, 0, w, 0);
+ else if ( HasFlag(wxTB_TOP) )
+ dc.DrawLine(0, h-1, w, h-1);
+ }
+ event.Skip();
+}
- bool drawMetalTheme = MacGetTopLevelWindow()->GetExtraStyle() & wxFRAME_EX_METAL;
+#if wxOSX_USE_NATIVE_TOOLBAR
+void wxToolBar::OSXSetSelectableTools(bool set)
+{
+ wxCHECK_RET( m_macToolbar, "toolbar must be non-NULL" );
+ [(wxNSToolbarDelegate*)[(NSToolbar*)m_macToolbar delegate] setSelectable:set];
+}
- if ( !drawMetalTheme )
- {
- HIThemePlacardDrawInfo info;
- memset( &info, 0, sizeof(info) );
- info.version = 0;
- info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive;
-
- CGContextRef cgContext = (CGContextRef) MacGetCGContextRef();
- HIRect rect = CGRectMake( 0, 0, w, h );
- HIThemeDrawPlacard( &rect, &info, cgContext, kHIThemeOrientationNormal );
- }
- else
- {
- // leave the background as it is (striped or metal)
- }
+void wxToolBar::OSXSelectTool(int toolId)
+{
+ wxToolBarToolBase *tool = FindById(toolId);
+ wxCHECK_RET( tool, "invalid tool ID" );
+ wxCHECK_RET( m_macToolbar, "toolbar must be non-NULL" );
- event.Skip();
+ wxString identifier = wxString::Format(wxT("%ld"), (long)tool);
+ wxCFStringRef cfidentifier(identifier, wxFont::GetDefaultEncoding());
+ [(NSToolbar*)m_macToolbar setSelectedItemIdentifier:cfidentifier.AsNSString()];
}
+#endif // wxOSX_USE_NATIVE_TOOLBAR
#endif // wxUSE_TOOLBAR
projects / wxWidgets.git / blobdiff