*** empty log message ***

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3861 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/font.h

@@ -195,10 +195,7 @@ private:
 // macros
 // ----------------------------------------------------------------------------
 
-#if !defined(__VISAGECPP__)
-// VZ: this is ugly (FIXME)
 #define M_FONTDATA GetFontData()
-#endif
 
 #endif
     // _WX_FONT_H_BASE_

include/wx/fontdlg.h

@@ -18,9 +18,7 @@
 #   define wxFontDialog wxGenericFontDialog
 #   define sm_classwxFontDialog sm_classwxGenericFontDialog
 #elif defined(__WXPM__)
-#include "wx/generic/fontdlgg.h"
+#include "wx/os2/fontdlg.h"
-#   define wxFontDialog wxGenericFontDialog
-#   define sm_classwxFontDialog sm_classwxGenericFontDialog
 #elif defined(__WXSTUBS__)
 #include "wx/generic/fontdlgg.h"
 #   define wxFontDialog wxGenericFontDialog

include/wx/os2/font.h

@@ -1,88 +1,96 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        font.h
 // Purpose:     wxFont class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/06/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
+// Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_FONT_H_
 #define _WX_FONT_H_
 
-#ifdef __GNUG__
-#pragma interface "font.h"
-#endif
-
 #include "wx/gdiobj.h"
 
-class WXDLLEXPORT wxFont;
+WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
 
-class WXDLLEXPORT wxFontRefData: public wxGDIRefData
+// ----------------------------------------------------------------------------
+// wxFont
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxFont : public wxFontBase
 {
-    friend class WXDLLEXPORT wxFont;
 public:
-    wxFontRefData();
+    // ctors and such
-    wxFontRefData(const wxFontRefData& data);
+    wxFont() { Init(); }
-    ~wxFontRefData();
+    wxFont(const wxFont& font) { Init(); Ref(font); }
-protected:
+
-  int           m_pointSize;
+    wxFont(int size,
-  int           m_family;
+           int family,
-  int           m_style;
+           int style,
-  int           m_weight;
+           int weight,
-  bool          m_underlined;
+           bool underlined = FALSE,
-  wxString      m_faceName;
+           const wxString& face = wxEmptyString,
-/* TODO: implementation
+           wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
-  WXHFONT       m_hFont;
+    {
+        Init();
+
+        (void)Create(size, family, style, weight, underlined, face, encoding);
+    }
+
+    bool Create(int size,
+                int family,
+                int style,
+                int weight,
+                bool underlined = FALSE,
+                const wxString& face = wxEmptyString,
+                wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
+
+    virtual ~wxFont();
+
+    // assignment
+    wxFont& operator=(const wxFont& font);
+
+    // implement base class pure virtuals
+    virtual int GetPointSize() const;
+    virtual int GetFamily() const;
+    virtual int GetStyle() const;
+    virtual int GetWeight() const;
+    virtual bool GetUnderlined() const;
+    virtual wxString GetFaceName() const;
+    virtual wxFontEncoding GetEncoding() const;
+
+    virtual void SetPointSize(int pointSize);
+    virtual void SetFamily(int family);
+    virtual void SetStyle(int style);
+    virtual void SetWeight(int weight);
+    virtual void SetFaceName(const wxString& faceName);
+    virtual void SetUnderlined(bool underlined);
+    virtual void SetEncoding(wxFontEncoding encoding);
+
+    // implementation only from now on
+    // -------------------------------
+
+    int GetFontId() const;
+    virtual bool IsFree() const;
+    virtual bool RealizeResource();
+    virtual WXHANDLE GetResourceHandle();
+    virtual bool FreeResource(bool force = FALSE);
+    /*
+       virtual bool UseResource();
+       virtual bool ReleaseResource();
      */
-};
 
-#define M_FONTDATA ((wxFontRefData *)m_refData)
-
-WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
-
-// Font
-class WXDLLEXPORT wxFont: public wxGDIObject
-{
-  DECLARE_DYNAMIC_CLASS(wxFont)
-public:
-  wxFont();
-  wxFont(int pointSize, int family, int style, int weight, bool underlined = FALSE, const wxString& faceName = wxEmptyString);
-  inline wxFont(const wxFont& font) { Ref(font); }
-
-  ~wxFont();
-
-  bool Create(int pointSize, int family, int style, int weight, bool underlined = FALSE, const wxString& faceName = wxEmptyString);
-
-  virtual bool Ok() const { return (m_refData != NULL) ; }
-
-  inline int GetPointSize() const { return M_FONTDATA->m_pointSize; }
-  inline int GetFamily() const { return M_FONTDATA->m_family; }
-  inline int GetStyle() const { return M_FONTDATA->m_style; }
-  inline int GetWeight() const { return M_FONTDATA->m_weight; }
-  wxString GetFamilyString() const ;
-  wxString GetFaceName() const ;
-  wxString GetStyleString() const ;
-  wxString GetWeightString() const ;
-  inline bool GetUnderlined() const { return M_FONTDATA->m_underlined; }
-
-  void SetPointSize(int pointSize);
-  void SetFamily(int family);
-  void SetStyle(int style);
-  void SetWeight(int weight);
-  void SetFaceName(const wxString& faceName);
-  void SetUnderlined(bool underlined);
-
-  inline wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; }
-  inline bool operator == (const wxFont& font) { return m_refData == font.m_refData; }
-  inline bool operator != (const wxFont& font) { return m_refData != font.m_refData; }
-
-  // Implementation
 protected:
-  bool RealizeResource();
+    // common part of all ctors
+    void Init();
+
     void Unshare();
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxFont)
 };
 
 #endif

