--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/NSButton.h
+// Purpose: wxCocoaNSButton class
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/09
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_NSBUTTON_H__
+#define __WX_COCOA_NSBUTTON_H__
+
+#include "wx/hashmap.h"
+#include "wx/cocoa/ObjcPose.h"
+
+WX_DECLARE_OBJC_HASHMAP(NSButton);
+
+class wxCocoaNSButton
+{
+ WX_DECLARE_OBJC_INTERFACE_HASHMAP(NSButton);
+public:
+ void AssociateNSButton(WX_NSButton cocoaNSButton);
+ inline void DisassociateNSButton(WX_NSButton cocoaNSButton)
+ {
+ sm_cocoaHash.erase(cocoaNSButton);
+ }
+
+public:
+ virtual void Cocoa_wxNSButtonAction(void) = 0;
+};
+
+#endif // _WX_COCOA_NSBUTTON_H_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/NSControl.h
+// Purpose: wxCocoaNSControl class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/02/15
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_NSCONTROL_H__
+#define __WX_COCOA_NSCONTROL_H__
+
+#include "wx/hashmap.h"
+#include "wx/cocoa/ObjcPose.h"
+
+WX_DECLARE_OBJC_HASHMAP(NSControl);
+class wxCocoaNSControl
+{
+ WX_DECLARE_OBJC_INTERFACE(NSControl)
+protected:
+// virtual void Cocoa_didChangeText(void) = 0;
+};
+
+#endif // _WX_COCOA_NSCONTROL_H_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/NSMenu.h
+// Purpose: wxCocoaNSMenu class
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/09
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_NSMENU_H__
+#define __WX_COCOA_NSMENU_H__
+
+#include "wx/hashmap.h"
+#include "wx/cocoa/ObjcPose.h"
+
+WX_DECLARE_OBJC_HASHMAP(NSMenu);
+
+// ========================================================================
+// wxCocoaNSMenu
+// ========================================================================
+
+class wxCocoaNSMenu
+{
+ WX_DECLARE_OBJC_INTERFACE(NSMenu)
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ inline wxCocoaNSMenu()
+ {
+ m_cocoaNSMenu = NULL;
+ }
+ ~wxCocoaNSMenu();
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+public:
+ bool CocoaCreate(const wxString &title);
+ inline WX_NSMenu GetNSMenu() { return m_cocoaNSMenu; }
+protected:
+ WX_NSMenu m_cocoaNSMenu;
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+protected:
+};
+
+#endif // _WX_COCOA_NSMENU_H_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/NSTextField.h
+// Purpose: wxCocoaNSTextField class
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/09
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_NSTEXTFIELD_H__
+#define __WX_COCOA_NSTEXTFIELD_H__
+
+#include "wx/hashmap.h"
+#include "wx/cocoa/ObjcPose.h"
+
+WX_DECLARE_OBJC_HASHMAP(NSTextField);
+class wxCocoaNSTextField
+{
+ WX_DECLARE_OBJC_INTERFACE(NSTextField)
+protected:
+ virtual void Cocoa_didChangeText(void) = 0;
+};
+
+#endif // _WX_COCOA_NSTEXTFIELD_H_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/NSView.h
+// Purpose: wxCocoaNSView class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/02/15
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_NSVIEW_H__
+#define __WX_COCOA_NSVIEW_H__
+
+#include "wx/hashmap.h"
+#include "wx/cocoa/ObjcPose.h"
+
+WX_DECLARE_OBJC_HASHMAP(NSView);
+class wxCocoaNSView
+{
+/* NSView is a rather special case and requires some extra attention */
+ WX_DECLARE_OBJC_INTERFACE_HASHMAP(NSView)
+public:
+ void AssociateNSView(WX_NSView cocoaNSView);
+ void DisassociateNSView(WX_NSView cocoaNSView);
+protected:
+ static void *sm_cocoaObserver;
+public:
+ virtual void Cocoa_FrameChanged(void) = 0;
+};
+
+#endif // _WX_COCOA_NSVIEW_H_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/NSWindow.h
+// Purpose: wxCocoaNSWindow class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_NSWINDOW_H__
+#define __WX_COCOA_NSWINDOW_H__
+
+#include "wx/hashmap.h"
+#include "wx/cocoa/ObjcPose.h"
+
+WX_DECLARE_OBJC_HASHMAP(NSWindow);
+
+class wxCocoaNSWindow
+{
+/* NSWindow is a rather special case and requires some extra attention */
+ WX_DECLARE_OBJC_INTERFACE_HASHMAP(NSWindow)
+public:
+ void AssociateNSWindow(WX_NSWindow cocoaNSWindow);
+ inline void DisassociateNSWindow(WX_NSWindow cocoaNSWindow)
+ {
+ sm_cocoaHash.erase(cocoaNSWindow);
+ }
+ virtual void Cocoa_close(void) = 0;
+ virtual bool Cocoa_windowShouldClose(void) = 0;
+ virtual void Cocoa_wxMenuItemAction(wxMenuItem& item) = 0;
+};
+
+#endif // _WX_COCOA_NSWINDOW_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/ObjcPose.h
+// Purpose: Macros for initializing poseAs, among other things
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/03
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott <dfe@cox.net>
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_PRIVATE_POSER_H__
+#define __WX_COCOA_PRIVATE_POSER_H__
+
+/*-------------------------------------------------------------------------
+Objective-C Poser class initialization
+-------------------------------------------------------------------------*/
+#ifdef __OBJC__
+#import <objc/objc-class.h>
+
+class wxPoseAsInitializer
+{
+public:
+ wxPoseAsInitializer(Class poser)
+ : m_poser(poser)
+ , m_next(sm_first)
+ {
+ sm_first = this;
+ }
+ ~wxPoseAsInitializer()
+ {
+ class_poseAs(m_poser,m_poser->super_class);
+ sm_first = m_next;
+ }
+ static void InitializePosers()
+ {
+ while(sm_first)
+ {
+ delete sm_first;
+ }
+ };
+protected:
+ Class m_poser;
+ wxPoseAsInitializer *m_next;
+ static wxPoseAsInitializer *sm_first;
+};
+
+class wxDummyForPoseAsInitializer
+{
+public:
+ wxDummyForPoseAsInitializer(void*) {}
+};
+
+#define WX_IMPLEMENT_POSER(poser) \
+wxDummyForPoseAsInitializer wxDummyPoseAsInitializerFor##poser(new wxPoseAsInitializer([poser class]))
+
+#endif // __OBJC__
+
+/*-------------------------------------------------------------------------
+Basic hashmap stuff, used by everything
+-------------------------------------------------------------------------*/
+#define WX_DECLARE_OBJC_HASHMAP(ObjcClass) \
+class wxCocoa##ObjcClass; \
+WX_DECLARE_HASH_MAP(WX_##ObjcClass,wxCocoa##ObjcClass*,wxPointerHash,wxPointerEqual,wxCocoa##ObjcClass##Hash)
+
+#define WX_DECLARE_OBJC_INTERFACE_HASHMAP(ObjcClass) \
+public: \
+ static inline wxCocoa##ObjcClass* GetFromCocoa(WX_##ObjcClass cocoaObjcClass) \
+ { \
+ wxCocoa##ObjcClass##Hash::iterator iter = sm_cocoaHash.find(cocoaObjcClass); \
+ if(iter!=sm_cocoaHash.end()) \
+ { \
+ return iter->second; \
+ } \
+ return NULL; \
+ } \
+protected: \
+ static wxCocoa##ObjcClass##Hash sm_cocoaHash;
+
+#define WX_IMPLEMENT_OBJC_INTERFACE_HASHMAP(ObjcClass) \
+wxCocoa##ObjcClass##Hash wxCocoa##ObjcClass::sm_cocoaHash;
+
+
+/*-------------------------------------------------------------------------
+The entire interface, including some boilerplate stuff
+-------------------------------------------------------------------------*/
+#define WX_DECLARE_OBJC_INTERFACE(ObjcClass) \
+WX_DECLARE_OBJC_INTERFACE_HASHMAP(ObjcClass) \
+public: \
+ inline void Associate##ObjcClass(WX_##ObjcClass cocoaObjcClass) \
+ { \
+ sm_cocoaHash.insert(wxCocoa##ObjcClass##Hash::value_type(cocoaObjcClass,this)); \
+ } \
+ inline void Disassociate##ObjcClass(WX_##ObjcClass cocoaObjcClass) \
+ { \
+ sm_cocoaHash.erase(cocoaObjcClass); \
+ }
+
+#define WX_IMPLEMENT_OBJC_INTERFACE(ObjcClass) \
+WX_IMPLEMENT_OBJC_INTERFACE_HASHMAP(ObjcClass)
+
+/*-------------------------------------------------------------------------
+Stuff to be used by the wxWindows class (not the Cocoa interface)
+-------------------------------------------------------------------------*/
+#define WX_DECLARE_COCOA_OWNER(ObjcClass,ObjcBase,ObjcRoot) \
+public: \
+ inline WX_##ObjcClass Get##ObjcClass() { return (WX_##ObjcClass)m_cocoa##ObjcRoot; } \
+ inline const WX_##ObjcClass Get##ObjcClass() const { return (WX_##ObjcClass)m_cocoa##ObjcRoot; } \
+protected: \
+ void Set##ObjcClass(WX_##ObjcClass cocoaObjcClass);
+
+#define WX_IMPLEMENT_COCOA_OWNER(wxClass,ObjcClass,ObjcBase,ObjcRoot) \
+void wxClass::Set##ObjcClass(WX_##ObjcClass cocoaObjcClass) \
+{ \
+ if(m_cocoa##ObjcRoot) \
+ Disassociate##ObjcClass((WX_##ObjcClass)m_cocoa##ObjcRoot); \
+ Set##ObjcBase(cocoaObjcClass); \
+ if(m_cocoa##ObjcRoot) \
+ Associate##ObjcClass((WX_##ObjcClass)m_cocoa##ObjcRoot); \
+}
+
+#endif // __WX_COCOA_PRIVATE_POSER_H__
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/app.h
+// Purpose: wxApp class
+// Author: David Elliott
+// Modified by:
+// Created: 2002/11/27
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COCOA_APP_H_
+#define _WX_COCOA_APP_H_
+
+// entrypoint
+int WXDLLEXPORT wxEntry( int argc, char *argv[] );
+
+// Represents the application. Derive OnInit and declare
+// a new App object to start application
+class WXDLLEXPORT wxApp: public wxAppBase
+{
+ DECLARE_DYNAMIC_CLASS(wxApp)
+ DECLARE_EVENT_TABLE()
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxApp();
+ virtual ~wxApp() {}
+
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+public:
+ inline WX_NSApplication GetNSApplication() { return m_cocoaApp; }
+ void CocoaInstallRequestedIdleHandler() { if(m_isIdle) CocoaInstallIdleHandler(); }
+ inline void CocoaRequestIdle() { m_isIdle = true; }
+protected:
+ WX_NSApplication m_cocoaApp;
+ void CocoaInstallIdleHandler();
+ bool m_isIdle;
+
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ // Implement wxAppBase pure virtuals
+ virtual int MainLoop();
+ virtual void ExitMainLoop();
+ virtual bool Initialized();
+ virtual bool Pending();
+ virtual void Dispatch();
+ virtual bool Yield(bool onlyIfNeeded = FALSE);
+ virtual bool ProcessIdle();
+
+ /* Idle Processing */
+ void OnIdle(wxIdleEvent& event);
+ // Send idle event to all top-level windows.
+ // Returns TRUE if more idle time is requested.
+ bool SendIdleEvents();
+ // Send idle event to window and all subwindows
+ // Returns TRUE if more idle time is requested.
+ bool SendIdleEvents(wxWindowCocoa* win);
+
+ static bool Initialize();
+ static void CleanUp();
+
+ virtual bool OnInit();
+ virtual bool OnInitGui();
+ void DeletePendingObjects();
+};
+
+#endif // _WX_COCOA_APP_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/button.h
+// Purpose: wxButton class
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/29
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_BUTTON_H__
+#define __WX_COCOA_BUTTON_H__
+
+#include "wx/cocoa/NSButton.h"
+
+// ========================================================================
+// wxButton
+// ========================================================================
+class WXDLLEXPORT wxButton : public wxButtonBase, protected wxCocoaNSButton
+{
+ DECLARE_DYNAMIC_CLASS(wxButton)
+ DECLARE_EVENT_TABLE()
+ WX_DECLARE_COCOA_OWNER(NSButton,NSControl,NSView)
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxButton() { }
+ wxButton(wxWindow *parent, wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxButtonNameStr)
+ {
+ Create(parent, winid, label, pos, size, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxButtonNameStr);
+ virtual ~wxButton();
+
+// ------------------------------------------------------------------------
+// Cocoa callbacks
+// ------------------------------------------------------------------------
+protected:
+ virtual void Cocoa_wxNSButtonAction(void);
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+};
+
+#endif // __WX_COCOA_BUTTON_H__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/checklst.h
+// Purpose: wxCheckListBox class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_CHECKLST_H__
+#define __WX_COCOA_CHECKLST_H__
+
+//#include "wx/cocoa/NSTableView.h"
+
+// ========================================================================
+// wxCheckListBox
+// ========================================================================
+class WXDLLEXPORT wxCheckListBox: public wxCheckListBoxBase //, protected wxCocoaNSTableView
+{
+ DECLARE_DYNAMIC_CLASS(wxCheckListBox)
+ DECLARE_EVENT_TABLE()
+ WX_DECLARE_COCOA_OWNER(NSTableView,NSControl,NSView)
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxCheckListBox() { }
+ wxCheckListBox(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxListBoxNameStr)
+ {
+ Create(parent, winid, pos, size, n, choices, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxListBoxNameStr);
+ virtual ~wxCheckListBox();
+
+// ------------------------------------------------------------------------
+// Cocoa callbacks
+// ------------------------------------------------------------------------
+protected:
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ // check list box specific methods
+ virtual bool IsChecked(size_t item) const;
+ virtual void Check(size_t item, bool check = TRUE);
+};
+
+#endif // __WX_COCOA_CHECKLST_H__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/control.h
+// Purpose: wxControl class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/02/15
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_CONTROL_H__
+#define __WX_COCOA_CONTROL_H__
+
+#include "wx/cocoa/NSControl.h"
+
+// ========================================================================
+// wxControl
+// ========================================================================
+
+class WXDLLEXPORT wxControl : public wxControlBase, public wxCocoaNSControl
+{
+ DECLARE_ABSTRACT_CLASS(wxControl)
+ WX_DECLARE_COCOA_OWNER(NSControl,NSView,NSView)
+ DECLARE_EVENT_TABLE()
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxControl() {}
+ wxControl(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxControlNameStr)
+ {
+ Create(parent, winid, pos, size, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxControlNameStr);
+ virtual ~wxControl();
+
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+
+ // implementation from now on
+ // --------------------------
+
+ void OnEraseBackground(wxEraseEvent& event);
+
+ virtual void Command(wxCommandEvent& event) { ProcessCommand(event); }
+
+ // Calls the callback and appropriate event handlers
+ bool ProcessCommand(wxCommandEvent& event);
+
+#if WXWIN_COMPATIBILITY
+ virtual void SetButtonColour(const wxColour& WXUNUSED(col)) { }
+ wxColour* GetButtonColour() const { return NULL; }
+
+ inline virtual void SetLabelFont(const wxFont& font);
+ inline virtual void SetButtonFont(const wxFont& font);
+ inline wxFont& GetLabelFont() const;
+ inline wxFont& GetButtonFont() const;
+
+ // Adds callback
+ inline void Callback(const wxFunction function);
+
+ wxFunction GetCallback() { return m_callback; }
+
+protected:
+ wxFunction m_callback; // Callback associated with the window
+#endif // WXWIN_COMPATIBILITY
+
+protected:
+ virtual wxSize DoGetBestSize() const;
+};
+
+
+#if WXWIN_COMPATIBILITY
+ inline void wxControl::Callback(const wxFunction f) { m_callback = f; };
+ inline wxFont& wxControl::GetLabelFont() const { return GetFont(); }
+ inline wxFont& wxControl::GetButtonFont() const { return GetFont(); }
+ inline void wxControl::SetLabelFont(const wxFont& font) { SetFont(font); }
+ inline void wxControl::SetButtonFont(const wxFont& font) { SetFont(font); }
+#endif // WXWIN_COMPATIBILITY
+
+#endif // __WX_COCOA_CONTROL_H__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/dcmemory.h
+// Purpose: wxMemoryDC class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_DCMEMORY_H__
+#define __WX_COCOA_DCMEMORY_H__
+
+#include "wx/dcclient.h"
+
+class WXDLLEXPORT wxMemoryDC: public wxDC
+{
+ DECLARE_DYNAMIC_CLASS(wxMemoryDC)
+public:
+ wxMemoryDC(void);
+ wxMemoryDC( wxDC *dc ); // Create compatible DC
+ ~wxMemoryDC(void);
+ virtual void SelectObject(const wxBitmap& bitmap);
+ virtual void DoGetSize(int *width, int *height) const;
+};
+
+#endif // __WX_COCOA_DCMEMORY_H__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/dcscreen.h
+// Purpose: wxScreenDC class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_DCSCREEN_H__
+#define __WX_COCOA_DCSCREEN_H__
+
+#include "wx/dcclient.h"
+
+class WXDLLEXPORT wxScreenDC: public wxDC
+{
+ DECLARE_DYNAMIC_CLASS(wxScreenDC)
+public:
+ wxScreenDC(void);
+ wxScreenDC( wxDC *dc ); // Create compatible DC
+ ~wxScreenDC(void);
+};
+
+#endif // __WX_COCOA_DCSCREEN_H__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/dialog.h
+// Purpose: wxDialog class
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/15
+// RCS-ID: $Id:
+// Copyright: David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COCOA_DIALOG_H_
+#define _WX_COCOA_DIALOG_H_
+
+#include "wx/defs.h"
+// NOTE: we don't need panel.h, but other things expect it to be included
+#include "wx/panel.h"
+#include "wx/cocoa/NSPanel.h"
+
+WXDLLEXPORT_DATA(extern const wxChar*) wxDialogNameStr;
+
+// ========================================================================
+// wxDialog
+// ========================================================================
+class WXDLLEXPORT wxDialog : public wxDialogBase, protected wxCocoaNSPanel
+{
+ DECLARE_DYNAMIC_CLASS(wxDialog)
+ DECLARE_EVENT_TABLE()
+ WX_DECLARE_COCOA_OWNER(NSPanel,NSWindow,NSWindow)
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxDialog() { Init(); }
+
+ // Constructor with a modal flag, but no window id - the old convention
+ wxDialog(wxWindow *parent,
+ const wxString& title, bool modal,
+ int x = -1, int y= -1, int width = 500, int height = 500,
+ long style = wxDEFAULT_DIALOG_STYLE,
+ const wxString& name = wxDialogNameStr)
+ {
+ Init();
+ long modalStyle = modal ? wxDIALOG_MODAL : wxDIALOG_MODELESS ;
+ Create(parent, -1, title, wxPoint(x, y), wxSize(width, height),
+ style | modalStyle, name);
+ }
+
+ // Constructor with no modal flag - the new convention.
+ wxDialog(wxWindow *parent, wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_DIALOG_STYLE,
+ const wxString& name = wxDialogNameStr)
+ {
+ Init();
+ Create(parent, winid, title, pos, size, style, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_DIALOG_STYLE,
+ const wxString& name = wxDialogNameStr);
+
+ ~wxDialog();
+protected:
+ void Init();
+
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+protected:
+ virtual void Cocoa_close(void);
+
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ bool Show(bool show);
+
+ void SetModal(bool flag);
+ virtual bool IsModal() const;
+
+ // For now, same as Show(TRUE) but returns return code
+ virtual int ShowModal();
+
+ // may be called to terminate the dialog with the given return code
+ virtual void EndModal(int retCode);
+
+// ------------------------------------------------------------------------
+// Event handlers
+// ------------------------------------------------------------------------
+protected:
+ void OnCloseWindow(wxCloseEvent& event);
+ // Standard buttons
+ void OnOK(wxCommandEvent& event);
+ void OnApply(wxCommandEvent& event);
+ void OnCancel(wxCommandEvent& event);
+};
+
+#endif // _WX_COCOA_DIALOG_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/frame.h
+// Purpose: wxFrame class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COCOA_FRAME_H_
+#define _WX_COCOA_FRAME_H_
+
+class WXDLLEXPORT wxMenuBar;
+class WXDLLEXPORT wxMenuItem;
+
+class WXDLLEXPORT wxFrame: public wxFrameBase
+{
+ DECLARE_EVENT_TABLE()
+ DECLARE_DYNAMIC_CLASS(wxFrame)
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxFrame() { Init(); }
+ wxFrame(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE,
+ const wxString& name = wxFrameNameStr)
+ {
+ Init();
+ Create(parent, winid, title, pos, size, style, name);
+ }
+
+ virtual ~wxFrame();
+
+ bool Create(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE,
+ const wxString& name = wxFrameNameStr);
+protected:
+ void Init();
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+protected:
+ virtual void Cocoa_wxMenuItemAction(wxMenuItem& item);
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ void AttachMenuBar(wxMenuBar *mbar);
+ void DetachMenuBar();
+
+ // implementation only from now on
+ // -------------------------------
+
+ // override some more virtuals
+ virtual bool Show( bool show = true );
+
+ // get the origin of the client area (which may be different from (0, 0)
+ // if the frame has a toolbar) in client coordinates
+ virtual wxPoint GetClientAreaOrigin() const;
+};
+
+#endif // _WX_COCOA_FRAME_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/listbox.h
+// Purpose: wxListBox class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_LISTBOX_H__
+#define __WX_COCOA_LISTBOX_H__
+
+//#include "wx/cocoa/NSTableView.h"
+
+// ========================================================================
+// wxListBox
+// ========================================================================
+class WXDLLEXPORT wxListBox: public wxListBoxBase //, protected wxCocoaNSTableView
+{
+ DECLARE_DYNAMIC_CLASS(wxListBox)
+ DECLARE_EVENT_TABLE()
+ WX_DECLARE_COCOA_OWNER(NSTableView,NSControl,NSView)
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxListBox() { }
+ wxListBox(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxListBoxNameStr)
+ {
+ Create(parent, winid, pos, size, n, choices, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxListBoxNameStr);
+ virtual ~wxListBox();
+
+// ------------------------------------------------------------------------
+// Cocoa callbacks
+// ------------------------------------------------------------------------
+protected:
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+// pure virtuals from wxListBoxBase
+ virtual bool IsSelected(int n) const;
+ virtual void SetSelection(int n, bool select = TRUE);
+ virtual int GetSelections(wxArrayInt& aSelections) const;
+protected:
+ virtual void DoInsertItems(const wxArrayString& items, int pos);
+ virtual void DoSetItems(const wxArrayString& items, void **clientData);
+ virtual void DoSetFirstItem(int n);
+
+// pure virtuals from wxItemContainer
+public:
+ // deleting items
+ virtual void Clear();
+ virtual void Delete(int n);
+ // accessing strings
+ virtual int GetCount() const;
+ virtual wxString GetString(int n) const;
+ virtual void SetString(int n, const wxString& s);
+ virtual int FindString(const wxString& s) const;
+ // selection
+ virtual void Select(int n);
+ virtual int GetSelection() const;
+protected:
+ virtual int DoAppend(const wxString& item);
+ virtual void DoSetItemClientData(int n, void* clientData);
+ virtual void* DoGetItemClientData(int n) const;
+ virtual void DoSetItemClientObject(int n, wxClientData* clientData);
+ virtual wxClientData* DoGetItemClientObject(int n) const;
+};
+
+#endif // __WX_COCOA_LISTBOX_H__
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/menu.h
+// Purpose: wxMenu and wxMenuBar classes
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/09
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_MENU_H__
+#define __WX_COCOA_MENU_H__
+
+#include "wx/cocoa/NSMenu.h"
+
+#if wxUSE_ACCEL
+ #include "wx/accel.h"
+#endif // wxUSE_ACCEL
+
+// ========================================================================
+// wxMenu
+// ========================================================================
+
+class WXDLLEXPORT wxMenu : public wxMenuBase, public wxCocoaNSMenu
+{
+public:
+ // ctors and dtor
+ wxMenu(const wxString& title, long style = 0)
+ : wxMenuBase(title, style) { Create(title,style); }
+ bool Create(const wxString& title, long style = 0);
+
+ wxMenu(long style = 0) : wxMenuBase(style) { Create(wxEmptyString, style); }
+
+ virtual ~wxMenu();
+
+protected:
+ // implement base class virtuals
+ virtual bool DoAppend(wxMenuItem *item);
+ virtual bool DoInsert(size_t pos, wxMenuItem *item);
+ virtual wxMenuItem *DoRemove(wxMenuItem *item);
+
+#if wxUSE_ACCEL
+ // add/remove accel for the given menu item
+ void AddAccelFor(wxMenuItem *item);
+ void RemoveAccelFor(wxMenuItem *item);
+#endif // wxUSE_ACCEL
+
+private:
+#if wxUSE_ACCEL
+ // the accel table for this menu
+ wxAcceleratorTable m_accelTable;
+#endif // wxUSE_ACCEL
+
+ DECLARE_DYNAMIC_CLASS(wxMenu)
+};
+
+// ========================================================================
+// wxMenuBar
+// ========================================================================
+class WXDLLEXPORT wxMenuBar : public wxMenuBarBase, public wxCocoaNSMenu
+{
+public:
+ // ctors and dtor
+ wxMenuBar(long style = 0) { Create(style); }
+ bool Create(long style = 0);
+ virtual ~wxMenuBar();
+
+ wxMenuItemList m_items; // the list of menu items
+
+ // implement base class virtuals
+ virtual bool Append(wxMenu *menu, const wxString &title);
+ virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title);
+ virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title);
+ virtual wxMenu *Remove(size_t pos);
+
+ virtual void EnableTop(size_t pos, bool enable);
+ virtual bool IsEnabledTop(size_t pos) const;
+
+ virtual void SetLabelTop(size_t pos, const wxString& label);
+ virtual wxString GetLabelTop(size_t pos) const;
+
+ virtual void Attach(wxFrame *frame);
+ virtual void Detach();
+
+ // get the next item for the givan accel letter (used by wxFrame), return
+ // -1 if none
+ //
+ // if unique is not NULL, filled with TRUE if there is only one item with
+ // this accel, FALSE if two or more
+ int FindNextItemForAccel(int idxStart,
+ int keycode,
+ bool *unique = NULL) const;
+
+ // called by wxFrame to set focus to or open the given menu
+ void SelectMenu(size_t pos);
+
+#if wxUSE_ACCEL
+ // find the item for the given accel and generate an event if found
+ bool ProcessAccelEvent(const wxKeyEvent& event);
+#endif // wxUSE_ACCEL
+
+protected:
+ // event handlers
+ void OnLeftDown(wxMouseEvent& event);
+ void OnMouseMove(wxMouseEvent& event);
+ void OnKeyDown(wxKeyEvent& event);
+ void OnKillFocus(wxFocusEvent& event);
+
+ // process the mouse move event, return TRUE if we did, FALSE to continue
+ // processing as usual
+ //
+ // the coordinates are client coordinates of menubar, convert if necessary
+ bool ProcessMouseEvent(const wxPoint& pt);
+
+ // menubar geometry
+ virtual wxSize DoGetBestClientSize() const;
+
+ // has the menubar been created already?
+ bool IsCreated() const { return m_frameLast != NULL; }
+
+ // get the (total) width of the specified menu
+ wxCoord GetItemWidth(size_t pos) const;
+
+ // get the rect of the item
+ wxRect GetItemRect(size_t pos) const;
+
+ // get the menu from the given point or -1 if none
+ int GetMenuFromPoint(const wxPoint& pos) const;
+
+ // refresh the given item
+ void RefreshItem(size_t pos);
+
+ // refresh all items after this one (including it)
+ void RefreshAllItemsAfter(size_t pos);
+
+ // do we show a menu currently?
+ bool IsShowingMenu() const { return m_menuShown != 0; }
+
+ // we don't want to have focus except while selecting from menu
+ void GiveAwayFocus();
+
+ // the current item (only used when menubar has focus)
+ int m_current;
+
+private:
+ // the last frame to which we were attached, NULL initially
+ wxFrame *m_frameLast;
+
+ // the currently shown menu or NULL
+ wxMenu *m_menuShown;
+
+ // should be showing the menu? this is subtly different from m_menuShown !=
+ // NULL as the menu which should be shown may be disabled in which case we
+ // don't show it - but will do as soon as the focus shifts to another menu
+ bool m_shouldShowMenu;
+
+ DECLARE_DYNAMIC_CLASS(wxMenuBar)
+};
+
+#endif // _WX_COCOA_MENU_H_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/menuitem.h
+// Purpose: wxMenuItem class
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/13
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COCOA_MENUITEM_H_
+#define _WX_COCOA_MENUITEM_H_
+
+#include "wx/hashmap.h"
+#include "wx/bitmap.h"
+
+// ========================================================================
+// wxMenuItem
+// ========================================================================
+
+#define wxMenuItemCocoa wxMenuItem
+class wxMenuItemCocoa;
+WX_DECLARE_HASH_MAP(WX_NSMenuItem,wxMenuItem*,wxPointerHash,wxPointerEqual,wxMenuItemCocoaHash);
+
+class WXDLLEXPORT wxMenuItemCocoa : public wxMenuItemBase
+{
+public:
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+ wxMenuItemCocoa(wxMenu *parentMenu = (wxMenu *)NULL,
+ int id = wxID_SEPARATOR,
+ const wxString& name = wxEmptyString,
+ const wxString& help = wxEmptyString,
+ wxItemKind kind = wxITEM_NORMAL,
+ wxMenu *subMenu = (wxMenu *)NULL);
+ virtual ~wxMenuItemCocoa();
+
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+public:
+ inline WX_NSMenuItem GetNSMenuItem() { return m_cocoaNSMenuItem; }
+ static inline wxMenuItem* GetFromCocoa(WX_NSMenuItem cocoaNSMenuItem)
+ {
+ wxMenuItemCocoaHash::iterator iter=sm_cocoaHash.find(cocoaNSMenuItem);
+ if(iter!=sm_cocoaHash.end())
+ return iter->second;
+ return NULL;
+ }
+protected:
+ WX_NSMenuItem m_cocoaNSMenuItem;
+ static wxMenuItemCocoaHash sm_cocoaHash;
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ // override base class virtuals to update the item appearance on screen
+ virtual void SetText(const wxString& text);
+ virtual void SetCheckable(bool checkable);
+
+ virtual void Enable(bool enable = TRUE);
+ virtual void Check(bool check = TRUE);
+
+ // we add some extra functions which are also available under MSW from
+ // wxOwnerDrawn class - they will be moved to wxMenuItemBase later
+ // hopefully
+ void SetBitmaps(const wxBitmap& bmpChecked,
+ const wxBitmap& bmpUnchecked = wxNullBitmap);
+ void SetBitmap(const wxBitmap& bmp) { SetBitmaps(bmp); }
+ const wxBitmap& GetBitmap(bool checked = TRUE) const
+ { return checked ? m_bmpChecked : m_bmpUnchecked; }
+
+protected:
+ // notify the menu about the change in this item
+ inline void NotifyMenu();
+
+ // set the accel index and string from text
+ void UpdateAccelInfo();
+
+ // the bitmaps (may be invalid, then they're not used)
+ wxBitmap m_bmpChecked,
+ m_bmpUnchecked;
+
+ // the accel string (i.e. "Ctrl-Q" or "Alt-F1")
+ wxString m_strAccel;
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxMenuItem)
+};
+
+#endif // _WX_COCOA_MENUITEM_H_
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/stattext.h
+// Purpose: wxStaticText class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/02/15
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_STATTEXT_H__
+#define __WX_COCOA_STATTEXT_H__
+
+#include "wx/cocoa/NSTextField.h"
+
+// ========================================================================
+// wxStaticText
+// ========================================================================
+class WXDLLEXPORT wxStaticText : public wxStaticTextBase, protected wxCocoaNSTextField
+{
+ DECLARE_DYNAMIC_CLASS(wxStaticText)
+ DECLARE_EVENT_TABLE()
+ WX_DECLARE_COCOA_OWNER(NSTextField,NSControl,NSView)
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxStaticText() {}
+ wxStaticText(wxWindow *parent, wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxStaticTextNameStr)
+ {
+ Create(parent, winid, label, pos, size, style, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxStaticTextNameStr);
+ virtual ~wxStaticText();
+
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+protected:
+ virtual void Cocoa_didChangeText(void);
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ void SetLabel(const wxString& label);
+};
+
+#endif // __WX_COCOA_STATTEXT_H__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/textctrl.h
+// Purpose: wxTextCtrl class
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_TEXTCTRL_H__
+#define __WX_COCOA_TEXTCTRL_H__
+
+#include "wx/cocoa/NSTextField.h"
+
+// ========================================================================
+// wxTextCtrl
+// ========================================================================
+class WXDLLEXPORT wxTextCtrl : public wxTextCtrlBase, protected wxCocoaNSTextField
+{
+ DECLARE_DYNAMIC_CLASS(wxTextCtrl)
+ DECLARE_EVENT_TABLE()
+ WX_DECLARE_COCOA_OWNER(NSTextField,NSControl,NSView)
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxTextCtrl() {}
+ wxTextCtrl(wxWindow *parent, wxWindowID winid,
+ const wxString& value = wxEmptyString,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxTextCtrlNameStr)
+ {
+ Create(parent, winid, value, pos, size, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID winid,
+ const wxString& value = wxEmptyString,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxTextCtrlNameStr);
+ virtual ~wxTextCtrl();
+
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+protected:
+ virtual void Cocoa_didChangeText(void);
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ virtual wxString GetValue() const;
+ virtual void SetValue(const wxString& value);
+
+ virtual int GetLineLength(long lineNo) const;
+ virtual wxString GetLineText(long lineNo) const;
+ virtual int GetNumberOfLines() const;
+
+ virtual bool IsModified() const;
+ virtual bool IsEditable() const;
+
+ // If the return values from and to are the same, there is no selection.
+ virtual void GetSelection(long* from, long* to) const;
+
+ // operations
+ // ----------
+
+ // editing
+ virtual void Clear();
+ virtual void Replace(long from, long to, const wxString& value);
+ virtual void Remove(long from, long to);
+
+ // clears the dirty flag
+ virtual void DiscardEdits();
+
+ // writing text inserts it at the current position, appending always
+ // inserts it at the end
+ virtual void WriteText(const wxString& text);
+ virtual void AppendText(const wxString& text);
+
+ // translate between the position (which is just an index in the text ctrl
+ // considering all its contents as a single strings) and (x, y) coordinates
+ // which represent column and line.
+ virtual long XYToPosition(long x, long y) const;
+ virtual bool PositionToXY(long pos, long *x, long *y) const;
+
+ virtual void ShowPosition(long pos);
+
+ // Clipboard operations
+ virtual void Copy();
+ virtual void Cut();
+ virtual void Paste();
+
+ // Undo/redo
+ virtual void Undo();
+ virtual void Redo();
+
+ virtual bool CanUndo() const;
+ virtual bool CanRedo() const;
+
+ // Insertion point
+ virtual void SetInsertionPoint(long pos);
+ virtual void SetInsertionPointEnd();
+ virtual long GetInsertionPoint() const;
+ virtual long GetLastPosition() const;
+
+ virtual void SetSelection(long from, long to);
+// virtual void SelectAll();
+ virtual void SetEditable(bool editable);
+
+};
+
+#endif // __WX_COCOA_TEXTCTRL_H__
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/toplevel.h
+// Purpose: wxTopLevelWindowCocoa is the Cocoa implementation of wxTLW
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/08
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_TOPLEVEL_H__
+#define __WX_COCOA_TOPLEVEL_H__
+
+#include "wx/hashmap.h"
+#include "wx/cocoa/NSWindow.h"
+
+// ========================================================================
+// wxTopLevelWindowCocoa
+// ========================================================================
+class WXDLLEXPORT wxTopLevelWindowCocoa : public wxTopLevelWindowBase, protected wxCocoaNSWindow
+{
+ DECLARE_CLASS(wxTopLevelWindowCocoa);
+ DECLARE_EVENT_TABLE();
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ inline wxTopLevelWindowCocoa() { Init(); }
+
+ inline wxTopLevelWindowCocoa(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE,
+ const wxString& name = wxFrameNameStr)
+ {
+ Init();
+ Create(parent, winid, title, pos, size, style, name);
+ }
+
+ bool Create(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE,
+ const wxString& name = wxFrameNameStr);
+
+ virtual ~wxTopLevelWindowCocoa();
+
+protected:
+ // common part of all ctors
+ void Init();
+
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+public:
+ inline WX_NSWindow GetNSWindow() { return m_cocoaNSWindow; }
+ virtual void Cocoa_close(void);
+ virtual bool Cocoa_windowShouldClose(void);
+ virtual void Cocoa_wxMenuItemAction(wxMenuItem& item);
+protected:
+ void SetNSWindow(WX_NSWindow cocoaNSWindow);
+ WX_NSWindow m_cocoaNSWindow;
+ static wxCocoaNSWindowHash sm_cocoaHash;
+
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ // Pure virtuals
+ virtual void Maximize(bool maximize = true);
+ virtual bool IsMaximized() const;
+ virtual void Iconize(bool iconize = true);
+ virtual bool IsIconized() const;
+ virtual void Restore();
+ virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL);
+ virtual bool IsFullScreen() const;
+ // other
+ virtual bool Show( bool show = true );
+ virtual bool Close( bool force = false );
+ virtual void OnCloseWindow(wxCloseEvent& event);
+ virtual void DoMoveWindow(int x, int y, int width, int height);
+ virtual void DoGetSize(int *width, int *height) const;
+ virtual void DoGetPosition(int *x, int *y) const;
+
+
+// Things I may/may not do
+// virtual void SetIcon(const wxIcon& icon);
+// virtual void SetIcons(const wxIconBundle& icons) { SetIcon( icons.GetIcon( -1 ) ); }
+// virtual void Clear() ;
+// virtual void Raise();
+// virtual void Lower();
+// virtual void SetTitle( const wxString& title);
+protected:
+ // is the frame currently iconized?
+ bool m_iconized;
+ // has the frame been closed
+ bool m_closed;
+ // should the frame be maximized when it will be shown? set by Maximize()
+ // when it is called while the frame is hidden
+ bool m_maximizeOnShow;
+};
+
+// list of all frames and modeless dialogs
+extern WXDLLEXPORT_DATA(wxWindowList) wxModelessWindows;
+
+#endif // __WX_COCOA_TOPLEVEL_H__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/cocoa/window.h
+// Purpose: wxWindowCocoa
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/26
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __WX_COCOA_WINDOW_H__
+#define __WX_COCOA_WINDOW_H__
+
+#include "wx/cocoa/NSView.h"
+
+// ========================================================================
+// wxWindowCocoa
+// ========================================================================
+class WXDLLEXPORT wxWindowCocoa: public wxWindowBase, protected wxCocoaNSView
+{
+ DECLARE_DYNAMIC_CLASS(wxWindowCocoa)
+ DECLARE_NO_COPY_CLASS(wxWindowCocoa)
+ DECLARE_EVENT_TABLE()
+// ------------------------------------------------------------------------
+// initialization
+// ------------------------------------------------------------------------
+public:
+ wxWindowCocoa() { Init(); }
+ inline wxWindowCocoa(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxPanelNameStr)
+ {
+ Init();
+ Create(parent, winid, pos, size, style, name);
+ }
+
+ virtual ~wxWindowCocoa();
+
+ bool Create(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxPanelNameStr);
+protected:
+ void Init();
+// ------------------------------------------------------------------------
+// Cocoa specifics
+// ------------------------------------------------------------------------
+public:
+ inline WX_NSView GetNSView() { return m_cocoaNSView; }
+ void CocoaAddChild(wxWindowCocoa *child);
+ void CocoaRemoveFromParent(void);
+ virtual void Cocoa_FrameChanged(void);
+protected:
+ void SetNSView(WX_NSView cocoaNSView);
+ WX_NSView m_cocoaNSView;
+ WX_NSView m_dummyNSView;
+// ------------------------------------------------------------------------
+// Implementation
+// ------------------------------------------------------------------------
+public:
+ /* Pure Virtuals */
+ // Raise the window to the top of the Z order
+ virtual void Raise();
+ // Lower the window to the bottom of the Z order
+ virtual void Lower();
+ // Set the focus to this window
+ virtual void SetFocus();
+ // Warp the pointer the given position
+ virtual void WarpPointer(int x_pos, int y_pos) ;
+ // Send the window a refresh event
+ virtual void Refresh(bool eraseBack = TRUE, const wxRect *rect = NULL);
+ // Clear the window
+ virtual void Clear();
+ // Set/get the window's font
+ virtual bool SetFont(const wxFont& f);
+// inline virtual wxFont& GetFont() const;
+ // Get character size
+ virtual int GetCharHeight() const;
+ virtual int GetCharWidth() const;
+ virtual void GetTextExtent(const wxString& string, int *x, int *y,
+ int *descent = NULL,
+ int *externalLeading = NULL,
+ const wxFont *theFont = NULL) const;
+ // Scroll stuff
+ virtual void SetScrollbar(int orient, int pos, int thumbVisible,
+ int range, bool refresh = TRUE);
+ virtual void SetScrollPos(int orient, int pos, bool refresh = TRUE);
+ virtual int GetScrollPos(int orient) const;
+ virtual int GetScrollThumb(int orient) const;
+ virtual int GetScrollRange(int orient) const;
+ virtual void ScrollWindow(int dx, int dy, const wxRect *rect = NULL);
+ // Get the private handle (platform-dependent)
+ virtual WXWidget GetHandle() const;
+ // Convert client to screen coordinates
+ virtual void DoClientToScreen(int *x, int *y) const;
+ // Convert screen to client coordinates
+ virtual void DoScreenToClient(int *x, int *y) const;
+ // Capture/release mouse
+ virtual void DoCaptureMouse();
+ virtual void DoReleaseMouse();
+ // Get window position, relative to parent (or screen if no parent)
+ virtual void DoGetPosition(int *x, int *y) const;
+ // Get overall window size
+ virtual void DoGetSize(int *width, int *height) const;
+ // Get/set client (application-useable) size
+ virtual void DoGetClientSize(int *width, int *height) const;
+ virtual void DoSetClientSize(int width, int size);
+ // Set overall size and position
+ virtual void DoSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ virtual void DoMoveWindow(int x, int y, int width, int height);
+ // Popup a menu
+ virtual bool DoPopupMenu(wxMenu *menu, int x, int y);
+
+ /* Other implementation */
+
+ // NOTE: typically Close() is not virtual, but we want this for Cocoa
+ virtual bool Close( bool force = false );
+ virtual bool Show( bool show = true );
+};
+
+#endif // __WX_COCOA_WINDOW_H__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/NSButton.cpp
+// Purpose: wxCocoaNSButton
+// Author: David Elliott
+// Modified by:
+// Created: 2003/01/31
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+#endif // WX_PRECOMP
+
+#include "wx/cocoa/NSButton.h"
+#import <AppKit/NSButton.h>
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+WX_IMPLEMENT_OBJC_INTERFACE_HASHMAP(NSButton)
+
+// ============================================================================
+// @class wxPoserNSButton
+// ============================================================================
+@interface wxPoserNSButton : NSButton
+{
+}
+
+- (void)wxNSButtonAction: (id)sender;
+@end // wxPoserNSButton
+
+WX_IMPLEMENT_POSER(wxPoserNSButton);
+
+@implementation wxPoserNSButton : NSButton
+- (void)wxNSButtonAction: (id)sender
+{
+ wxASSERT_MSG(self==sender,"Received wxNSButtonAction from another object");
+ wxCocoaNSButton *button = wxCocoaNSButton::GetFromCocoa(self);
+ wxCHECK_RET(button,"wxNSButtonAction received without associated wx object");
+ button->Cocoa_wxNSButtonAction();
+}
+
+@end // implementation wxPoserNSButton
+
+void wxCocoaNSButton::AssociateNSButton(WX_NSButton cocoaNSButton)
+{
+ sm_cocoaHash.insert(wxCocoaNSButtonHash::value_type(cocoaNSButton,this));
+ [cocoaNSButton setTarget: cocoaNSButton];
+ [cocoaNSButton setAction: @selector(wxNSButtonAction:)];
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/NSControl.cpp
+// Purpose: wxCocoaNSControl
+// Author: David Elliott
+// Modified by:
+// Created: 2003/02/15
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+#endif // WX_PRECOMP
+
+#include "wx/cocoa/NSControl.h"
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+WX_IMPLEMENT_OBJC_INTERFACE(NSControl)
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/NSMenu.mm
+// Purpose: wxCocoaNSMenu implementation
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/09
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+#endif // WX_PRECOMP
+
+#include "wx/cocoa/NSMenu.h"
+#include "wx/cocoa/ObjcPose.h"
+
+#import <Foundation/NSString.h>
+#import <AppKit/NSMenu.h>
+
+#if wxUSE_MENUS
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+// @class wxPoserNSMenu
+// ============================================================================
+@interface wxPoserNSMenu : NSMenu
+{
+}
+
+@end // wxPoserNSMenu
+
+WX_IMPLEMENT_POSER(wxPoserNSMenu);
+@implementation wxPoserNSMenu : NSMenu
+
+@end // wxPoserNSMenu
+
+// ============================================================================
+// wxCocoaNSMenu implementation
+// ============================================================================
+bool wxCocoaNSMenu::CocoaCreate(const wxString &title)
+{
+ wxLogDebug("CocoaCreate: "+title);
+ m_cocoaNSMenu = [[NSMenu alloc] initWithTitle: [NSString stringWithCString: title.c_str()]];
+ return true;
+}
+
+wxCocoaNSMenu::~wxCocoaNSMenu()
+{
+ [m_cocoaNSMenu release];
+}
+
+#endif // wxUSE_MENUS
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/NSTextField.mm
+// Purpose: wxCocoaNSTextField
+// Author: David Elliott
+// Modified by:
+// Created: 2003/01/31
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+#endif // WX_PRECOMP
+
+#include "wx/cocoa/NSTextField.h"
+
+WX_IMPLEMENT_OBJC_INTERFACE(NSTextField)
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/NSView.mm
+// Purpose: wxCocoaNSView
+// Author: David Elliott
+// Modified by:
+// Created: 2003/02/15
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/window.h"
+#endif // WX_PRECOMP
+
+#include "wx/cocoa/NSView.h"
+
+#import <Appkit/NSView.h>
+#import <Foundation/NSNotification.h>
+#import <Foundation/NSString.h>
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+WX_IMPLEMENT_OBJC_INTERFACE_HASHMAP(NSView)
+
+void wxCocoaNSView::AssociateNSView(WX_NSView cocoaNSView)
+{
+ sm_cocoaHash.insert(wxCocoaNSViewHash::value_type(cocoaNSView,this));
+ [[NSNotificationCenter defaultCenter] addObserver:(id)sm_cocoaObserver selector:@selector(notificationFrameChanged:) name:@"NSViewFrameDidChangeNotification" object:cocoaNSView];
+ [cocoaNSView setPostsFrameChangedNotifications: YES];
+}
+
+void wxCocoaNSView::DisassociateNSView(WX_NSView cocoaNSView)
+{
+ sm_cocoaHash.erase(cocoaNSView);
+ [[NSNotificationCenter defaultCenter] removeObserver:(id)sm_cocoaObserver name:@"NSViewFrameDidChangeNotification" object:cocoaNSView];
+}
+
+// ============================================================================
+// @class wxPoserNSView
+// ============================================================================
+@interface wxPoserNSView : NSView
+{
+}
+
+@end // wxPoserNSView
+
+WX_IMPLEMENT_POSER(wxPoserNSView);
+@implementation wxPoserNSView : NSView
+
+@end // implementation wxPoserNSView
+
+@interface wxNSViewNotificationObserver : NSObject
+{
+}
+
+// FIXME: Initializing like this is a really bad idea. If for some reason
+// we ever require posing as an NSObject we won't be able to since an instance
+// will have already been created here. Of course, catching messages for
+// NSObject seems like a LOT of overkill, so I doubt we ever will anyway!
+void *wxCocoaNSView::sm_cocoaObserver = [[wxNSViewNotificationObserver alloc] init];
+
+- (void)notificationFrameChanged: (NSNotification *)notification;
+@end // interface wxNSViewNotificationObserver
+
+@implementation wxNSViewNotificationObserver : NSObject
+
+- (void)notificationFrameChanged: (NSNotification *)notification;
+{
+ wxCocoaNSView *win = wxCocoaNSView::GetFromCocoa([notification object]);
+ wxCHECK_RET(win,"notificationFrameChanged received but no wxWindow exists");
+ win->Cocoa_FrameChanged();
+}
+
+@end // implementation wxNSViewNotificationObserver
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/NSWindow.mm
+// Purpose: wxCocoaNSWindow
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+ #include "wx/menuitem.h"
+#endif // WX_PRECOMP
+
+#include "wx/cocoa/NSWindow.h"
+
+#import <Appkit/NSWindow.h>
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+WX_IMPLEMENT_OBJC_INTERFACE_HASHMAP(NSWindow)
+
+void wxCocoaNSWindow::AssociateNSWindow(WX_NSWindow cocoaNSWindow)
+{
+ [cocoaNSWindow setReleasedWhenClosed: NO];
+ sm_cocoaHash.insert(wxCocoaNSWindowHash::value_type(cocoaNSWindow,this));
+}
+
+// ============================================================================
+// @class wxPoserNSWindow
+// ============================================================================
+@interface wxPoserNSWindow : NSWindow
+{
+}
+
+- (void)close;
+- (BOOL)windowShouldClose: (id)sender;
+
+- (BOOL)wxMenuItemAction: (id)sender;
+@end // wxPoserNSwindow
+
+WX_IMPLEMENT_POSER(wxPoserNSWindow);
+@implementation wxPoserNSWindow : NSWindow
+
+- (void)close
+{
+ wxLogDebug("close");
+ wxCocoaNSWindow *tlw = wxCocoaNSWindow::GetFromCocoa(self);
+ if(tlw)
+ tlw->Cocoa_close();
+ [super close];
+}
+
+- (BOOL)windowShouldClose: (id)sender
+{
+ wxLogDebug("windowShouldClose");
+ wxCocoaNSWindow *tlw = wxCocoaNSWindow::GetFromCocoa(sender);
+ if(tlw && !tlw->Cocoa_windowShouldClose())
+ return NO;
+ wxLogDebug("Window will most likely be CLOSED");
+ if([[wxPoserNSWindow superclass] instancesRespondToSelector:@selector(windowShouldClose:)])
+ return [super windowShouldClose: sender];
+ return YES;
+}
+
+- (BOOL)wxMenuItemAction: (id)sender
+{
+ wxLogDebug("wxMenuItemAction");
+ wxMenuItem *item = wxMenuItem::GetFromCocoa(sender);
+ if(!item)
+ return NO;
+
+ wxCocoaNSWindow *tlw = wxCocoaNSWindow::GetFromCocoa(self);
+ wxASSERT(tlw);
+ tlw->Cocoa_wxMenuItemAction(*item);
+ return YES;
+}
+@end // implementation wxPoserNSWindow
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/app.mm
+// Purpose: wxApp
+// Author: David Elliott
+// Modified by:
+// Created: 2002/11/27
+// RCS-ID: $Id:
+// Copyright: (c) David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/defs.h"
+ #include "wx/app.h"
+ #include "wx/frame.h"
+ #include "wx/dialog.h"
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/cocoa/ObjcPose.h"
+#endif
+
+#if wxUSE_WX_RESOURCES
+# include "wx/resource.h"
+#endif
+
+#import <AppKit/NSApplication.h>
+#import <Foundation/NSRunLoop.h>
+#import <Foundation/NSArray.h>
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
+wxApp *wxTheApp = NULL;
+wxPoseAsInitializer *wxPoseAsInitializer::sm_first = NULL;
+
+@interface wxPoserNSApplication : NSApplication
+{
+}
+
+- (void)doIdle: (id)data;
+- (void)finishLaunching;
+- (void)sendEvent: (NSEvent*)anEvent;
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)theApplication;
+@end // wxPoserNSApplication
+
+@implementation wxPoserNSApplication : NSApplication
+
+- (void)doIdle: (id)data
+{
+ wxASSERT(wxTheApp);
+ wxLogDebug("doIdle called");
+ NSRunLoop *rl = [NSRunLoop currentRunLoop];
+ // runMode: beforeDate returns YES if something was done
+ while(wxTheApp->ProcessIdle()) // FIXME: AND NO EVENTS ARE PENDING
+ {
+ wxLogDebug("Looping for idle events");
+ #if 1
+ if( [rl runMode:[rl currentMode] beforeDate:[NSDate distantPast]])
+ {
+ wxLogDebug("Found actual work to do");
+ break;
+ }
+ #endif
+ }
+ wxLogDebug("Idle processing complete, requesting next idle event");
+ // Add ourself back into the run loop (on next event) if necessary
+ wxTheApp->CocoaRequestIdle();
+}
+
+- (void)finishLaunching
+{
+ wxLogDebug("finishLaunching");
+ bool initsuccess = wxTheApp->OnInit();
+ if(!initsuccess)
+ [super stop: NULL];
+
+ [super finishLaunching];
+}
+
+- (void)sendEvent: (NSEvent*)anEvent
+{
+ wxLogDebug("SendEvent");
+ wxTheApp->CocoaInstallRequestedIdleHandler();
+ [super sendEvent: anEvent];
+}
+
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)theApplication
+{
+ BOOL ret = wxTheApp->GetExitOnFrameDelete();
+ wxLogDebug("applicationShouldTermintaeAfterLastWindowClosed=%d",ret);
+ return ret;
+}
+
+@end // wxPoserNSApplication
+WX_IMPLEMENT_POSER(wxPoserNSApplication);
+
+// ============================================================================
+// functions
+// ============================================================================
+
+//----------------------------------------------------------------------
+// wxEntry
+//----------------------------------------------------------------------
+
+int WXDLLEXPORT wxEntryStart( int WXUNUSED(argc), char *WXUNUSED(argv)[] )
+{
+ return wxApp::Initialize();
+}
+
+int WXDLLEXPORT wxEntryInitGui()
+{
+ return wxTheApp->OnInitGui();
+}
+
+void WXDLLEXPORT wxEntryCleanup()
+{
+ wxApp::CleanUp();
+}
+
+int wxEntry( int argc, char *argv[])
+{
+ if (!wxEntryStart(argc, argv)) {
+ return 0;
+ }
+ wxLogDebug("Creating application");
+ // create the application object or ensure that one already exists
+ if (!wxTheApp)
+ {
+ // The app may have declared a global application object, but we recommend
+ // the IMPLEMENT_APP macro is used instead, which sets an initializer
+ // function for delayed, dynamic app object construction.
+ wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
+ wxT("No initializer - use IMPLEMENT_APP macro.") );
+
+ wxTheApp = (wxApp*) (*wxApp::GetInitializerFunction()) ();
+ }
+
+ wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
+
+ // Mac OS X passes a process serial number command line argument when
+ // the application is launched from the Finder. This argument must be
+ // removed from the command line arguments before being handled by the
+ // application (otherwise applications would need to handle it)
+
+ if (argc > 1) {
+ char theArg[6] = "";
+ strncpy(theArg, argv[1], 5);
+
+ if (strcmp(theArg, "-psn_") == 0) {
+ // assume the argument is always the only one and remove it
+ --argc;
+ }
+ }
+
+ wxTheApp->argc = argc;
+ wxTheApp->argv = argv;
+
+ wxLogDebug("initializing gui");
+ // GUI-specific initialization, such as creating an app context.
+ wxEntryInitGui();
+
+ // Here frames insert themselves automatically
+ // into wxTopLevelWindows by getting created
+ // in OnInit().
+
+ int retValue = 0;
+
+ wxLogDebug("Time to run");
+ retValue = wxTheApp->OnRun();
+
+ wxWindow *topWindow = wxTheApp->GetTopWindow();
+ if ( topWindow )
+ {
+ // Forcibly delete the window.
+ if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
+ topWindow->IsKindOf(CLASSINFO(wxDialog)) )
+ {
+ topWindow->Close(TRUE);
+ }
+ else
+ {
+ delete topWindow;
+ wxTheApp->SetTopWindow(NULL);
+ }
+ }
+
+ wxTheApp->OnExit();
+
+ wxEntryCleanup();
+
+ return retValue;
+}
+
+// ----------------------------------------------------------------------------
+// other functions
+// ----------------------------------------------------------------------------
+void wxWakeUpIdle()
+{
+ wxTheApp->CocoaRequestIdle();
+}
+
+void wxExit()
+{
+ wxLogError(_("Fatal error: exiting"));
+
+ wxApp::CleanUp();
+ exit(1);
+}
+
+// ============================================================================
+// wxApp implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxApp Static member initialization
+// ----------------------------------------------------------------------------
+wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
+BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
+ EVT_IDLE(wxApp::OnIdle)
+// EVT_END_SESSION(wxApp::OnEndSession)
+// EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
+END_EVENT_TABLE()
+#endif
+
+// ----------------------------------------------------------------------------
+// wxApp static functions
+// ----------------------------------------------------------------------------
+/*static*/ bool wxApp::Initialize()
+{
+ wxPoseAsInitializer::InitializePosers();
+ wxClassInfo::InitializeClasses();
+
+#if wxUSE_THREADS
+ wxPendingEventsLocker = new wxCriticalSection;
+#endif
+
+ wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
+ wxTheColourDatabase->Initialize();
+
+ wxInitializeStockLists();
+ wxInitializeStockObjects();
+
+#if wxUSE_WX_RESOURCES
+ wxInitializeResourceSystem();
+#endif
+
+ wxBitmap::InitStandardHandlers();
+
+ wxModule::RegisterModules();
+ if (!wxModule::InitializeModules()) {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/*static*/ void wxApp::CleanUp()
+{
+ wxModule::CleanUpModules();
+
+#if wxUSE_WX_RESOURCES
+ wxCleanUpResourceSystem();
+#endif
+
+ wxDeleteStockObjects() ;
+
+ // Destroy all GDI lists, etc.
+ wxDeleteStockLists();
+
+ delete wxTheColourDatabase;
+ wxTheColourDatabase = NULL;
+
+ wxBitmap::CleanUpHandlers();
+
+ delete wxPendingEvents;
+
+#if wxUSE_THREADS
+ delete wxPendingEventsLocker;
+ // If we don't do the following, we get an apparent memory leak.
+ ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
+#endif
+
+ wxClassInfo::CleanUpClasses();
+
+ delete wxTheApp;
+ wxTheApp = NULL;
+
+#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
+ // At this point we want to check if there are any memory
+ // blocks that aren't part of the wxDebugContext itself,
+ // as a special case. Then when dumping we need to ignore
+ // wxDebugContext, too.
+ if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
+ {
+ wxLogDebug(wxT("There were memory leaks."));
+ wxDebugContext::Dump();
+ wxDebugContext::PrintStatistics();
+ }
+ // wxDebugContext::SetStream(NULL, NULL);
+#endif
+
+#if wxUSE_LOG
+ // do it as the very last thing because everything else can log messages
+ delete wxLog::SetActiveTarget(NULL);
+#endif // wxUSE_LOG
+}
+
+// ----------------------------------------------------------------------------
+// wxApp creation
+// ----------------------------------------------------------------------------
+
+wxApp::wxApp()
+{
+ m_topWindow = NULL;
+ wxTheApp = this;
+
+ m_isIdle = true;
+#if WXWIN_COMPATIBILITY_2_2
+ m_wantDebugOutput = TRUE;
+#endif
+
+ argc = 0;
+ argv = NULL;
+ m_cocoaApp = NULL;
+}
+
+void wxApp::CocoaInstallIdleHandler()
+{
+ wxLogDebug("wxApp::CocoaInstallIdleHandler");
+ m_isIdle = false;
+ // Call doIdle for EVERYTHING dammit
+// We'd need Foundation/NSConnection.h for this next constant, do we need it?
+ [[ NSRunLoop currentRunLoop ] performSelector:@selector(doIdle:) target:m_cocoaApp argument:NULL order:0 modes:[NSArray arrayWithObjects:NSDefaultRunLoopMode, /* NSConnectionReplyRunLoopMode,*/ NSModalPanelRunLoopMode, /**/NSEventTrackingRunLoopMode,/**/ nil] ];
+}
+
+bool wxApp::OnInitGui()
+{
+ if(!wxAppBase::OnInitGui())
+ return FALSE;
+
+ // Create the app using the sharedApplication method
+ m_cocoaApp = [NSApplication sharedApplication];
+// [ m_cocoaApp setDelegate:m_cocoaApp ];
+ #if 0
+ wxLogDebug("Just for kicks");
+ [ m_cocoaApp performSelector:@selector(doIdle:) withObject:NULL ];
+ wxLogDebug("okay.. done now");
+ #endif
+ return TRUE;
+}
+
+bool wxApp::OnInit()
+{
+ if(!wxAppBase::OnInit())
+ return FALSE;
+
+ return TRUE;
+}
+
+bool wxApp::Initialized()
+{
+ if (GetTopWindow())
+ return TRUE;
+ else
+ return FALSE;
+}
+
+int wxApp::MainLoop()
+{
+ [m_cocoaApp run];
+ return 0;
+}
+
+// Returns TRUE if more time is needed.
+bool wxApp::ProcessIdle()
+{
+ wxIdleEvent event;
+ event.SetEventObject(this);
+ ProcessEvent(event);
+
+ return event.MoreRequested();
+}
+
+void wxApp::ExitMainLoop()
+{
+ wxLogDebug("wxApp::ExitMailLoop m_isIdle=%d, isRunning=%d",(int)m_isIdle,(int)[m_cocoaApp isRunning]);
+// CocoaInstallRequestedIdleHandler();
+// if(m_isIdle)
+// [[ NSRunLoop currentRunLoop ] performSelector:@selector(doIdle:) target:m_cocoaApp argument:NULL order:0 modes:[NSArray arrayWithObjects:NSDefaultRunLoopMode, /* NSConnectionReplyRunLoopMode, NSModalPanelRunLoopMode, NSEventTrackingRunLoopMode,*/ nil] ];
+// actually.. we WANT the idle event
+// or not
+#if 0
+ if(!m_isIdle)
+ [[ NSRunLoop currentRunLoop ] cancelPerformSelector:@selector(doIdle:) target:m_cocoaApp argument:NULL];
+#endif
+ [m_cocoaApp terminate: m_cocoaApp];
+}
+
+// Is a message/event pending?
+bool wxApp::Pending()
+{
+ return 0;
+}
+
+// Dispatch a message.
+void wxApp::Dispatch()
+{
+}
+
+void wxApp::OnIdle(wxIdleEvent& event)
+{
+ wxLogDebug("wxApp::OnIdle");
+ static bool s_inOnIdle = FALSE;
+
+ // Avoid recursion (via ProcessEvent default case)
+ if ( s_inOnIdle )
+ return;
+ s_inOnIdle = TRUE;
+
+
+ DeletePendingObjects();
+
+ // flush the logged messages if any
+ wxLog *pLog = wxLog::GetActiveTarget();
+ if ( pLog != NULL && pLog->HasPendingMessages() )
+ pLog->Flush();
+
+ // Send OnIdle events to all windows
+ bool needMore = SendIdleEvents();
+
+ if (needMore)
+ event.RequestMore(TRUE);
+
+ s_inOnIdle = FALSE;
+}
+
+// Send idle event to all top-level windows
+bool wxApp::SendIdleEvents()
+{
+ bool needMore = FALSE;
+ wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
+ while (node)
+ {
+ wxWindow* win = node->GetData();
+ if (SendIdleEvents(win))
+ needMore = TRUE;
+
+ node = node->GetNext();
+ }
+ return needMore;
+}
+
+// Send idle event to window and all subwindows
+bool wxApp::SendIdleEvents(wxWindow* win)
+{
+// wxLogDebug("SendIdleEvents win=%p",win);
+ bool needMore = FALSE;
+
+ wxIdleEvent event;
+ event.SetEventObject(win);
+ win->ProcessEvent(event);
+
+ if (event.MoreRequested())
+ needMore = TRUE;
+
+ wxWindowList::Node* node = win->GetChildren().GetFirst();
+ while (node)
+ {
+// wxLogDebug("child=%p",node->Data());
+ wxWindow* win = node->GetData();
+ if (SendIdleEvents(win))
+ needMore = TRUE;
+
+ node = node->GetNext();
+ }
+ return needMore;
+}
+
+// Yield to other processes
+
+bool wxApp::Yield(bool onlyIfNeeded)
+{
+ // MT-FIXME
+ static bool s_inYield = false;
+
+#if wxUSE_LOG
+ // disable log flushing from here because a call to wxYield() shouldn't
+ // normally result in message boxes popping up &c
+ wxLog::Suspend();
+#endif // wxUSE_LOG
+
+ if (s_inYield)
+ {
+ if ( !onlyIfNeeded )
+ {
+ wxFAIL_MSG( wxT("wxYield called recursively" ) );
+ }
+
+ return false;
+ }
+
+ s_inYield = true;
+
+ wxLogDebug("WARNING: SUPPOSED to have yielded!");
+ // FIXME: Do something!
+
+#if wxUSE_LOG
+ // let the logs be flashed again
+ wxLog::Resume();
+#endif // wxUSE_LOG
+
+ s_inYield = false;
+
+ return true;
+}
+
+void wxApp::DeletePendingObjects()
+{
+ wxNode *node = wxPendingDelete.GetFirst();
+ while (node)
+ {
+ wxObject *obj = (wxObject *)node->GetData();
+
+ delete obj;
+
+ if (wxPendingDelete.Find(obj))
+ delete node;
+
+ node = wxPendingDelete.GetFirst();
+ }
+}
+
+// platform specifics
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/button.mm
+// Purpose: wxButton
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/30
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/defs.h"
+ #include "wx/button.h"
+ #include "wx/log.h"
+#endif
+
+#import <AppKit/NSButton.h>
+#import <Foundation/NSString.h>
+
+IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
+BEGIN_EVENT_TABLE(wxButton, wxButtonBase)
+END_EVENT_TABLE()
+WX_IMPLEMENT_COCOA_OWNER(wxButton,NSButton,NSControl,NSView)
+
+bool wxButton::Create(wxWindow *parent, wxWindowID winid,
+ const wxString& label, const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator, const wxString& name)
+{
+ wxLogDebug("Creating control with id=%d",winid);
+ if(!CreateControl(parent,winid,pos,size,style,validator,name))
+ return false;
+ wxLogDebug("Created control with id=%d",GetId());
+ NSRect cocoaRect = NSMakeRect(10,10,20,20);
+ m_cocoaNSView = NULL;
+ SetNSButton([[NSButton alloc] initWithFrame: cocoaRect]);
+ // NOTE: YES we want to release this (to match the alloc).
+ // DoAddChild(this) will retain us again since addSubView doesn't.
+ [m_cocoaNSView release];
+
+ [GetNSButton() setBezelStyle:NSRoundedBezelStyle];
+ [GetNSButton() setTitle:[NSString stringWithCString: label.c_str()]];
+ [GetNSControl() sizeToFit];
+
+ if(m_parent)
+ m_parent->CocoaAddChild(this);
+
+ return true;
+}
+
+wxButton::~wxButton()
+{
+ CocoaRemoveFromParent();
+ SetNSButton(NULL);
+}
+
+void wxButton::Cocoa_wxNSButtonAction(void)
+{
+ wxLogDebug("YAY!");
+ wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
+ InitCommandEvent(event); // event.SetEventObject(this);
+ Command(event);
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/control.mm
+// Purpose: wxControl class
+// Author: David Elliiott
+// Modified by:
+// Created: 2003/02/15
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/defs.h"
+ #include "wx/control.h"
+ #include "wx/log.h"
+#endif
+
+#import <AppKit/NSControl.h>
+
+IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
+BEGIN_EVENT_TABLE(wxControl, wxControlBase)
+END_EVENT_TABLE()
+WX_IMPLEMENT_COCOA_OWNER(wxControl,NSControl,NSView,NSView)
+
+bool wxControl::Create(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos, const wxSize& size, long style,
+ const wxValidator& validator, const wxString& name)
+{
+ wxLogDebug("Creating control with id=%d",winid);
+ if(!CreateControl(parent,winid,pos,size,style,validator,name))
+ return false;
+ wxLogDebug("Created control with id=%d",GetId());
+ NSRect cocoaRect = NSMakeRect(10,10,20,20);
+ m_cocoaNSView = NULL;
+ SetNSControl([[NSControl alloc] initWithFrame: cocoaRect]);
+ // NOTE: YES we want to release this (to match the alloc).
+ // DoAddChild(this) will retain us again since addSubView doesn't.
+ [m_cocoaNSView release];
+
+ [GetNSControl() sizeToFit];
+
+ if(m_parent)
+ m_parent->CocoaAddChild(this);
+
+ return true;
+}
+
+wxControl::~wxControl()
+{
+ CocoaRemoveFromParent();
+ SetNSControl(NULL);
+}
+
+wxSize wxControl::DoGetBestSize() const
+{
+ wxASSERT(m_cocoaNSView);
+ NSRect storedRect = [m_cocoaNSView frame];
+ [GetNSControl() sizeToFit];
+ NSRect cocoaRect = [m_cocoaNSView frame];
+ wxSize size((int)cocoaRect.size.width+10,(int)cocoaRect.size.height);
+ [m_cocoaNSView setFrame: storedRect];
+ wxLogDebug("wxControl=%p::DoGetBestSize()==(%d,%d)",this,size.x,size.y);
+ return size;
+}
+
+bool wxControl::ProcessCommand(wxCommandEvent& event)
+{
+#if WXWIN_COMPATIBILITY
+ if ( m_callback )
+ {
+ (void)(*m_callback)(*this, event);
+
+ return TRUE;
+ }
+ else
+#endif // WXWIN_COMPATIBILITY
+
+ return GetEventHandler()->ProcessEvent(event);
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/cocoa/dialog.mm
+// Purpose: wxDialog class
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/15
+// RCS-ID: $Id:
+// Copyright: 2002 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/dialog.h"
+#include "wx/app.h"
+#include "wx/settings.h"
+#include "wx/log.h"
+
+#import <AppKit/NSPanel.h>
+#import <AppKit/NSApplication.h>
+
+// Lists to keep track of windows, so we can disable/enable them
+// for modal dialogs
+static wxWindowList wxModalDialogs;
+
+IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxTopLevelWindow)
+
+BEGIN_EVENT_TABLE(wxDialog, wxDialogBase)
+ EVT_BUTTON(wxID_OK, wxDialog::OnOK)
+ EVT_BUTTON(wxID_APPLY, wxDialog::OnApply)
+ EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
+ EVT_CLOSE(wxDialog::OnCloseWindow)
+END_EVENT_TABLE()
+
+WX_IMPLEMENT_COCOA_OWNER(wxDialog,NSPanel,NSWindow,NSWindow)
+
+void wxDialog::Init()
+{
+ SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
+}
+
+bool wxDialog::Create(wxWindow *parent, wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
+ wxTopLevelWindows.Append(this);
+
+ if(!CreateBase(parent,winid,pos,size,style,wxDefaultValidator,name))
+ return false;
+
+ if (parent)
+ parent->AddChild(this);
+
+ NSRect cocoaRect = NSMakeRect(300,300,200,200);
+
+ unsigned int cocoaStyle = 0;
+ cocoaStyle |= NSTitledWindowMask;
+ cocoaStyle |= NSClosableWindowMask;
+ cocoaStyle |= NSMiniaturizableWindowMask;
+ cocoaStyle |= NSResizableWindowMask;
+
+ m_cocoaNSWindow = NULL;
+ SetNSPanel([[NSPanel alloc] initWithContentRect:cocoaRect styleMask:cocoaStyle backing:NSBackingStoreBuffered defer:NO]);
+ // NOTE: SetNSWindow has retained the Cocoa object for this object.
+ // Because we do not release on close, the following release matches the
+ // above alloc and thus the retain count will be 1.
+ [m_cocoaNSWindow release];
+ wxLogDebug("wxDialog m_cocoaNSWindow retainCount=%d",[m_cocoaNSWindow retainCount]);
+
+ return true;
+}
+
+wxDialog::~wxDialog()
+{
+ wxLogDebug("Destroying");
+ // setReleasedWhenClosed: NO
+ [m_cocoaNSWindow close];
+ SetNSPanel(NULL);
+}
+
+void wxDialog::Cocoa_close(void)
+{
+ m_closed = true;
+ /* Actually, this isn't true anymore */
+ wxLogDebug("Woah: Dialogs are not generally closed");
+}
+
+void wxDialog::SetModal(bool flag)
+{
+ if ( flag )
+ {
+ wxModelessWindows.DeleteObject(this);
+ m_windowStyle |= wxDIALOG_MODAL ;
+ }
+ else
+ {
+ m_windowStyle &= ~wxDIALOG_MODAL ;
+ wxModelessWindows.Append(this);
+ }
+}
+
+bool wxDialog::Show(bool show)
+{
+ if(show)
+ InitDialog();
+ if(IsModal())
+ {
+ if(show)
+ {
+ wxModalDialogs.Append(this);
+ wxLogDebug("runModal");
+ [wxTheApp->GetNSApplication() runModalForWindow:m_cocoaNSWindow];
+ wxLogDebug("runModal END");
+ }
+ else
+ {
+ wxLogDebug("abortModal");
+ [wxTheApp->GetNSApplication() abortModal];
+ wxModalDialogs.DeleteObject(this);
+ }
+ }
+ return true;
+}
+
+// Replacement for Show(TRUE) for modal dialogs - returns return code
+int wxDialog::ShowModal()
+{
+ if(!IsModal())
+ SetModal(true);
+ Show(true);
+ return GetReturnCode();
+}
+
+// EndModal will work for any dialog
+void wxDialog::EndModal(int retCode)
+{
+ SetReturnCode(retCode);
+ Show(false);
+}
+
+bool wxDialog::IsModal() const
+{
+ return (GetWindowStyleFlag() & wxDIALOG_MODAL);
+}
+
+void wxDialog::OnCloseWindow(wxCloseEvent& event)
+{
+ // We'll send a Cancel message by default,
+ // which may close the dialog.
+ // Check for looping if the Cancel event handler calls Close().
+
+ // Note that if a cancel button and handler aren't present in the dialog,
+ // nothing will happen when you close the dialog via the window manager, or
+ // via Close().
+ // We wouldn't want to destroy the dialog by default, since the dialog may have been
+ // created on the stack.
+ // However, this does mean that calling dialog->Close() won't delete the dialog
+ // unless the handler for wxID_CANCEL does so. So use Destroy() if you want to be
+ // sure to destroy the dialog.
+ // The default OnCancel (above) simply ends a modal dialog, and hides a modeless dialog.
+ // ALWAYS VETO THIS EVENT!!!!
+ event.Veto();
+
+ static wxList closing;
+
+ if ( closing.Member(this) )
+ {
+ wxLogDebug("WARNING: Attempting to recursively call Close for dialog");
+ return;
+ }
+
+ closing.Append(this);
+
+ wxLogDebug("Sending Cancel Event");
+ wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
+ cancelEvent.SetEventObject( this );
+ GetEventHandler()->ProcessEvent(cancelEvent); // This may close the dialog
+
+ closing.DeleteObject(this);
+}
+
+// Standard buttons
+void wxDialog::OnOK(wxCommandEvent& event)
+{
+ if ( Validate() && TransferDataFromWindow() )
+ {
+ EndModal(wxID_OK);
+ }
+}
+
+void wxDialog::OnApply(wxCommandEvent& event)
+{
+ if (Validate())
+ TransferDataFromWindow();
+ // TODO probably need to disable the Apply button until things change again
+}
+
+void wxDialog::OnCancel(wxCommandEvent& event)
+{
+ wxLogDebug("Cancelled!");
+ EndModal(wxID_CANCEL);
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/frame.mm
+// Purpose: wxFrame
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/frame.h"
+#include "wx/menu.h"
+#include "wx/menuitem.h"
+#include "wx/app.h"
+#include "wx/log.h"
+
+#import <AppKit/NSWindow.h>
+#import <AppKit/NSApplication.h>
+
+// wxFrame
+
+BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
+END_EVENT_TABLE()
+
+IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)
+
+void wxFrame::Init()
+{
+}
+
+bool wxFrame::Create(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
+ bool rt = wxTopLevelWindow::Create(parent,winid,title,pos,size,style,name);
+
+ return rt;
+}
+
+wxFrame::~wxFrame()
+{
+}
+
+void wxFrame::Cocoa_wxMenuItemAction(wxMenuItem& item)
+{
+ Command(item.GetId());
+}
+
+void wxFrame::AttachMenuBar(wxMenuBar *mbar)
+{
+ wxFrameBase::AttachMenuBar(mbar);
+ if(m_frameMenuBar)
+ {
+ wxLogDebug("Attached menu");
+ [m_cocoaNSWindow setMenu:m_frameMenuBar->GetNSMenu()];
+ }
+}
+
+void wxFrame::DetachMenuBar()
+{
+ if(m_frameMenuBar)
+ {
+ [m_cocoaNSWindow setMenu:nil];
+ }
+ wxFrameBase::DetachMenuBar();
+}
+
+bool wxFrame::Show(bool show)
+{
+ bool ret = wxFrameBase::Show(show);
+ if(show && GetMenuBar())
+ [wxTheApp->GetNSApplication() setMenu:GetMenuBar()->GetNSMenu() ];
+ return ret;
+}
+
+wxPoint wxFrame::GetClientAreaOrigin() const
+{
+ return wxPoint(0,0);
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/main.cpp
+// Purpose: Entry point
+// Author: David Elliott
+// Modified by:
+// Created: 2002/11/11
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+/* DFE: ^^^^^ Was that really necessary :-) */
+
+#include "wx/app.h"
+
+WXDLLEXPORT int main(int argc, char* argv[])
+{
+ return wxEntry(argc, argv);
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/menu.cpp
+// Purpose: wxMenu and wxMenuBar implementation
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/09
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/menu.h"
+ #include "wx/log.h"
+#endif // WX_PRECOMP
+
+#import <Foundation/NSString.h>
+#import <AppKit/NSMenu.h>
+
+#if wxUSE_MENUS
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+// wxMenu implementation
+// ============================================================================
+
+IMPLEMENT_DYNAMIC_CLASS(wxMenu,wxEvtHandler)
+
+bool wxMenu::Create(const wxString& title, long style)
+{
+#if 0
+ if(!title)
+ return CocoaCreate("wxMenu");
+#endif
+ return CocoaCreate(title);
+}
+
+wxMenu::~wxMenu()
+{
+}
+
+bool wxMenu::DoAppend(wxMenuItem *item)
+{
+ if(!wxMenuBase::DoAppend(item))
+ return false;
+ [m_cocoaNSMenu addItem: item->GetNSMenuItem()];
+ return true;
+}
+
+bool wxMenu::DoInsert(unsigned long pos, wxMenuItem *item)
+{
+ if(!wxMenuBase::DoInsert(pos,item))
+ return false;
+ [m_cocoaNSMenu insertItem:item->GetNSMenuItem() atIndex:pos];
+ return true;
+}
+
+wxMenuItem* wxMenu::DoRemove(wxMenuItem *item)
+{
+ wxMenuItem *retitem = wxMenuBase::DoRemove(item);
+ wxASSERT(retitem->GetNSMenuItem());
+ [m_cocoaNSMenu removeItem:retitem->GetNSMenuItem()];
+ return retitem;
+}
+
+// ============================================================================
+// wxMenuBar implementation
+// ============================================================================
+IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow)
+
+bool wxMenuBar::Create(long style)
+{
+ if(!CocoaCreate("wxMenuBar"))
+ return false;
+ return true;
+}
+
+wxMenuBar::~wxMenuBar()
+{
+}
+
+bool wxMenuBar::Append( wxMenu *menu, const wxString &title )
+{
+ wxLogDebug("append menu=%p, title=%s",menu,title.c_str());
+ if(!wxMenuBarBase::Append(menu,title))
+ return false;
+ wxASSERT(menu);
+ wxASSERT(menu->GetNSMenu());
+ NSString *menuTitle = [[NSString alloc] initWithCString: wxStripMenuCodes(title).c_str()];
+ NSMenuItem *newItem = [[NSMenuItem alloc] initWithTitle:menuTitle action:NULL keyEquivalent:@""];
+ [menu->GetNSMenu() setTitle:menuTitle];
+ [newItem setSubmenu:menu->GetNSMenu()];
+
+ [m_cocoaNSMenu addItem:newItem];
+
+ [menuTitle release];
+ [newItem release];
+ return true;
+}
+
+bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
+{
+ wxLogDebug("insert pos=%lu, menu=%p, title=%s",pos,menu,title.c_str());
+ if(!wxMenuBarBase::Insert(pos,menu,title))
+ return false;
+ wxASSERT(menu);
+ wxASSERT(menu->GetNSMenu());
+ NSString *menuTitle = [[NSString alloc] initWithCString: title.c_str()];
+ NSMenuItem *newItem = [[NSMenuItem alloc] initWithTitle:menuTitle action:NULL keyEquivalent:@""];
+ [menu->GetNSMenu() setTitle:menuTitle];
+ [newItem setSubmenu:menu->GetNSMenu()];
+
+ [m_cocoaNSMenu insertItem:newItem atIndex:pos];
+
+ [menuTitle release];
+ [newItem release];
+ return true;
+}
+
+wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
+{
+ return NULL;
+}
+
+wxMenu *wxMenuBar::Remove(size_t pos)
+{
+ return NULL;
+}
+
+
+void wxMenuBar::EnableTop(size_t pos, bool enable)
+{
+}
+
+bool wxMenuBar::IsEnabledTop(size_t pos) const
+{
+ return false;
+}
+
+void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
+{
+}
+
+wxString wxMenuBar::GetLabelTop(size_t pos) const
+{
+ return wxEmptyString;
+}
+
+void wxMenuBar::Attach(wxFrame *frame)
+{
+}
+
+void wxMenuBar::Detach()
+{
+}
+
+wxSize wxMenuBar::DoGetBestClientSize() const
+{
+ return wxDefaultSize;
+}
+
+#endif // wxUSE_MENUS
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: menuitem.cpp
+// Purpose: wxMenuItem implementation
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/15
+// RCS-ID: $Id:
+// Copyright: 2002 David Elliott
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/menu.h"
+ #include "wx/menuitem.h"
+ #include "wx/utils.h"
+ #include "wx/frame.h"
+#endif
+
+#include "wx/cocoa/ObjcPose.h"
+
+#import <AppKit/NSMenuItem.h>
+#import <AppKit/NSMenu.h>
+#import <Foundation/NSString.h>
+
+#if wxUSE_MENUS
+
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+wxMenuItemCocoaHash wxMenuItemCocoa::sm_cocoaHash;
+
+// ----------------------------------------------------------------------------
+// functions prototypes
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+// @class wxPoserNSMenuItem
+// ============================================================================
+@interface wxPoserNSMenuItem : NSMenuItem
+{
+}
+
+@end // wxPoserNSMenuItem
+
+WX_IMPLEMENT_POSER(wxPoserNSMenuItem);
+@implementation wxPoserNSMenuItem : NSMenuItem
+
+@end // wxPoseRNSMenuItem
+
+// ============================================================================
+// wxMenuItemCocoa implementation
+// ============================================================================
+IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
+
+// ----------------------------------------------------------------------------
+// wxMenuItemBase
+// ----------------------------------------------------------------------------
+
+wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
+ int itemid,
+ const wxString& name,
+ const wxString& help,
+ wxItemKind kind,
+ wxMenu *subMenu)
+{
+ return new wxMenuItem(parentMenu, itemid, name, help, kind, subMenu);
+}
+
+/* static */
+wxString wxMenuItemBase::GetLabelFromText(const wxString& text)
+{
+ return wxStripMenuCodes(text);
+}
+
+// ----------------------------------------------------------------------------
+// ctor & dtor
+// ----------------------------------------------------------------------------
+wxMenuItemCocoa::wxMenuItemCocoa(wxMenu *pParentMenu,
+ int itemid,
+ const wxString& strName,
+ const wxString& strHelp,
+ wxItemKind kind,
+ wxMenu *pSubMenu)
+ : wxMenuItemBase(pParentMenu, itemid, strName, strHelp, kind, pSubMenu)
+{
+ NSString *menuTitle = [[NSString alloc] initWithCString: wxStripMenuCodes(strName).c_str()];
+ m_cocoaNSMenuItem = [[NSMenuItem alloc] initWithTitle:menuTitle action:@selector(wxMenuItemAction:) keyEquivalent:@""];
+ sm_cocoaHash.insert(wxMenuItemCocoaHash::value_type(m_cocoaNSMenuItem,this));
+ if(pSubMenu)
+ {
+ wxASSERT(pSubMenu->GetNSMenu());
+ [pSubMenu->GetNSMenu() setTitle:menuTitle];
+ [m_cocoaNSMenuItem setSubmenu:pSubMenu->GetNSMenu()];
+ }
+ [menuTitle release];
+}
+
+wxMenuItem::~wxMenuItem()
+{
+ sm_cocoaHash.erase(m_cocoaNSMenuItem);
+ [m_cocoaNSMenuItem release];
+}
+
+// ----------------------------------------------------------------------------
+// misc
+// ----------------------------------------------------------------------------
+
+// change item state
+// -----------------
+
+void wxMenuItem::Enable(bool bDoEnable)
+{
+ wxMenuItemBase::Enable(bDoEnable);
+}
+
+void wxMenuItem::Check(bool bDoCheck)
+{
+ wxCHECK_RET( IsCheckable(), "only checkable items may be checked" );
+ wxMenuItemBase::Check(bDoCheck);
+}
+
+void wxMenuItem::SetText(const wxString& label)
+{
+ wxMenuItemBase::SetText(label);
+}
+
+void wxMenuItem::SetCheckable(bool checkable)
+{
+ wxMenuItemBase::SetCheckable(checkable);
+}
+
+#endif // wxUSE_MENUS
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/stattext.mm
+// Purpose: wxStaticText
+// Author: David Elliott
+// Modified by:
+// Created: 2003/02/15
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/app.h"
+#include "wx/stattext.h"
+
+#import <Foundation/NSString.h>
+#import <AppKit/NSTextField.h>
+
+IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl)
+BEGIN_EVENT_TABLE(wxStaticText, wxControl)
+END_EVENT_TABLE()
+WX_IMPLEMENT_COCOA_OWNER(wxStaticText,NSTextField,NSControl,NSView)
+
+bool wxStaticText::Create(wxWindow *parent, wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
+ if(!CreateControl(parent,winid,pos,size,style,wxDefaultValidator,name))
+ return false;
+ m_cocoaNSView = NULL;
+ SetNSTextField([[NSTextField alloc] initWithFrame:NSMakeRect(0,0,30,30)]);
+ [m_cocoaNSView release];
+ [GetNSTextField() setStringValue:[NSString stringWithCString:label.c_str()]];
+// [GetNSTextField() setBordered: NO];
+ [GetNSTextField() setBezeled: NO];
+ [GetNSTextField() setEditable: NO];
+ [GetNSTextField() setDrawsBackground: NO];
+ [GetNSControl() sizeToFit];
+ if(m_parent)
+ m_parent->CocoaAddChild(this);
+ return true;
+}
+
+wxStaticText::~wxStaticText()
+{
+ CocoaRemoveFromParent();
+ SetNSTextField(NULL);
+}
+
+void wxStaticText::SetLabel(const wxString& label)
+{
+ // TODO
+}
+
+void wxStaticText::Cocoa_didChangeText(void)
+{
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/textctrl.mm
+// Purpose: wxTextCtrl
+// Author: David Elliott
+// Modified by:
+// Created: 2003/03/16
+// RCS-ID: $Id:
+// Copyright: (c) 2003 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/app.h"
+#include "wx/textctrl.h"
+
+#import <Foundation/NSString.h>
+#import <AppKit/NSTextField.h>
+
+IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
+BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
+END_EVENT_TABLE()
+WX_IMPLEMENT_COCOA_OWNER(wxTextCtrl,NSTextField,NSControl,NSView)
+
+bool wxTextCtrl::Create(wxWindow *parent, wxWindowID winid,
+ const wxString& value,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxValidator& validator,
+ const wxString& name)
+{
+ if(!CreateControl(parent,winid,pos,size,style,validator,name))
+ return false;
+ m_cocoaNSView = NULL;
+ SetNSTextField([[NSTextField alloc] initWithFrame:NSMakeRect(0,0,30,30)]);
+ [m_cocoaNSView release];
+ [GetNSTextField() setStringValue:[NSString stringWithCString:value.c_str()]];
+ [GetNSControl() sizeToFit];
+ if(m_parent)
+ m_parent->CocoaAddChild(this);
+ return true;
+}
+
+wxTextCtrl::~wxTextCtrl()
+{
+ CocoaRemoveFromParent();
+ SetNSTextField(NULL);
+}
+
+void wxTextCtrl::Cocoa_didChangeText(void)
+{
+}
+
+void wxTextCtrl::AppendText(wxString const&)
+{
+}
+
+void wxTextCtrl::SetEditable(bool)
+{
+}
+
+void wxTextCtrl::DiscardEdits()
+{
+}
+
+void wxTextCtrl::SetSelection(long, long)
+{
+}
+
+void wxTextCtrl::ShowPosition(long)
+{
+}
+
+void wxTextCtrl::SetInsertionPoint(long)
+{
+}
+
+void wxTextCtrl::SetInsertionPointEnd()
+{
+}
+
+void wxTextCtrl::Cut()
+{
+}
+
+void wxTextCtrl::Copy()
+{
+}
+
+void wxTextCtrl::Redo()
+{
+}
+
+void wxTextCtrl::Undo()
+{
+}
+
+void wxTextCtrl::Clear()
+{
+}
+
+void wxTextCtrl::Paste()
+{
+}
+
+void wxTextCtrl::Remove(long, long)
+{
+}
+
+void wxTextCtrl::Replace(long, long, wxString const&)
+{
+}
+
+void wxTextCtrl::SetValue(wxString const&)
+{
+}
+
+void wxTextCtrl::WriteText(wxString const&)
+{
+}
+
+bool wxTextCtrl::IsEditable() const
+{
+ return true;
+}
+
+bool wxTextCtrl::IsModified() const
+{
+ return false;
+}
+
+wxString wxTextCtrl::GetLineText(long) const
+{
+ return wxEmptyString;
+}
+
+void wxTextCtrl::GetSelection(long*, long*) const
+{
+}
+
+bool wxTextCtrl::PositionToXY(long, long*, long*) const
+{
+ return false;
+}
+
+long wxTextCtrl::XYToPosition(long, long) const
+{
+ return 0;
+}
+
+int wxTextCtrl::GetLineLength(long) const
+{
+ return 0;
+}
+
+long wxTextCtrl::GetLastPosition() const
+{
+ return 0;
+}
+
+int wxTextCtrl::GetNumberOfLines() const
+{
+ return 0;
+}
+
+long wxTextCtrl::GetInsertionPoint() const
+{
+ return 0;
+}
+
+bool wxTextCtrl::CanRedo() const
+{
+ return false;
+}
+
+bool wxTextCtrl::CanUndo() const
+{
+ return false;
+}
+
+wxString wxTextCtrl::GetValue() const
+{
+ return wxEmptyString;
+}
+
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: cocoa/toplevel.mm
+// Purpose: implements wxTopLevelWindow for Cocoa
+// Author: David Elliott
+// Modified by:
+// Created: 2002/11/27
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// License: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/window.h"
+ #include "wx/toplevel.h"
+ #include "wx/menuitem.h"
+ #include "wx/frame.h"
+ #include "wx/log.h"
+ #include "wx/app.h"
+#endif //WX_PRECOMP
+
+#import <AppKit/NSWindow.h>
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
+// list of all frames and modeless dialogs
+wxWindowList wxModelessWindows;
+
+// ============================================================================
+// wxTopLevelWindowCocoa implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxTopLevelWindowCocoa creation
+// ----------------------------------------------------------------------------
+IMPLEMENT_CLASS(wxTopLevelWindowCocoa,wxWindowCocoa)
+BEGIN_EVENT_TABLE(wxTopLevelWindowCocoa,wxTopLevelWindowBase)
+ EVT_CLOSE(wxTopLevelWindowCocoa::OnCloseWindow)
+END_EVENT_TABLE()
+
+void wxTopLevelWindowCocoa::Init()
+{
+ m_iconized =
+ m_maximizeOnShow =
+ m_closed = false;
+}
+
+bool wxTopLevelWindowCocoa::Create(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
+ wxTopLevelWindows.Append(this);
+
+ if(!CreateBase(parent,winid,pos,size,style,wxDefaultValidator,name))
+ return FALSE;
+
+ if ( parent )
+ parent->AddChild(this);
+
+ // TODO: get rect from given position/size
+ NSRect cocoaRect = NSMakeRect(100,100,200,200);
+
+ // TODO: Set flags given wxWindows style
+ unsigned int cocoaStyle = 0;
+ cocoaStyle |= NSTitledWindowMask;
+ cocoaStyle |= NSClosableWindowMask;
+ cocoaStyle |= NSMiniaturizableWindowMask;
+ cocoaStyle |= NSResizableWindowMask;
+
+ m_cocoaNSWindow = NULL;
+ m_cocoaNSView = NULL;
+ SetNSWindow([[NSWindow alloc] initWithContentRect:cocoaRect styleMask:cocoaStyle backing:NSBackingStoreBuffered defer:NO]);
+ // NOTE: SetNSWindow has retained the Cocoa object for this object.
+ // Because we do not release on close, the following release matches the
+ // above alloc and thus the retain count will be 1.
+ [m_cocoaNSWindow release];
+
+ return TRUE;
+}
+
+wxTopLevelWindowCocoa::~wxTopLevelWindowCocoa()
+{
+ SetNSWindow(NULL);
+}
+
+// ----------------------------------------------------------------------------
+// wxTopLevelWindowCocoa Cocoa Specifics
+// ----------------------------------------------------------------------------
+
+void wxTopLevelWindowCocoa::SetNSWindow(WX_NSWindow cocoaNSWindow)
+{
+ bool need_debug = cocoaNSWindow || m_cocoaNSWindow;
+ if(need_debug) wxLogDebug("wxTopLevelWindowCocoa=%p::SetNSWindow [m_cocoaNSWindow=%p retainCount]=%d",this,m_cocoaNSWindow,[m_cocoaNSWindow retainCount]);
+ if(m_cocoaNSWindow)
+ DisassociateNSWindow(m_cocoaNSWindow);
+ [cocoaNSWindow retain];
+ [m_cocoaNSWindow release];
+ m_cocoaNSWindow = cocoaNSWindow;
+ if(m_cocoaNSWindow)
+ SetNSView([m_cocoaNSWindow contentView]);
+ else
+ SetNSView(NULL);
+ if(m_cocoaNSWindow)
+ AssociateNSWindow(m_cocoaNSWindow);
+ if(need_debug) wxLogDebug("wxTopLevelWindowCocoa=%p::SetNSWindow [cocoaNSWindow=%p retainCount]=%d",this,cocoaNSWindow,[cocoaNSWindow retainCount]);
+}
+
+void wxTopLevelWindowCocoa::Cocoa_wxMenuItemAction(wxMenuItem& item)
+{
+}
+
+void wxTopLevelWindowCocoa::Cocoa_close(void)
+{
+ m_closed = true;
+ Destroy();
+ /* Be SURE that idle events get ran. If the window was not active when
+ it was closed, then there will be no more events to trigger this and
+ therefore it must be done here */
+ wxTheApp->CocoaInstallRequestedIdleHandler();
+}
+
+bool wxTopLevelWindowCocoa::Cocoa_windowShouldClose()
+{
+ return wxWindowBase::Close(false);
+}
+
+// ----------------------------------------------------------------------------
+// wxTopLevelWindowCocoa maximize/minimize
+// ----------------------------------------------------------------------------
+
+void wxTopLevelWindowCocoa::Maximize(bool maximize)
+{
+}
+
+bool wxTopLevelWindowCocoa::IsMaximized() const
+{
+ return false ;
+}
+
+void wxTopLevelWindowCocoa::Iconize(bool iconize)
+{
+}
+
+bool wxTopLevelWindowCocoa::IsIconized() const
+{
+ return FALSE;
+}
+
+void wxTopLevelWindowCocoa::Restore()
+{
+}
+
+bool wxTopLevelWindowCocoa::Show(bool show)
+{
+ if(show)
+ [m_cocoaNSWindow makeKeyAndOrderFront:m_cocoaNSWindow];
+ else
+ [m_cocoaNSWindow orderOut:m_cocoaNSWindow];
+ return true;
+}
+
+bool wxTopLevelWindowCocoa::Close(bool force)
+{
+ if(force)
+ return wxWindowBase::Close(force);
+ // performClose will fake the user clicking the close button which
+ // will invoke windowShouldClose which will call the base class version
+ // of Close() which will NOT Destroy() the window (see below) but
+ // if closing is not stopped, then performClose will go ahead and
+ // close the window which will invoke Cocoa_close() setting m_closed
+ // to true and Destroy()ing the window.
+ [m_cocoaNSWindow performClose:m_cocoaNSWindow];
+ return m_closed;
+}
+
+void wxTopLevelWindowCocoa::OnCloseWindow(wxCloseEvent& event)
+{
+ // If the event was forced, close the window which will Destroy() it
+ if(!event.CanVeto())
+ [m_cocoaNSWindow close];
+ // if the event was not forced, it's probably because the user clicked
+ // the close button, or Close(false) was called which (see above) is
+ // redirected to performClose and thus Cocoa itself will close the window
+}
+
+// ----------------------------------------------------------------------------
+// wxTopLevelWindowCocoa misc
+// ----------------------------------------------------------------------------
+
+bool wxTopLevelWindowCocoa::ShowFullScreen(bool show, long style)
+{
+ return FALSE;
+}
+
+bool wxTopLevelWindowCocoa::IsFullScreen() const
+{
+ return FALSE;
+}
+
+void wxTopLevelWindowCocoa::DoMoveWindow(int x, int y, int width, int height)
+{
+ wxLogDebug("wxTopLevelWindow=%p::DoMoveWindow(%d,%d,%d,%d)",this,x,y,width,height);
+
+ NSRect cocoaRect = NSMakeRect(x,y,width,height);
+ [m_cocoaNSWindow setFrame: cocoaRect display:NO];
+}
+
+void wxTopLevelWindowCocoa::DoGetSize(int *w, int *h) const
+{
+ NSRect cocoaRect = [m_cocoaNSWindow frame];
+ if(w)
+ *w=(int)cocoaRect.size.width;
+ if(h)
+ *h=(int)cocoaRect.size.height;
+ wxLogDebug("wxTopLevelWindow=%p::DoGetSize = (%d,%d)",this,(int)cocoaRect.size.width,(int)cocoaRect.size.height);
+}
+
+void wxTopLevelWindowCocoa::DoGetPosition(int *x, int *y) const
+{
+ NSRect cocoaRect = [m_cocoaNSWindow frame];
+ if(x)
+ *x=(int)cocoaRect.origin.x;
+ if(y)
+ *y=(int)cocoaRect.origin.y;
+ wxLogDebug("wxTopLevelWindow=%p::DoGetPosition = (%d,%d)",this,(int)cocoaRect.origin.x,(int)cocoaRect.origin.y);
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/cocoa/window.mm
+// Purpose: wxWindowCocoa
+// Author: David Elliott
+// Modified by:
+// Created: 2002/12/26
+// RCS-ID: $Id:
+// Copyright: (c) 2002 David Elliott
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/window.h"
+#include "wx/log.h"
+
+#import <Appkit/NSView.h>
+
+// normally the base classes aren't included, but wxWindow is special
+#ifdef __WXUNIVERSAL__
+IMPLEMENT_ABSTRACT_CLASS(wxWindowCocoa, wxWindowBase)
+#else
+IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
+#endif
+
+BEGIN_EVENT_TABLE(wxWindowCocoa, wxWindowBase)
+END_EVENT_TABLE()
+
+// Constructor
+void wxWindowCocoa::Init()
+{
+ InitBase();
+
+ m_cocoaNSView = NULL;
+ m_dummyNSView = NULL;
+ m_isBeingDeleted = FALSE;
+}
+
+// Constructor
+bool wxWindow::Create(wxWindow *parent, wxWindowID winid,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
+ if(!CreateBase(parent,winid,pos,size,style,wxDefaultValidator,name))
+ return false;
+
+ // TODO: create the window
+ NSRect cocoaRect = NSMakeRect(10,10,20,20);
+ m_cocoaNSView = NULL;
+ SetNSView([[NSView alloc] initWithFrame: cocoaRect]);
+ [m_cocoaNSView release];
+
+ if (m_parent)
+ {
+ m_parent->AddChild(this);
+ m_parent->CocoaAddChild(this);
+ }
+
+ return TRUE;
+}
+
+// Destructor
+wxWindow::~wxWindow()
+{
+ DestroyChildren();
+
+ if(m_parent)
+ m_parent->RemoveChild(this);
+
+ CocoaRemoveFromParent();
+ SetNSView(NULL);
+}
+
+void wxWindowCocoa::CocoaAddChild(wxWindowCocoa *child)
+{
+ [child->m_cocoaNSView retain];
+ // NOTE: addSubView takes ownership of, but does not retain the subview
+ // Upon a removeFromView or closing the super view, the child WILL be
+ // released!!! I think the idea here is that normally you would alloc
+ // the subview and add it to the superview and this way you don't have
+ // to release what you just alloced. Unfortunately, that doesn't
+ // make sense for wxCocoa, so we do this instead.
+ [m_cocoaNSView addSubview: child->m_cocoaNSView];
+ wxASSERT(!child->m_dummyNSView);
+ child->m_isShown = true;
+}
+
+void wxWindowCocoa::CocoaRemoveFromParent(void)
+{
+ wxASSERT(m_cocoaNSView);
+ if(m_dummyNSView)
+ {
+ // balances the alloc
+ [m_dummyNSView removeFromSuperview];
+ // But since we also retained it ourselves
+ [m_dummyNSView release];
+ m_dummyNSView = nil;
+ // m_cocoaNSView has of course already been removed by virtue of
+ // replaceSubview: m_cocoaNSView with: m_dummyNSView
+ }
+ else
+ [m_cocoaNSView removeFromSuperview];
+}
+
+void wxWindowCocoa::SetNSView(WX_NSView cocoaNSView)
+{
+ bool need_debug = cocoaNSView || m_cocoaNSView;
+ if(need_debug) wxLogDebug("wxWindowCocoa=%p::SetNSView [m_cocoaNSView=%p retainCount]=%d",this,m_cocoaNSView,[m_cocoaNSView retainCount]);
+ if(m_cocoaNSView)
+ DisassociateNSView(m_cocoaNSView);
+ [cocoaNSView retain];
+ [m_cocoaNSView release];
+ m_cocoaNSView = cocoaNSView;
+ if(m_cocoaNSView)
+ AssociateNSView(m_cocoaNSView);
+ if(need_debug) wxLogDebug("wxWindowCocoa=%p::SetNSView [cocoaNSView=%p retainCount]=%d",this,cocoaNSView,[cocoaNSView retainCount]);
+}
+
+void wxWindowCocoa::Cocoa_FrameChanged(void)
+{
+ wxLogDebug("Cocoa_FrameChanged");
+ wxSizeEvent event(GetSize(), m_windowId);
+ event.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(event);
+}
+
+bool wxWindow::Close(bool force)
+{
+ return false;
+}
+
+bool wxWindow::Show(bool show)
+{
+ // If the window is marked as visible, then it shouldn't have a dummy view
+ // If the window is marked hidden, then it should have a dummy view
+ wxASSERT_MSG( (m_isShown && !m_dummyNSView) || (!m_isShown && m_dummyNSView),"wxWindow: m_isShown does not agree with m_dummyNSView");
+ // Return false if there isn't a window to show or hide
+ if(!m_cocoaNSView)
+ return false;
+ // Return false if the state isn't changing
+ if( show == m_isShown )
+ return false;
+ if(show)
+ {
+ // replaceSubView releases m_dummyNSView, balancing the alloc
+ [m_cocoaNSView retain];
+ [[m_dummyNSView superview] replaceSubview:m_dummyNSView with:m_cocoaNSView];
+ // But since we also retained it ourselves
+ [m_dummyNSView release];
+ m_dummyNSView = nil;
+ return true;
+ }
+ else
+ {
+ m_dummyNSView = [[NSView alloc] initWithFrame: [m_cocoaNSView frame]];
+ [m_dummyNSView retain];
+ // NOTE: replaceSubView will cause m_cocaNSView to be released
+ [[m_cocoaNSView superview] replaceSubview:m_cocoaNSView with:m_dummyNSView];
+ // m_coocaNSView is now only retained by us
+ return true;
+ }
+}
+
+void wxWindowCocoa::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+{
+ wxLogDebug("wxWindow=%p::DoSetSizeWindow(%d,%d,%d,%d,Auto: %s%s)",this,x,y,width,height,(sizeFlags&wxSIZE_AUTO_WIDTH)?"W":".",sizeFlags&wxSIZE_AUTO_HEIGHT?"H":".");
+ int currentX, currentY;
+ int currentW, currentH;
+ DoGetPosition(¤tX, ¤tY);
+ DoGetSize(¤tW, ¤tH);
+ if((x==-1) && !(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
+ x=currentX;
+ if((y==-1) && !(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
+ y=currentY;
+
+ AdjustForParentClientOrigin(x,y,sizeFlags);
+
+ wxSize size(-1,-1);
+
+ if((width==-1)&&!(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
+ {
+ if(sizeFlags&wxSIZE_AUTO_WIDTH)
+ {
+ size=DoGetBestSize();
+ width=size.x;
+ }
+ else
+ width=currentW;
+ }
+ if((height==-1)&&!(sizeFlags&wxSIZE_ALLOW_MINUS_ONE))
+ {
+ if(sizeFlags&wxSIZE_AUTO_HEIGHT)
+ {
+ if(size.x==-1)
+ size=DoGetBestSize();
+ height=size.y;
+ }
+ else
+ height=currentH;
+ }
+ DoMoveWindow(x,y,width,height);
+}
+
+void wxWindowCocoa::DoMoveWindow(int x, int y, int width, int height)
+{
+ wxLogDebug("wxWindow=%p::DoMoveWindow(%d,%d,%d,%d)",this,x,y,width,height);
+
+ NSView *superview = [m_cocoaNSView superview];
+ wxCHECK_RET(superview,"NSView does not have a superview");
+ NSRect parentRect = [superview frame];
+
+ NSRect cocoaRect = NSMakeRect(x,parentRect.size.height-(y+height),width,height);
+ [m_cocoaNSView setFrame: cocoaRect];
+ // Also change the dummy's size
+ if(m_dummyNSView)
+ [m_dummyNSView setFrame: cocoaRect];
+}
+
+// Get total size
+void wxWindow::DoGetSize(int *w, int *h) const
+{
+ NSRect cocoaRect = [m_cocoaNSView frame];
+ if(w)
+ *w=(int)cocoaRect.size.width;
+ if(h)
+ *h=(int)cocoaRect.size.height;
+ wxLogDebug("wxWindow=%p::DoGetSize = (%d,%d)",this,(int)cocoaRect.size.width,(int)cocoaRect.size.height);
+}
+
+void wxWindow::DoGetPosition(int *x, int *y) const
+{
+ NSView *superview = [m_cocoaNSView superview];
+ wxCHECK_RET(superview,"NSView does not have a superview");
+ NSRect parentRect = [superview frame];
+
+ NSRect cocoaRect = [m_cocoaNSView frame];
+ if(x)
+ *x=(int)cocoaRect.origin.x;
+ if(y)
+ *y=(int)(parentRect.size.height-(cocoaRect.origin.y+cocoaRect.size.height));
+ wxLogDebug("wxWindow=%p::DoGetPosition = (%d,%d)",this,(int)cocoaRect.origin.x,(int)cocoaRect.origin.y);
+}
+
+WXWidget wxWindow::GetHandle() const
+{
+ return m_cocoaNSView;
+}
+
+void wxWindow::SetFocus()
+{
+ // TODO
+}
+
+void wxWindow::DoCaptureMouse()
+{
+ // TODO
+}
+
+void wxWindow::DoReleaseMouse()
+{
+ // TODO
+}
+
+void wxWindow::DoScreenToClient(int *x, int *y) const
+{
+ // TODO
+}
+
+void wxWindow::DoClientToScreen(int *x, int *y) const
+{
+ // TODO
+}
+
+// Get size *available for subwindows* i.e. excluding menu bar etc.
+void wxWindow::DoGetClientSize(int *x, int *y) const
+{
+ wxLogDebug("DoGetClientSize:");
+ wxWindowCocoa::DoGetSize(x,y);
+ // TODO: Actually account for menubar, borders, etc...
+}
+
+void wxWindow::DoSetClientSize(int width, int height)
+{
+ wxLogDebug("DoSetClientSize=(%d,%d)",width,height);
+ // TODO
+}
+
+int wxWindow::GetCharHeight() const
+{
+ // TODO
+ return 0;
+}
+
+int wxWindow::GetCharWidth() const
+{
+ // TODO
+ return 0;
+}
+
+void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
+ int *descent, int *externalLeading, const wxFont *theFont) const
+{
+ // TODO
+}
+
+void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
+{
+ // TODO
+}
+
+// Coordinates relative to the window
+void wxWindow::WarpPointer (int x_pos, int y_pos)
+{
+ // TODO
+}
+
+int wxWindow::GetScrollPos(int orient) const
+{
+ // TODO
+ return 0;
+}
+
+// This now returns the whole range, not just the number
+// of positions that we can scroll.
+int wxWindow::GetScrollRange(int orient) const
+{
+ // TODO
+ return 0;
+}
+
+int wxWindow::GetScrollThumb(int orient) const
+{
+ // TODO
+ return 0;
+}
+
+void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
+{
+ // TODO
+}
+
+// New function that will replace some of the above.
+void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
+ int range, bool refresh)
+{
+ // TODO
+}
+
+// Does a physical scroll
+void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
+{
+ // TODO
+}
+
+bool wxWindow::SetFont(const wxFont& font)
+{
+ // TODO
+ return TRUE;
+}
+
+void wxWindow::Clear()
+{
+ // TODO
+}
+
+// Raise the window to the top of the Z order
+void wxWindow::Raise()
+{
+ // TODO
+}
+
+// Lower the window to the bottom of the Z order
+void wxWindow::Lower()
+{
+ // TODO
+}
+
+bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
+{
+ return FALSE;
+}
+
+// Get the window with the focus
+wxWindow *wxWindowBase::FindFocus()
+{
+ // TODO
+ return NULL;
+}
+
+/* static */ wxWindow *wxWindowBase::GetCapture()
+{
+ // TODO
+ return NULL;
+}
+
+wxWindow *wxGetActiveWindow()
+{
+ // TODO
+ return NULL;
+}
+
projects / wxWidgets.git / commitdiff
