src/motif/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        app.cpp
   3 // Purpose:     wxApp
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "app.h"
  14 #endif
  15
  16 #ifdef __VMS
  17 #define XtParent XTPARENT
  18 #define XtDisplay XTDISPLAY
  19 #endif
  20
  21 #include "wx/frame.h"
  22 #include "wx/app.h"
  23 #include "wx/utils.h"
  24 #include "wx/gdicmn.h"
  25 #include "wx/pen.h"
  26 #include "wx/brush.h"
  27 #include "wx/cursor.h"
  28 #include "wx/icon.h"
  29 #include "wx/palette.h"
  30 #include "wx/dc.h"
  31 #include "wx/dialog.h"
  32 #include "wx/msgdlg.h"
  33 #include "wx/log.h"
  34 #include "wx/module.h"
  35 #include "wx/memory.h"
  36 #include "wx/log.h"
  37 #include "wx/intl.h"
  38 #include "wx/evtloop.h"
  39 #include "wx/hash.h"
  40 #include "wx/hashmap.h"
  41
  42 #if wxUSE_THREADS
  43     #include "wx/thread.h"
  44 #endif
  45
  46 #ifdef __VMS__
  47 #pragma message disable nosimpint
  48 #endif
  49 #include <Xm/Xm.h>
  50 #include <X11/Xlib.h>
  51 #include <X11/Xutil.h>
  52 #include <X11/Xresource.h>
  53 #include <X11/Xatom.h>
  54 #ifdef __VMS__
  55 #pragma message enable nosimpint
  56 #endif
  57
  58 #include "wx/motif/private.h"
  59
  60 #include <string.h>
  61
  62 WX_DECLARE_VOIDPTR_HASH_MAP( wxXVisualInfo*, wxXVisualInfoMap );
  63
  64 extern wxList wxPendingDelete;
  65 extern bool wxAddIdleCallback();
  66
  67 wxApp *wxTheApp = NULL;
  68
  69 wxHashTable *wxWidgetHashTable = NULL;
  70
  71 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
  72
  73 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
  74     EVT_IDLE(wxApp::OnIdle)
  75 END_EVENT_TABLE()
  76
  77 #ifdef __WXDEBUG__
  78     typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *);
  79
  80     XErrorHandlerFunc gs_pfnXErrorHandler = 0;
  81
  82     static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent)
  83     {
  84         // just forward to the default handler for now
  85         return gs_pfnXErrorHandler(dpy, xevent);
  86     }
  87 #endif // __WXDEBUG__
  88
  89 long wxApp::sm_lastMessageTime = 0;
  90
  91 bool wxApp::Initialize()
  92 {
  93     wxClassInfo::InitializeClasses();
  94
  95     // GL: I'm annoyed ... I don't know where to put this and I don't want to
  96     // create a module for that as it's part of the core.
  97 #if wxUSE_THREADS
  98     wxPendingEventsLocker = new wxCriticalSection();
  99 #endif
 100
 101     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
 102     wxTheColourDatabase->Initialize();
 103
 104     wxInitializeStockLists();
 105     wxInitializeStockObjects();
 106
 107     wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
 108
 109     wxModule::RegisterModules();
 110     if (!wxModule::InitializeModules()) return FALSE;
 111
 112     return TRUE;
 113 }
 114
 115 void wxApp::CleanUp()
 116 {
 117     delete wxWidgetHashTable;
 118     wxWidgetHashTable = NULL;
 119
 120     wxModule::CleanUpModules();
 121
 122     wxDeleteStockObjects() ;
 123
 124     // Destroy all GDI lists, etc.
 125
 126     wxDeleteStockLists();
 127
 128     delete wxTheColourDatabase;
 129     wxTheColourDatabase = NULL;
 130
 131     wxClassInfo::CleanUpClasses();
 132
 133     delete wxTheApp;
 134     wxTheApp = NULL;
 135
 136     // GL: I'm annoyed ... I don't know where to put this and I don't want to
 137     // create a module for that as it's part of the core.
 138 #if wxUSE_THREADS
 139     delete wxPendingEvents;
 140     delete wxPendingEventsLocker;
 141 #endif
 142
 143 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 144     // At this point we want to check if there are any memory
 145     // blocks that aren't part of the wxDebugContext itself,
 146     // as a special case. Then when dumping we need to ignore
 147     // wxDebugContext, too.
 148     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 149     {
 150         wxLogDebug("There were memory leaks.\n");
 151         wxDebugContext::Dump();
 152         wxDebugContext::PrintStatistics();
 153     }
 154 #endif
 155
 156     // do it as the very last thing because everything else can log messages
 157     wxLog::DontCreateOnDemand();
 158     // do it as the very last thing because everything else can log messages
 159     delete wxLog::SetActiveTarget(NULL);
 160 }
 161
 162 int wxEntry( int argc, char *argv[] )
 163 {
 164 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 165     // This seems to be necessary since there are 'rogue'
 166     // objects present at this point (perhaps global objects?)
 167     // Setting a checkpoint will ignore them as far as the
 168     // memory checking facility is concerned.
 169     // Of course you may argue that memory allocated in globals should be
 170     // checked, but this is a reasonable compromise.
 171     wxDebugContext::SetCheckpoint();
 172 #endif
 173
 174     if (!wxApp::Initialize())
 175         return FALSE;
 176
 177     if (!wxTheApp)
 178     {
 179         if (!wxApp::GetInitializerFunction())
 180         {
 181             printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" );
 182             return 0;
 183         };
 184
 185         wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) ();
 186     };
 187
 188     if (!wxTheApp)
 189     {
 190         printf( "wxWindows error: wxTheApp == NULL\n" );
 191         return 0;
 192     };
 193
 194     wxTheApp->SetClassName(wxFileNameFromPath(argv[0]));
 195     wxTheApp->SetAppName(wxFileNameFromPath(argv[0]));
 196
 197     wxTheApp->argc = argc;
 198     wxTheApp->argv = argv;
 199
 200     // GUI-specific initialization, such as creating an app context.
 201     wxTheApp->OnInitGui();
 202
 203     // Here frames insert themselves automatically into wxTopLevelWindows by
 204     // getting created in OnInit().
 205
 206     int retValue = 0;
 207     if (wxTheApp->OnInit())
 208     {
 209         if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
 210     }
 211
 212     // flush the logged messages if any
 213     wxLog *pLog = wxLog::GetActiveTarget();
 214     if ( pLog != NULL && pLog->HasPendingMessages() )
 215         pLog->Flush();
 216
 217     // So dialog boxes aren't used for further messages
 218     delete wxLog::SetActiveTarget(new wxLogStderr);
 219
 220     if (wxTheApp->GetTopWindow())
 221     {
 222         delete wxTheApp->GetTopWindow();
 223         wxTheApp->SetTopWindow(NULL);
 224     }
 225
 226     wxTheApp->DeletePendingObjects();
 227
 228     wxTheApp->OnExit();
 229
 230     wxApp::CleanUp();
 231
 232     return retValue;
 233 };
 234
 235 // Static member initialization
 236 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
 237
 238 wxApp::wxApp()
 239 {
 240     argc = 0;
 241     argv = NULL;
 242
 243     m_eventLoop = new wxEventLoop;
 244     m_mainColormap = (WXColormap) NULL;
 245     m_appContext = (WXAppContext) NULL;
 246     m_topLevelWidget = (WXWidget) NULL;
 247     m_maxRequestSize = 0;
 248     m_initialDisplay = (WXDisplay*) 0;
 249     m_visualInfoMap = new wxXVisualInfoMap;
 250 }
 251
 252 wxApp::~wxApp()
 253 {
 254     delete m_eventLoop;
 255
 256     for( wxXVisualInfoMap::iterator it  = m_visualInfoMap->begin(),
 257                                     end = m_visualInfoMap->end();
 258          it != end; ++it )
 259     {
 260         delete it->second;
 261     }
 262
 263     delete m_visualInfoMap;
 264 }
 265
 266 bool wxApp::Initialized()
 267 {
 268     if (GetTopWindow())
 269         return TRUE;
 270     else
 271         return FALSE;
 272 }
 273
 274 int wxApp::MainLoop()
 275 {
 276     /*
 277     * Sit around forever waiting to process X-events. Property Change
 278     * event are handled special, because they have to refer to
 279     * the root window rather than to a widget. therefore we can't
 280     * use an Xt-eventhandler.
 281     */
 282
 283     XSelectInput(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()),
 284         XDefaultRootWindow(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())),
 285         PropertyChangeMask);
 286
 287     m_eventLoop->Run();
 288
 289     return 0;
 290 }
 291
 292 // Processes an idle event.
 293 // Returns TRUE if more time is needed.
 294 bool wxApp::ProcessIdle()
 295 {
 296     wxIdleEvent event;
 297
 298     return ProcessEvent(event) && event.MoreRequested();
 299 }
 300
 301 void wxApp::ExitMainLoop()
 302 {
 303     m_eventLoop->Exit();
 304 }
 305
 306 // Is a message/event pending?
 307 bool wxApp::Pending()
 308 {
 309 <<<<<<< app.cpp
 310     return XtAppPending( (XtAppContext) GetAppContext() ) != 0;
 311 =======
 312     return m_eventLoop->Pending();
 313 #if 0
 314     XFlush(XtDisplay( (Widget) wxTheApp->GetTopLevelWidget() ));
 315
 316     // Fix by Doug from STI, to prevent a stall if non-X event
 317     // is found.
 318     return ((XtAppPending( (XtAppContext) GetAppContext() ) & XtIMXEvent) != 0) ;
 319 #endif
 320 >>>>>>> 1.57
 321 }
 322
 323 // Dispatch a message.
 324 void wxApp::Dispatch()
 325 {
 326     m_eventLoop->Dispatch();
 327 }
 328
 329 // This should be redefined in a derived class for
 330 // handling property change events for XAtom IPC.
 331 void wxApp::HandlePropertyChange(WXEvent *event)
 332 {
 333     // by default do nothing special
 334     XtDispatchEvent((XEvent*) event); /* let Motif do the work */
 335 }
 336
 337 void wxApp::OnIdle(wxIdleEvent& event)
 338 {
 339     static bool inOnIdle = FALSE;
 340
 341     // Avoid recursion (via ProcessEvent default case)
 342     if (inOnIdle)
 343         return;
 344
 345     inOnIdle = TRUE;
 346
 347     // If there are pending events, we must process them: pending events
 348     // are either events to the threads other than main or events posted
 349     // with wxPostEvent() functions
 350     // GRG: I have moved this here so that all pending events are processed
 351     //   before starting to delete any objects. This behaves better (in
 352     //   particular, wrt wxPostEvent) and is coherent with wxGTK's current
 353     //   behaviour. Also removed the '#if wxUSE_THREADS' around it.
 354     //  Changed Mar/2000 before 2.1.14
 355
 356     // Flush pending events.
 357     ProcessPendingEvents();
 358
 359     // 'Garbage' collection of windows deleted with Close().
 360     DeletePendingObjects();
 361
 362     // flush the logged messages if any
 363     wxLog *pLog = wxLog::GetActiveTarget();
 364     if ( pLog != NULL && pLog->HasPendingMessages() )
 365         pLog->Flush();
 366
 367     // Send OnIdle events to all windows
 368     bool needMore = SendIdleEvents();
 369
 370     if (needMore)
 371         event.RequestMore(TRUE);
 372
 373     inOnIdle = FALSE;
 374 }
 375
 376 // Send idle event to all top-level windows
 377 bool wxApp::SendIdleEvents()
 378 {
 379     bool needMore = FALSE;
 380
 381     wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
 382     while (node)
 383     {
 384         wxWindow* win = node->GetData();
 385         if (SendIdleEvents(win))
 386             needMore = TRUE;
 387         node = node->GetNext();
 388     }
 389
 390     return needMore;
 391 }
 392
 393 // Send idle event to window and all subwindows
 394 bool wxApp::SendIdleEvents(wxWindow* win)
 395 {
 396     bool needMore = FALSE;
 397
 398     wxIdleEvent event;
 399     event.SetEventObject(win);
 400     win->ProcessEvent(event);
 401
 402     if (event.MoreRequested())
 403         needMore = TRUE;
 404
 405     wxWindowList::Node* node = win->GetChildren().GetFirst();
 406     while (node)
 407     {
 408         wxWindow* win = node->GetData();
 409         if (SendIdleEvents(win))
 410             needMore = TRUE;
 411
 412         node = node->GetNext();
 413     }
 414     return needMore ;
 415 }
 416
 417 void wxApp::DeletePendingObjects()
 418 {
 419     wxList::Node *node = wxPendingDelete.GetFirst();
 420     while (node)
 421     {
 422         wxObject *obj = node->GetData();
 423
 424         delete obj;
 425
 426         if (wxPendingDelete.Member(obj))
 427             delete node;
 428
 429         // Deleting one object may have deleted other pending
 430         // objects, so start from beginning of list again.
 431         node = wxPendingDelete.GetFirst();
 432     }
 433 }
 434
 435 static char *fallbackResources[] = {
 436     "*menuBar.marginHeight: 0",
 437     "*menuBar.shadowThickness: 1",
 438     "*background: #c0c0c0",
 439     "*foreground: black",
 440     NULL
 441 };
 442
 443 // Create an application context
 444 bool wxApp::OnInitGui()
 445 {
 446     if( !wxAppBase::OnInitGui() )
 447         return FALSE;
 448
 449     XtToolkitInitialize() ;
 450     wxTheApp->m_appContext = (WXAppContext) XtCreateApplicationContext();
 451     XtAppSetFallbackResources((XtAppContext) wxTheApp->m_appContext, fallbackResources);
 452
 453     Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,(String)NULL,NULL,
 454         wxTheApp->GetClassName().c_str(), NULL, 0,
 455 # if XtSpecificationRelease < 5
 456         (Cardinal*) &argc,
 457 # else
 458         &argc,
 459 # endif
 460         argv);
 461
 462     if (!dpy) {
 463          // if you don't log to stderr, nothing will be shown...
 464         delete wxLog::SetActiveTarget(new wxLogStderr);
 465         wxString className(wxTheApp->GetClassName());
 466         wxLogError(_("wxWindows could not open display for '%s': exiting."),
 467                    className.c_str());
 468         exit(-1);
 469     }
 470     m_initialDisplay = (WXDisplay*) dpy;
 471
 472 #ifdef __WXDEBUG__
 473     // install the X error handler
 474     gs_pfnXErrorHandler = XSetErrorHandler(wxXErrorHandler);
 475 #endif // __WXDEBUG__
 476
 477     wxTheApp->m_topLevelWidget =
 478         (WXWidget) XtAppCreateShell((String)NULL,
 479                                     wxTheApp->GetClassName().c_str(),
 480                                     applicationShellWidgetClass,dpy,
 481                                     NULL,0) ;
 482
 483     // Add general resize proc
 484     XtActionsRec rec;
 485     rec.string = "resize";
 486     rec.proc = (XtActionProc)wxWidgetResizeProc;
 487     XtAppAddActions((XtAppContext) wxTheApp->m_appContext, &rec, 1);
 488
 489     GetMainColormap(dpy);
 490     m_maxRequestSize = XMaxRequestSize((Display*) dpy);
 491
 492     wxAddIdleCallback();
 493
 494     return TRUE;
 495 }
 496
 497 WXColormap wxApp::GetMainColormap(WXDisplay* display)
 498 {
 499     if (!display) /* Must be called first with non-NULL display */
 500         return m_mainColormap;
 501
 502     int defaultScreen = DefaultScreen((Display*) display);
 503     Screen* screen = XScreenOfDisplay((Display*) display, defaultScreen);
 504
 505     Colormap c = DefaultColormapOfScreen(screen);
 506
 507     if (!m_mainColormap)
 508         m_mainColormap = (WXColormap) c;
 509
 510     return (WXColormap) c;
 511 }
 512
 513 wxXVisualInfo* wxApp::GetVisualInfo( WXDisplay* display )
 514 {
 515     wxXVisualInfoMap::iterator it = m_visualInfoMap->find( display );
 516
 517     if( it != m_visualInfoMap->end() ) return it->second;
 518
 519     wxXVisualInfo* vi = new wxXVisualInfo;
 520     wxFillXVisualInfo( vi, (Display*)display );
 521
 522     (*m_visualInfoMap)[display] = vi;
 523
 524     return vi;
 525 }
 526
 527 void wxExit()
 528 {
 529     int retValue = 0;
 530     if (wxTheApp)
 531         retValue = wxTheApp->OnExit();
 532
 533     wxApp::CleanUp();
 534     /*
 535     * Exit in some platform-specific way.
 536     * Not recommended that the app calls this:
 537     * only for emergencies.
 538     */
 539     exit(retValue);
 540 }
 541
 542 // Yield to other processes
 543
 544 bool wxApp::Yield(bool onlyIfNeeded)
 545 {
 546     bool s_inYield = FALSE;
 547
 548     if ( s_inYield )
 549     {
 550         if ( !onlyIfNeeded )
 551         {
 552             wxFAIL_MSG( wxT("wxYield called recursively" ) );
 553         }
 554
 555         return FALSE;
 556     }
 557
 558     s_inYield = TRUE;
 559
 560     while (wxTheApp && wxTheApp->Pending())
 561         wxTheApp->Dispatch();
 562
 563     s_inYield = FALSE;
 564
 565     return TRUE;
 566 }
 567
 568 // ----------------------------------------------------------------------------
 569 // accessors for C modules
 570 // ----------------------------------------------------------------------------
 571
 572 extern "C" XtAppContext wxGetAppContext()
 573 {
 574     return (XtAppContext)wxTheApp->GetAppContext();
 575 }