include/wx/os2/fontdlg.h

@@ -2,21 +2,17 @@
 // Name:        fontdlg.h
 // Purpose:     wxFontDialog class. Use generic version if no
 //              platform-specific implementation.
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/06/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
+// Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_FONTDLG_H_
 #define _WX_FONTDLG_H_
 
-#ifdef __GNUG__
-#pragma interface "fontdlg.h"
-#endif
-
 #include "wx/dialog.h"
 #include "wx/cmndata.h"
 

include/wx/os2/frame.h

@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        frame.h
 // Purpose:     wxFrame class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/06/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
+// Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -18,11 +18,12 @@
 
 #include "wx/window.h"
 #include "wx/toolbar.h"
-#include "wx/accel.h"
+#include "wx/os2/accel.h"
 #include "wx/icon.h"
 
-WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr;
+WXDLLEXPORT_DATA(extern const wxChar*) wxFrameNameStr;
-WXDLLEXPORT_DATA(extern const char*) wxToolBarNameStr;
+WXDLLEXPORT_DATA(extern const wxChar*) wxToolBarNameStr;
+WXDLLEXPORT_DATA(extern const wxChar*) wxStatusLineNameStr;
 
 class WXDLLEXPORT wxMenuBar;
 class WXDLLEXPORT wxStatusBar;
@@ -33,37 +34,37 @@ class WXDLLEXPORT wxFrame: public wxWindow {
 
 public:
     wxFrame();
-  inline wxFrame(wxWindow *parent,
+    inline wxFrame( wxWindow*       parent
-           wxWindowID id,
+                   ,wxWindowID      id
-           const wxString& title,
+                   ,const wxString& title
-           const wxPoint& pos = wxDefaultPosition,
+                   ,const wxPoint&  pos = wxDefaultPosition
-           const wxSize& size = wxDefaultSize,
+                   ,const wxSize&   size = wxDefaultSize
-           long style = wxDEFAULT_FRAME_STYLE,
+                   ,long            style = wxDEFAULT_FRAME_STYLE
-           const wxString& name = wxFrameNameStr)
+                   ,const wxString& name = wxFrameNameStr
+                  )
     {
         Create(parent, id, title, pos, size, style, name);
     }
 
     ~wxFrame();
 
-  bool Create(wxWindow *parent,
+    bool Create( wxWindow*       parent
-           wxWindowID id,
+                ,wxWindowID      id
-           const wxString& title,
+                ,const wxString& title
-           const wxPoint& pos = wxDefaultPosition,
+                ,const wxPoint&  pos = wxDefaultPosition
-           const wxSize& size = wxDefaultSize,
+                ,const wxSize&   size = wxDefaultSize
-           long style = wxDEFAULT_FRAME_STYLE,
+                ,long            style = wxDEFAULT_FRAME_STYLE
-           const wxString& name = wxFrameNameStr);
+                ,const wxString& name = wxFrameNameStr
+               );
 
     virtual bool Destroy();
+
+    virtual void ClientToScreen(int *x, int *y) const;
+    virtual void ScreenToClient(int *x, int *y) const;
+
     void SetClientSize(int width, int height);
     void GetClientSize(int *width, int *height) const;
 
-  void GetSize(int *width, int *height) const ;
-  void GetPosition(int *x, int *y) const ;
-  void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
-  void ClientToScreen(int *x, int *y) const;
-  void ScreenToClient(int *x, int *y) const;
-
     void OnSize(wxSizeEvent& event);
     void OnMenuHighlight(wxMenuEvent& event);
     void OnActivate(wxActivateEvent& event);
@@ -72,38 +73,53 @@ public:
 
     bool Show(bool show);
 
+    void DetachMenuBar();
+
     // Set menu bar
     void SetMenuBar(wxMenuBar *menu_bar);
     virtual wxMenuBar *GetMenuBar() const ;
 
-  // Set title
-  void SetTitle(const wxString& title);
-  wxString GetTitle() const ;
-
-  void Centre(int direction = wxBOTH);
-
     // Call this to simulate a menu command
-  virtual void Command(int id);
+    inline bool Command(int id) { return ProcessCommand(id); }
-  virtual void ProcessCommand(int id);
+
+    // process menu command: returns TRUE if processed
+    bool ProcessCommand(int id);
+
+    // make the window modal (all other windows unresponsive)
+    virtual void MakeModal(bool modal = TRUE);
 
     // Set icon
     virtual void SetIcon(const wxIcon& icon);
 
-  // Create status line
+    // Toolbar
-  virtual wxStatusBar* CreateStatusBar(int number=1, long style = wxST_SIZEGRIP, wxWindowID id = 0,
+#if wxUSE_TOOLBAR
-    const wxString& name = "statusBar");
+    virtual wxToolBar* CreateToolBar(long style = wxNO_BORDER | wxTB_HORIZONTAL | wxTB_FLAT,
-  inline wxStatusBar *GetStatusBar() const { return m_frameStatusBar; }
+                                     wxWindowID id = -1,
-  virtual void PositionStatusBar();
+                                     const wxString& name = wxToolBarNameStr);
-  virtual wxStatusBar *OnCreateStatusBar(int number, long style, wxWindowID id,
-    const wxString& name);
 
-  // Create toolbar
-  virtual wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL, wxWindowID id = -1, const wxString& name = wxToolBarNameStr);
     virtual wxToolBar *OnCreateToolBar(long style, wxWindowID id, const wxString& name);
