src/osx/carbon/mdi.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mac/carbon/mdi.cpp
   3 // Purpose:     MDI classes
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     1998-01-01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #if wxUSE_MDI
  15
  16 #include "wx/mdi.h"
  17
  18 #ifndef WX_PRECOMP
  19     #include "wx/log.h"
  20     #include "wx/menu.h"
  21     #include "wx/settings.h"
  22     #include "wx/statusbr.h"
  23 #endif
  24
  25 #include "wx/osx/private.h"
  26 #include "wx/osx/uma.h"
  27
  28 IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
  29 IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
  30 IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
  31
  32 BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
  33     EVT_ACTIVATE(wxMDIParentFrame::OnActivate)
  34     EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
  35 END_EVENT_TABLE()
  36
  37 BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
  38     EVT_SCROLL(wxMDIClientWindow::OnScroll)
  39 END_EVENT_TABLE()
  40
  41 #define TRACE_MDI "mdi"
  42
  43 static const int IDM_WINDOWTILEHOR  = 4001;
  44 static const int IDM_WINDOWCASCADE = 4002;
  45 static const int IDM_WINDOWICONS = 4003;
  46 static const int IDM_WINDOWNEXT = 4004;
  47 static const int IDM_WINDOWTILEVERT = 4005;
  48
  49 // others
  50
  51 void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate )
  52 {
  53 #if 1 // TODO REMOVE
  54     if ( inWindowRef )
  55     {
  56 //        bool isHighlighted = IsWindowHighlited( inWindowRef ) ;
  57 //        if ( inActivate != isHighlighted )
  58 #ifndef __LP64__
  59         GrafPtr port ;
  60         GetPort( &port ) ;
  61         SetPortWindowPort( inWindowRef ) ;
  62 #endif
  63         HiliteWindow( inWindowRef , inActivate ) ;
  64         ControlRef control = NULL ;
  65         ::GetRootControl( inWindowRef , &control ) ;
  66         if ( control )
  67         {
  68             if ( inActivate )
  69                 ::ActivateControl( control ) ;
  70             else
  71                 ::DeactivateControl( control ) ;
  72         }
  73 #ifndef __LP64__
  74         SetPort( port ) ;
  75 #endif
  76     }
  77 #endif
  78 }
  79
  80 // ----------------------------------------------------------------------------
  81 // Parent frame
  82 // ----------------------------------------------------------------------------
  83
  84 void wxMDIParentFrame::Init()
  85 {
  86     m_clientWindow = NULL;
  87     m_currentChild = NULL;
  88     m_windowMenu = (wxMenu*) NULL;
  89     m_parentFrameActive = true;
  90     m_shouldBeShown = false;
  91 }
  92
  93 bool wxMDIParentFrame::Create(wxWindow *parent,
  94     wxWindowID id,
  95     const wxString& title,
  96     const wxPoint& pos,
  97     const wxSize& size,
  98     long style,
  99     const wxString& name)
 100 {
 101     // this style can be used to prevent a window from having the standard MDI
 102     // "Window" menu
 103     if ( style & wxFRAME_NO_WINDOW_MENU )
 104     {
 105         m_windowMenu = (wxMenu *)NULL;
 106         style -= wxFRAME_NO_WINDOW_MENU ;
 107     }
 108     else // normal case: we have the window menu, so construct it
 109     {
 110         m_windowMenu = new wxMenu;
 111
 112         m_windowMenu->Append(IDM_WINDOWCASCADE, wxT("&Cascade"));
 113         m_windowMenu->Append(IDM_WINDOWTILEHOR, wxT("Tile &Horizontally"));
 114         m_windowMenu->Append(IDM_WINDOWTILEVERT, wxT("Tile &Vertically"));
 115         m_windowMenu->AppendSeparator();
 116         m_windowMenu->Append(IDM_WINDOWICONS, wxT("&Arrange Icons"));
 117         m_windowMenu->Append(IDM_WINDOWNEXT, wxT("&Next"));
 118     }
 119
 120     if ( !wxFrame::Create( parent , id , title , pos , size , style , name ) )
 121         return false;
 122
 123     m_parentFrameActive = true;
 124
 125     m_clientWindow = OnCreateClient();
 126
 127     return m_clientWindow != NULL;
 128 }
 129
 130 wxMDIParentFrame::~wxMDIParentFrame()
 131 {
 132     DestroyChildren();
 133
 134     // already deleted by DestroyChildren()
 135     m_clientWindow = NULL ;
 136
 137     delete m_windowMenu;
 138 }
 139
 140 void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar)
 141 {
 142     wxFrame::SetMenuBar( menu_bar ) ;
 143 }
 144
 145 void wxMDIParentFrame::GetRectForTopLevelChildren(int *x, int *y, int *w, int *h)
 146 {
 147     if (x)
 148         *x = 0;
 149     if (y)
 150         *y = 0;
 151
 152     wxDisplaySize(w, h);
 153 }
 154
 155 void wxMDIParentFrame::AddChild(wxWindowBase *child)
 156 {
 157     // moved this to front, so that we don't run into unset m_parent problems later
 158     wxFrame::AddChild(child);
 159
 160     if ( !m_currentChild )
 161     {
 162         m_currentChild = wxDynamicCast(child, wxMDIChildFrame);
 163
 164         if ( m_currentChild && IsShown() && !ShouldBeVisible() )
 165         {
 166             // we shouldn't remain visible any more
 167             wxFrame::Show(false);
 168             m_shouldBeShown = true;
 169         }
 170     }
 171 }
 172
 173 void wxMDIParentFrame::RemoveChild(wxWindowBase *child)
 174 {
 175     if ( child == m_currentChild )
 176     {
 177         // the current child isn't active any more, try to find another one
 178         m_currentChild = NULL;
 179
 180         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 181               node;
 182               node = node->GetNext() )
 183         {
 184             wxMDIChildFrame *
 185                 childCur = wxDynamicCast(node->GetData(), wxMDIChildFrame);
 186             if ( childCur != child )
 187             {
 188                 m_currentChild = childCur;
 189                 break;
 190             }
 191         }
 192     }
 193
 194     wxFrame::RemoveChild(child);
 195
 196     // if there are no more children left we need to show the frame if we
 197     // hadn't shown it before because there were active children and it was
 198     // useless (note that we have to do it after fully removing the child, i.e.
 199     // after calling the base class RemoveChild() as otherwise we risk to touch
 200     // pointer to the child being deleted)
 201     if ( !m_currentChild && m_shouldBeShown && !IsShown() )
 202     {
 203         // we have to show it, but at least move it out of sight and make it of
 204         // smallest possible size (unfortunately (0, 0) doesn't work so that it
 205         // doesn't appear in expose
 206         SetSize(-10000, -10000, 1, 1);
 207         Show();
 208     }
 209 }
 210
 211 void wxMDIParentFrame::MacActivate(long timestamp, bool activating)
 212 {
 213     wxLogTrace(TRACE_MDI, wxT("MDI PARENT=%p MacActivate(0x%08lx,%s)"), this, timestamp, activating ? wxT("ACTIV") : wxT("deact"));
 214
 215     if (activating)
 216     {
 217         if (s_macDeactivateWindow && s_macDeactivateWindow->GetParent() == this)
 218         {
 219             wxLogTrace(TRACE_MDI, wxT("child had been scheduled for deactivation, rehighlighting"));
 220
 221             UMAHighlightAndActivateWindow((WindowRef)s_macDeactivateWindow->GetWXWindow(), true);
 222
 223             wxLogTrace(TRACE_MDI, wxT("finished highliting child"));
 224
 225             s_macDeactivateWindow = NULL;
 226         }
 227         else if (s_macDeactivateWindow == this)
 228         {
 229             wxLogTrace(TRACE_MDI, wxT("Avoided deactivation/activation of this=%p"), this);
 230
 231             s_macDeactivateWindow = NULL;
 232         }
 233         else // window to deactivate is NULL or is not us or one of our kids
 234         {
 235             // activate kid instead
 236             if (m_currentChild)
 237                 m_currentChild->MacActivate(timestamp, activating);
 238             else
 239                 wxFrame::MacActivate(timestamp, activating);
 240         }
 241     }
 242     else
 243     {
 244         // We were scheduled for deactivation, and now we do it.
 245         if (s_macDeactivateWindow == this)
 246         {
 247             s_macDeactivateWindow = NULL;
 248             if (m_currentChild)
 249                 m_currentChild->MacActivate(timestamp, activating);
 250             wxFrame::MacActivate(timestamp, activating);
 251         }
 252         else // schedule ourselves for deactivation
 253         {
 254             if (s_macDeactivateWindow)
 255                 wxLogTrace(TRACE_MDI, wxT("window=%p SHOULD have been deactivated, oh well!"), s_macDeactivateWindow);
 256             wxLogTrace(TRACE_MDI, wxT("Scheduling delayed MDI Parent deactivation"));
 257
 258             s_macDeactivateWindow = this;
 259         }
 260     }
 261 }
 262
 263 void wxMDIParentFrame::OnActivate(wxActivateEvent& event)
 264 {
 265     event.Skip();
 266 }
 267
 268 // Returns the active MDI child window
 269 wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
 270 {
 271     return m_currentChild ;
 272 }
 273
 274 // Create the client window class (don't Create the window,
 275 // just return a new class)
 276 wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
 277 {
 278     return new wxMDIClientWindow( this );
 279 }
 280
 281 // Responds to colour changes, and passes event on to children.
 282 void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
 283 {
 284     // TODO
 285
 286     // Propagate the event to the non-top-level children
 287     wxFrame::OnSysColourChanged(event);
 288 }
 289
 290 // MDI operations
 291 void wxMDIParentFrame::Cascade()
 292 {
 293     // TODO
 294 }
 295
 296 void wxMDIParentFrame::Tile(wxOrientation WXUNUSED(orient))
 297 {
 298     // TODO
 299 }
 300
 301 void wxMDIParentFrame::ArrangeIcons()
 302 {
 303     // TODO
 304 }
 305
 306 void wxMDIParentFrame::ActivateNext()
 307 {
 308     // TODO
 309 }
 310
 311 void wxMDIParentFrame::ActivatePrevious()
 312 {
 313     // TODO
 314 }
 315
 316 bool wxMDIParentFrame::ShouldBeVisible() const
 317 {
 318     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 319           node;
 320           node = node->GetNext() )
 321     {
 322         wxWindow *win = node->GetData();
 323
 324         if ( win->IsShown()
 325                 && !wxDynamicCast(win, wxMDIChildFrame)
 326 #if wxUSE_STATUSBAR
 327                 && win != (wxWindow*) GetStatusBar()
 328 #endif
 329                 && win != GetClientWindow() )
 330         {
 331             // if we have a non-MDI child, do remain visible so that it could
 332             // be used
 333             return true;
 334         }
 335     }
 336
 337     return false;
 338 }
 339
 340 bool wxMDIParentFrame::Show( bool show )
 341 {
 342     m_shouldBeShown = false;
 343
 344     // don't really show the MDI frame unless it has any children other than
 345     // MDI children as it is pretty useless in this case
 346
 347     if ( show )
 348     {
 349         if ( !ShouldBeVisible() && m_currentChild )
 350         {
 351             // don't make the window visible now but remember that we should
 352             // have had done it
 353             m_shouldBeShown = true;
 354
 355             return false;
 356         }
 357     }
 358
 359     return wxFrame::Show(show);
 360 }
 361
 362 // ----------------------------------------------------------------------------
 363 // Child frame
 364 // ----------------------------------------------------------------------------
 365
 366 wxMDIChildFrame::wxMDIChildFrame()
 367 {
 368     Init() ;
 369 }
 370 void wxMDIChildFrame::Init()
 371 {
 372 }
 373
 374 bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
 375                              wxWindowID id,
 376                              const wxString& title,
 377                              const wxPoint& pos,
 378                              const wxSize& size,
 379                              long style,
 380                              const wxString& name)
 381 {
 382     SetName(name);
 383
 384     if ( id == wxID_ANY )
 385         id = (int)NewControlId();
 386
 387     wxNonOwnedWindow::Create( parent, id, pos , size , MacRemoveBordersFromStyle(style) , name ) ;
 388
 389     SetTitle( title );
 390
 391     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
 392
 393     return true;
 394 }
 395
 396 wxMDIChildFrame::~wxMDIChildFrame()
 397 {
 398     DestroyChildren();
 399 }
 400
 401 void wxMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
 402 {
 403     return wxFrame::SetMenuBar( menu_bar ) ;
 404 }
 405
 406 void wxMDIChildFrame::MacActivate(long timestamp, bool activating)
 407 {
 408     wxLogTrace(TRACE_MDI, wxT("MDI child=%p  MacActivate(0x%08lx,%s)"),this, timestamp, activating ? wxT("ACTIV") : wxT("deact"));
 409
 410     wxMDIParentFrame *mdiparent = wxDynamicCast(m_parent, wxMDIParentFrame);
 411     wxASSERT(mdiparent);
 412
 413     if (activating)
 414     {
 415         if (s_macDeactivateWindow == m_parent)
 416         {
 417             wxLogTrace(TRACE_MDI, wxT("parent had been scheduled for deactivation, rehighlighting"));
 418
 419             UMAHighlightAndActivateWindow((WindowRef)s_macDeactivateWindow->GetWXWindow(), true);
 420
 421             wxLogTrace(TRACE_MDI, wxT("finished highliting parent"));
 422
 423             s_macDeactivateWindow = NULL;
 424         }
 425         else if ((mdiparent->m_currentChild == this) || !s_macDeactivateWindow)
 426             mdiparent->wxFrame::MacActivate(timestamp, activating);
 427
 428         if (mdiparent->m_currentChild && mdiparent->m_currentChild != this)
 429             mdiparent->m_currentChild->wxFrame::MacActivate(timestamp, false);
 430         mdiparent->m_currentChild = this;
 431
 432         if (s_macDeactivateWindow == this)
 433         {
 434             wxLogTrace(TRACE_MDI, wxT("Avoided deactivation/activation of this=%p"), this);
 435
 436             s_macDeactivateWindow = NULL;
 437         }
 438         else
 439             wxFrame::MacActivate(timestamp, activating);
 440     }
 441     else
 442     {
 443         // We were scheduled for deactivation, and now we do it.
 444         if (s_macDeactivateWindow == this)
 445         {
 446             s_macDeactivateWindow = NULL;
 447             wxFrame::MacActivate(timestamp, activating);
 448             if (mdiparent->m_currentChild == this)
 449                 mdiparent->wxFrame::MacActivate(timestamp, activating);
 450         }
 451         else // schedule ourselves for deactivation
 452         {
 453             if (s_macDeactivateWindow)
 454                 wxLogTrace(TRACE_MDI, wxT("window=%p SHOULD have been deactivated, oh well!"), s_macDeactivateWindow);
 455             wxLogTrace(TRACE_MDI, wxT("Scheduling delayed deactivation"));
 456
 457             s_macDeactivateWindow = this;
 458         }
 459     }
 460 }
 461
 462 // MDI operations
 463 void wxMDIChildFrame::Maximize()
 464 {
 465     wxFrame::Maximize() ;
 466 }
 467
 468 void wxMDIChildFrame::Restore()
 469 {
 470     wxFrame::Restore() ;
 471 }
 472
 473 void wxMDIChildFrame::Activate()
 474 {
 475     Raise ();
 476 }
 477
 478 //-----------------------------------------------------------------------------
 479 // wxMDIClientWindow
 480 //-----------------------------------------------------------------------------
 481
 482 wxMDIClientWindow::wxMDIClientWindow()
 483 {
 484 }
 485
 486 wxMDIClientWindow::~wxMDIClientWindow()
 487 {
 488     DestroyChildren();
 489 }
 490
 491 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
 492 {
 493     if ( !wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style) )
 494         return false;
 495
 496     return true;
 497 }
 498
 499 // Get size *available for subwindows* i.e. excluding menu bar.
 500 void wxMDIClientWindow::DoGetClientSize(int *x, int *y) const
 501 {
 502     wxDisplaySize( x , y ) ;
 503 }
 504
 505 // Explicitly call default scroll behaviour
 506 void wxMDIClientWindow::OnScroll(wxScrollEvent& WXUNUSED(event))
 507 {
 508 }
 509
 510 #endif // wxUSE_MDI