-  // If made known to the frame, the frame will manage it automatically.
+
-  virtual inline void SetToolBar(wxToolBar *toolbar) { m_frameToolBar = toolbar; }
+    virtual void SetToolBar(wxToolBar *toolbar) { m_frameToolBar = toolbar; }
-  virtual inline wxToolBar *GetToolBar() const { return m_frameToolBar; }
+    virtual wxToolBar *GetToolBar() const { return m_frameToolBar; }
+
     virtual void PositionToolBar();
+#endif // wxUSE_TOOLBAR
+
+#if wxUSE_STATUSBAR
+    // Status bar
+    virtual wxStatusBar* CreateStatusBar(int number = 1,
+                                         long style = wxST_SIZEGRIP,
+                                         wxWindowID id = 0,
+                                         const wxString& name = wxStatusLineNameStr);
+
+    wxStatusBar *GetStatusBar() const { return m_frameStatusBar; }
+    void SetStatusBar(wxStatusBar *statusBar) { m_frameStatusBar = statusBar; }
+
+    virtual void PositionStatusBar();
+    virtual wxStatusBar *OnCreateStatusBar(int number,
+                                           long style,
+                                           wxWindowID id,
+                                           const wxString& name);
 
     // Set status line text
     virtual void SetStatusText(const wxString& text, int number = 0);
@@ -115,22 +131,21 @@ public:
     // TODO: should this go into a wxFrameworkSettings class perhaps?
     static void UseNativeStatusBar(bool useNative) { m_useNativeStatusBar = useNative; };
     static bool UsesNativeStatusBar() { return m_useNativeStatusBar; };
-
+#endif // wxUSE_STATUSBAR
-  // Fit frame around subwindows
-  virtual void Fit();
 
     // Iconize
     virtual void Iconize(bool iconize);
 
     virtual bool IsIconized() const;
 
-  // Compatibility
+    // Is it maximized?
-  inline bool Iconized() const { return IsIconized(); }
+    virtual bool IsMaximized() const;
 
-  // Is the frame maximized?
+    // Compatibility
-  virtual bool IsMaximized(void) const ;
+    bool Iconized() const { return IsIconized(); }
 
     virtual void Maximize(bool maximize);
+    //  virtual bool LoadAccelerators(const wxString& table);
 
     // Responds to colour changes
     void OnSysColourChanged(wxSysColourChangedEvent& event);
@@ -139,19 +154,73 @@ public:
     void DoMenuUpdates();
     void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
 
-  // Checks if there is a toolbar, and returns the first free client position
+    WXHMENU GetWinMenu() const { return m_hMenu; }
+
+    // Returns the origin of client area (may be different from (0,0) if the
+    // frame has a toolbar)
     virtual wxPoint GetClientAreaOrigin() const;
 
+    // Implementation only from here
+        // event handlers
+    bool HandlePaint();
+    bool HandleSize(int x, int y, WXUINT flag);
+    bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control);
+    bool HandleMenuSelect(WXWORD nItem, WXWORD nFlags, WXHMENU hMenu);
+
+    bool OS2Create(int id, wxWindow *parent, const wxChar *wclass,
+                   wxWindow *wx_win, const wxChar *title,
+                   int x, int y, int width, int height, long style);
+
+  // tooltip management
+#if wxUSE_TOOLTIPS
+    WXHWND GetToolTipCtrl() const { return m_hwndToolTip; }
+    void SetToolTipCtrl(WXHWND hwndTT) { m_hwndToolTip = hwndTT; }
+#endif // tooltips
+
 protected:
+    // override base class virtuals
+    virtual void DoGetClientSize(int *width, int *height) const;
+    virtual void DoGetSize(int *width, int *height) const;
+    virtual void DoGetPosition(int *x, int *y) const;
+
+    virtual void DoSetClientSize(int width, int height);
+
+    // a plug in for MDI frame classes which need to do something special when
+    // the menubar is set
+    virtual void InternalSetMenuBar();
+
+    // propagate our state change to all child frames
+    void IconizeChildFrames(bool bIconize);
+
+    // we add menu bar accel processing
+    bool OS2TranslateMessage(WXMSG* pMsg);
+
+    // window proc for the frames
+    MRESULT OS2WindowProc(HWND hwnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
+
     wxMenuBar *           m_frameMenuBar;
-  wxStatusBar *         m_frameStatusBar;
     wxIcon                m_icon;
     bool                  m_iconized;
+    WXHICON               m_defaultIcon;
+
+#if wxUSE_STATUSBAR
+    wxStatusBar *         m_frameStatusBar;
+
     static bool           m_useNativeStatusBar;
+#endif // wxUSE_STATUSBAR
+
+#if wxUSE_TOOLBAR
     wxToolBar *           m_frameToolBar;
+#endif // wxUSE_TOOLBAR
+
+private:
+#if wxUSE_TOOLTIPS
+    WXHWND                m_hwndToolTip;
+#endif // tooltips
 
     DECLARE_EVENT_TABLE()
 };
 
 #endif
     // _WX_FRAME_H_
+

src/makeva.env

@@ -17,7 +17,7 @@ OS2LIBFLAGS=/NOL /NOE
 OS2LIBS=CPPOM30.lib CPPOOC3.LIB OS2386.LIB
 
 # Change this to your WXWIN directory
-WXDIR=h:\dev\Wx2\wxwindows
+WXDIR=j:\dev\Wx2\wxwindows
 
 WXSRC=$(WXDIR)\src\os2
 WXINC=$(WXDIR)\include

src/msw/frame.cpp

@@ -1061,3 +1061,4 @@ long wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 
     return rc;
 }
+

src/os2/font.cpp

@@ -1,85 +1,176 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        font.cpp
 // Purpose:     wxFont class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/06/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
+// Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
+// ============================================================================
-#pragma implementation "font.h"
+// declarations
-#endif
+// ============================================================================
 
-#include "wx/defs.h"
+// ----------------------------------------------------------------------------
-#include "wx/string.h"
+// headers
+// ----------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+    #include <stdio.h>
+    #include "wx/setup.h"
+    #include "wx/list.h"
+    #include "wx/utils.h"
+    #include "wx/app.h"
     #include "wx/font.h"
-#include "wx/gdicmn.h"
+#endif // WX_PRECOMP
+
+#include "wx/os2/private.h"
 
 #if !USE_SHARED_LIBRARIES
     IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
+
+    #if wxUSE_PORTABLE_FONTS_IN_MSW
+        IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject)
+    #endif
 #endif
 
-wxFontRefData::wxFontRefData()
+// ----------------------------------------------------------------------------
+// wxFontRefData - the internal description of the font
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxFontRefData: public wxGDIRefData
 {
-	m_style = 0;
+friend class WXDLLEXPORT wxFont;
-  	m_pointSize = 0;
+
-  	m_family = 0;
+public:
-  	m_style = 0;
+    wxFontRefData()
-  	m_weight = 0;
+    {
-  	m_underlined = 0;
+        Init(12, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE,
-  	m_faceName = "";
+             "", wxFONTENCODING_DEFAULT);
-/* TODO
-  	m_hFont = 0;
-*/
     }
 
-wxFontRefData::wxFontRefData(const wxFontRefData& data)
+    wxFontRefData(const wxFontRefData& data)
     {
-	m_style = data.m_style;
+        Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
-  	m_pointSize = data.m_pointSize;
+             data.m_underlined, data.m_faceName, data.m_encoding);
-  	m_family = data.m_family;
+
-  	m_style = data.m_style;
+        m_fontId = data.m_fontId;
-  	m_weight = data.m_weight;
+    }
-  	m_underlined = data.m_underlined;
+
-  	m_faceName = data.m_faceName;
+    wxFontRefData(int size,
-/* TODO
+                  int family,
+                  int style,
+                  int weight,
+                  bool underlined,
+                  const wxString& faceName,
+                  wxFontEncoding encoding)
+    {
+        Init(size, family, style, weight, underlined, faceName, encoding);
+    }
+
+    virtual ~wxFontRefData();
+
+protected:
+    // common part of all ctors
+    void Init(int size,
+              int family,
+              int style,
+              int weight,
+              bool underlined,
+              const wxString& faceName,
+              wxFontEncoding encoding);
+
+    // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE
+    // DELETED by destructor
+    bool          m_temporary;
+
+    int           m_fontId;
+
+    // font characterstics
+    int           m_pointSize;
+    int           m_family;
+    int           m_style;
+    int           m_weight;
+    bool          m_underlined;
+    wxString      m_faceName;
+    wxFontEncoding m_encoding;
+
+    // Windows font handle
+    WXHFONT       m_hFont;
+};
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxFontRefData
+// ----------------------------------------------------------------------------
+
+void wxFontRefData::Init(int pointSize,
+                         int family,
+                         int style,
+                         int weight,
+                         bool underlined,
+                         const wxString& faceName,
+                         wxFontEncoding encoding)
+{
+    m_style = style;
+    m_pointSize = pointSize;
+    m_family = family;
+    m_style = style;
+    m_weight = weight;
+    m_underlined = underlined;
+    m_faceName = faceName;
+    m_encoding = encoding;
+
+    m_fontId = 0;
+    m_temporary = FALSE;
+
     m_hFont = 0;
-*/
 }
 
 wxFontRefData::~wxFontRefData()
 {
-    // TODO: delete font data
+// TODO:
+//    if ( m_hFont )
+//    {
+//        if ( !::DeleteObject((HFONT) m_hFont) )
+//        {
+//            wxLogLastError("DeleteObject(font)");
+//        }
+//    }
 }
 
-wxFont::wxFont()
+// ----------------------------------------------------------------------------
+// wxFont
+// ----------------------------------------------------------------------------
+
+void wxFont::Init()
 {
     if ( wxTheFontList )
         wxTheFontList->Append(this);
 }
 
-wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
+/* Constructor for a font. Note that the real construction is done
-{
+ * in wxDC::SetFont, when information is available about scaling etc.
-    Create(pointSize, family, style, weight, underlined, faceName);
+ */
-
+bool wxFont::Create(int pointSize,
-    if ( wxTheFontList )
+                    int family,
-        wxTheFontList->Append(this);
+                    int style,
-}
+                    int weight,
-
+                    bool underlined,
-bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
+                    const wxString& faceName,
+                    wxFontEncoding encoding)
 {
     UnRef();
-    m_refData = new wxFontRefData;
+    m_refData = new wxFontRefData(pointSize, family, style, weight,
-
+                                  underlined, faceName, encoding);
-    M_FONTDATA->m_family = family;
-    M_FONTDATA->m_style = style;
-    M_FONTDATA->m_weight = weight;
-    M_FONTDATA->m_pointSize = pointSize;
-    M_FONTDATA->m_underlined = underlined;
-    M_FONTDATA->m_faceName = faceName;
 
     RealizeResource();
 
@@ -92,12 +183,269 @@ wxFont::~wxFont()
         wxTheFontList->DeleteObject(this);
 }
 
+// ----------------------------------------------------------------------------
+// real implementation
+// ----------------------------------------------------------------------------
+
 bool wxFont::RealizeResource()
 {
-    // TODO: create the font (if there is a native font object)
+    if ( GetResourceHandle() )
+    {
+        // VZ: the old code returned FALSE in this case, but it doesn't seem
+        //     to make sense because the font _was_ created
+        wxLogDebug(T("Calling wxFont::RealizeResource() twice"));
+
+       return TRUE;
+    }
+
+    int ff_family = 0;
+    wxString ff_face;
+
+// OS/2 combines the family with styles to give a facename
+
+    switch ( M_FONTDATA->m_family )
+    {
+        case wxSCRIPT:
+//            ff_family = FF_SCRIPT ;
+            ff_face = T("Script") ;
+            break ;
+
+        case wxDECORATIVE:
+//            ff_family = FF_DECORATIVE;
+            break;
+
+        case wxROMAN:
+//            ff_family = FF_ROMAN;
+            ff_face = T("Times New Roman") ;
+            break;
+
+        case wxTELETYPE:
+        case wxMODERN:
+//            ff_family = FF_MODERN;
+            ff_face = T("Courier New") ;
+            break;
+
+        case wxSWISS:
+//            ff_family = FF_SWISS;
+            ff_face = T("Arial") ;
+            break;
+
+        case wxDEFAULT:
+        default:
+//            ff_family = FF_SWISS;
+            ff_face = T("Arial") ;
+    }
+
+    BYTE ff_italic;
+    switch ( M_FONTDATA->m_style )
+    {
+        case wxITALIC:
+        case wxSLANT:
+            ff_italic = 1;
+            break;
+
+        default:
+            wxFAIL_MSG(T("unknown font slant"));
+            // fall through
+
+        case wxNORMAL:
+            ff_italic = 0;
+    }
+
+    int ff_weight = 0;
+    switch ( M_FONTDATA->m_weight )
+    {
+        default:
+            wxFAIL_MSG(T("unknown font weight"));
+            // fall through
+
+        case wxNORMAL:
+//            ff_weight = FW_NORMAL;
+            break;
+
+        case wxLIGHT:
+//            ff_weight = FW_LIGHT;
+            break;
+
+        case wxBOLD:
+//            ff_weight = FW_BOLD;
+            break;
+    }
+
+    const wxChar* pzFace;
+    if ( M_FONTDATA->m_faceName.IsEmpty() )
+        pzFace = ff_face;
+    else
+        pzFace = M_FONTDATA->m_faceName ;
+
+#if 0
+    /* Always calculate fonts using the screen DC (is this the best strategy?)
+     * There may be confusion if a font is selected into a printer
+     * DC (say), because the height will be calculated very differently.
+     */
+    // What sort of display is it?
+    int technology = ::GetDeviceCaps(dc, TECHNOLOGY);
+
+    int nHeight;
+
+    if (technology != DT_RASDISPLAY && technology != DT_RASPRINTER)
+    {
+        // Have to get screen DC Caps, because a metafile will return 0.
+        HDC dc2 = ::GetDC(NULL);
+        nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc2, LOGPIXELSY)/72;
+        ::ReleaseDC(NULL, dc2);
+    }
+    else
+    {
+        nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc, LOGPIXELSY)/72;
+    }
+#endif // 0
+
+#if 0
+    // Have to get screen DC Caps, because a metafile will return 0.
+    HDC dc2 = ::GetDC(NULL);
+    ppInch = ::GetDeviceCaps(dc2, LOGPIXELSY);
+    ::ReleaseDC(NULL, dc2);
+#endif // 0
+
+    // New behaviour: apparently ppInch varies according to Large/Small Fonts
+    // setting in Windows. This messes up fonts. So, set ppInch to a constant
+    // 96 dpi.
+    static const int ppInch = 96;
+
+#if wxFONT_SIZE_COMPATIBILITY
+    // Incorrect, but compatible with old wxWindows behaviour
+    int nHeight = (M_FONTDATA->m_pointSize*ppInch/72);
+#else
+    // Correct for Windows compatibility
+    int nHeight = - (M_FONTDATA->m_pointSize*ppInch/72);
+#endif
+
+    BYTE ff_underline = M_FONTDATA->m_underlined;
+
+    wxFontEncoding encoding = M_FONTDATA->m_encoding;
+    if ( encoding == wxFONTENCODING_DEFAULT )
+    {
+        encoding = wxFont::GetDefaultEncoding();
+    }
+
+    DWORD charset;
+    switch ( encoding )
+    {
+        case wxFONTENCODING_ISO8859_1:
+        case wxFONTENCODING_ISO8859_15:
+        case wxFONTENCODING_CP1250:
+//            charset = ANSI_CHARSET;
+            break;
+
+        case wxFONTENCODING_ISO8859_2:
+        case wxFONTENCODING_CP1252:
+//            charset = EASTEUROPE_CHARSET;
+            break;
+
+        case wxFONTENCODING_ISO8859_4:
+        case wxFONTENCODING_ISO8859_10:
+//            charset = BALTIC_CHARSET;
+            break;
+
+        case wxFONTENCODING_ISO8859_5:
+        case wxFONTENCODING_CP1251:
+//            charset = RUSSIAN_CHARSET;
+            break;
+
+        case wxFONTENCODING_ISO8859_6:
+//            charset = ARABIC_CHARSET;
+            break;
+
+        case wxFONTENCODING_ISO8859_7:
+//            charset = GREEK_CHARSET;
+            break;
+
+        case wxFONTENCODING_ISO8859_8:
+//            charset = HEBREW_CHARSET;
+            break;
+
+        case wxFONTENCODING_ISO8859_9:
+//            charset = TURKISH_CHARSET;
+            break;
+
+        case wxFONTENCODING_ISO8859_11:
+//            charset = THAI_CHARSET;
+            break;
+
+        case wxFONTENCODING_CP437:
+//            charset = OEM_CHARSET;
+            break;
+
+        default:
+            wxFAIL_MSG(T("unsupported encoding"));
+            // fall through
+
+        case wxFONTENCODING_SYSTEM:
+//            charset = ANSI_CHARSET;
+            break;
+    }
+
+// TODO:
+WXHFONT hFont;
+//    HFONT hFont = ::CreateFont
+//                  (
+//                   nHeight,             // height
+//                   0,                   // width (choose best)
+//                   0,                   // escapement
+//                   0,                   // orientation
+//                   ff_weight,           // weight
+//                   ff_italic,           // italic?
+//                   ff_underline,        // underlined?
+//                   0,                   // strikeout?
+//                   charset,             // charset
+//                   OUT_DEFAULT_PRECIS,  // precision
+//                   CLIP_DEFAULT_PRECIS, // clip precision
+//                   PROOF_QUALITY,       // quality of match
+//                   DEFAULT_PITCH |      // fixed or variable
+//                   ff_family,           // family id
+//                   pzFace               // face name
+//                  );
+
+    M_FONTDATA->m_hFont = (WXHFONT)hFont;
+    if ( !hFont )
+    {
+        wxLogLastError("CreateFont");
+    }
+
+    return hFont != 0;
+}
+
+bool wxFont::FreeResource(bool force)
+{
+    if ( GetResourceHandle() )
+    {
+// TODO:
+//        if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) )
+//        {
+//            wxLogLastError("DeleteObject(font)");
+//        }
+
+        M_FONTDATA->m_hFont = 0;
+
+        return TRUE;
+    }
     return FALSE;
 }
 
+WXHANDLE wxFont::GetResourceHandle()
+{
+    if ( !M_FONTDATA )
+        return 0;
+    else
+        return (WXHANDLE)M_FONTDATA->m_hFont ;
+}
+
+bool wxFont::IsFree() const
+{
+    return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
+}
+
 void wxFont::Unshare()
 {
     // Don't change shared data
@@ -107,12 +455,16 @@ void wxFont::Unshare()
     }
     else
     {
-		wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
+        wxFontRefData* ref = new wxFontRefData(*M_FONTDATA);
         UnRef();
         m_refData = ref;
     }
 }
 
+// ----------------------------------------------------------------------------
+// change font attribute: we recreate font when doing it
+// ----------------------------------------------------------------------------
+
 void wxFont::SetPointSize(int pointSize)
 {
     Unshare();
@@ -167,78 +519,59 @@ void wxFont::SetUnderlined(bool underlined)
     RealizeResource();
 }
 
-wxString wxFont::GetFamilyString() const
+void wxFont::SetEncoding(wxFontEncoding encoding)
 {
-  wxString fam("");
+    Unshare();
-  switch (GetFamily())
+
-  {
+    M_FONTDATA->m_encoding = encoding;
-    case wxDECORATIVE:
+
-      fam = "wxDECORATIVE";
+    RealizeResource();
-      break;
+}
-    case wxROMAN:
+
-      fam = "wxROMAN";
+// ----------------------------------------------------------------------------
-      break;
+// accessors
-    case wxSCRIPT:
+// ----------------------------------------------------------------------------
-      fam = "wxSCRIPT";
+
-      break;
+int wxFont::GetPointSize() const
-    case wxSWISS:
+{
-      fam = "wxSWISS";
+    return M_FONTDATA->m_pointSize;
-      break;
+}
-    case wxMODERN:
+
-      fam = "wxMODERN";
+int wxFont::GetFamily() const
-      break;
+{
-    case wxTELETYPE:
+    return M_FONTDATA->m_family;
-      fam = "wxTELETYPE";
+}
-      break;
+
-    default:
+int wxFont::GetFontId() const
-      fam = "wxDEFAULT";
+{
-      break;
+    return M_FONTDATA->m_fontId;
-  }
+}
-  return fam;
+
+int wxFont::GetStyle() const
+{
+    return M_FONTDATA->m_style;
+}
+
+int wxFont::GetWeight() const
+{
+    return M_FONTDATA->m_weight;
+}
+
+bool wxFont::GetUnderlined() const
+{
+    return M_FONTDATA->m_underlined;
 }
 
-/* New font system */
 wxString wxFont::GetFaceName() const
 {
-    wxString str("");
+    wxString str;
     if ( M_FONTDATA )
         str = M_FONTDATA->m_faceName ;
     return str;
 }
 
-wxString wxFont::GetStyleString() const
+wxFontEncoding wxFont::GetEncoding() const
 {
-    wxString styl("");
+    return M_FONTDATA->m_encoding;
-    switch (GetStyle())
-    {
-        case wxITALIC:
-            styl = "wxITALIC";
-            break;
-        case wxSLANT:
-            styl = "wxSLANT";
-            break;
-        default:
-            styl = "wxNORMAL";
-            break;
-    }
-    return styl;
-}
-
-wxString wxFont::GetWeightString() const
-{
-    wxString w("");
-    switch (GetWeight())
-    {
-        case wxBOLD:
-            w = "wxBOLD";
-            break;
-        case wxLIGHT:
-            w = "wxLIGHT";
-            break;
-        default:
-            w = "wxNORMAL";
-            break;
-    }
-    return w;
 }
 

src/os2/fontdlg.cpp

@@ -2,21 +2,39 @@
 // Name:        fontdlg.cpp
 // Purpose:     wxFontDialog class. NOTE: you can use the generic class
 //              if you wish, instead of implementing this.
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/06/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
+// Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
+// For compilers that support precompilation, includes "wx.h".
-#pragma implementation "fontdlg.h"
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+#include <stdio.h>
+#include "wx/defs.h"
+#include "wx/utils.h"
+#include "wx/dialog.h"
 #endif
 
-#include "wx/stubs/fontdlg.h"
+#include "wx/fontdlg.h"
+
+#define INCL_PM
+#include <os2.h>
+
+#include "wx/os2/private.h"
 #include "wx/cmndata.h"
 
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define wxDIALOG_DEFAULT_X 300
+#define wxDIALOG_DEFAULT_Y 300
+
 #if !USE_SHARED_LIBRARY
 IMPLEMENT_DYNAMIC_CLASS(wxFontDialog, wxDialog)
 #endif
@@ -24,7 +42,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxFontDialog, wxDialog)
 /*
  * wxFontDialog
  */
-
 wxFontDialog::wxFontDialog()
 {
     m_dialogParent = NULL;
@@ -41,9 +58,6 @@ bool wxFontDialog::Create(wxWindow *parent, wxFontData *data)
 
     if (data)
         m_fontData = *data;
-
-    // TODO: you may need to do dialog creation here, unless it's
-    // done in ShowModal.
     return TRUE;
 }
 

src/os2/makefile.va

@@ -308,6 +308,8 @@ OS2OBJS = \
   ..\os2\$D\dirdlg.obj \
   ..\os2\$D\dnd.obj \
   ..\os2\$D\filedlg.obj \
+  ..\os2\$D\font.obj \
+  ..\os2\$D\fontdlg.obj \
   ..\os2\$D\frame.obj \
   ..\os2\$D\window.obj
 
@@ -337,6 +339,8 @@ OS2LIBOBJS = \
   dirdlg.obj \
   dnd.obj \
   filedlg.obj \
+  font.obj \
+  fontdlg.obj \
   frame.obj \
   window.obj
 
@@ -349,7 +353,7 @@ HTMLOBJS = \
   ..\html\$D\htmltag.obj \
   ..\html\$D\htmlwin.obj \
   ..\html\$D\htmlwinparser.obj \
-s  ..\html\$D\mod_fonts.obj \
+  ..\html\$D\mod_fonts.obj \
   ..\html\$D\mod_hline.obj \
   ..\html\$D\mod_image.obj \
   ..\html\$D\mod_layout.obj \
@@ -510,6 +514,8 @@ $(OS2LIBOBJS):
   copy ..\os2\$D\dirdlg.obj
   copy ..\os2\$D\dnd.obj
   copy ..\os2\$D\filedlg.obj
+  copy ..\os2\$D\font.obj
+  copy ..\os2\$D\fontdlg.obj
   copy ..\os2\$D\frame.obj
   copy ..\os2\$D\window.obj