]> git.saurik.com Git - wxWidgets.git/blame - src/common/utilscmn.cpp
Added mouse event handler invocations
[wxWidgets.git] / src / common / utilscmn.cpp
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
3452f00b 2// Name: src/common/utilscmn.cpp
c801d85f
KB
3// Purpose: Miscellaneous utility functions and classes
4// Author: Julian Smart
5// Modified by:
6// Created: 29/01/98
7// RCS-ID: $Id$
8// Copyright: (c) 1998 Julian Smart
65571936 9// Licence: wxWindows licence
c801d85f
KB
10/////////////////////////////////////////////////////////////////////////////
11
e90c1d2a
VZ
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
c801d85f
KB
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
e90c1d2a 24 #pragma hdrstop
c801d85f
KB
25#endif
26
27#ifndef WX_PRECOMP
fcdb9b38 28 #include "wx/app.h"
e90c1d2a
VZ
29 #include "wx/string.h"
30 #include "wx/utils.h"
974e8d94
VZ
31 #include "wx/intl.h"
32 #include "wx/log.h"
e90c1d2a
VZ
33
34 #if wxUSE_GUI
35 #include "wx/window.h"
e90c1d2a 36 #include "wx/frame.h"
1e6feb95 37 #include "wx/menu.h"
e90c1d2a
VZ
38 #include "wx/msgdlg.h"
39 #include "wx/textdlg.h"
78bcfcfc 40 #include "wx/textctrl.h" // for wxTE_PASSWORD
974e8d94
VZ
41 #if wxUSE_ACCEL
42 #include "wx/menuitem.h"
43 #include "wx/accel.h"
44 #endif // wxUSE_ACCEL
e90c1d2a
VZ
45 #endif // wxUSE_GUI
46#endif // WX_PRECOMP
c801d85f 47
2739d4f0
VZ
48#include "wx/apptrait.h"
49
cd6ce4a9
VZ
50#include "wx/process.h"
51#include "wx/txtstrm.h"
498a1eeb
RN
52#include "wx/uri.h"
53#include "wx/mimetype.h"
54#include "wx/config.h"
cd6ce4a9 55
4676948b
JS
56#if defined(__WXWINCE__) && wxUSE_DATETIME
57#include "wx/datetime.h"
58#endif
59
c801d85f
KB
60#include <ctype.h>
61#include <stdio.h>
62#include <stdlib.h>
63#include <string.h>
e90c1d2a 64
13ff2485 65#if !wxONLY_WATCOM_EARLIER_THAN(1,4)
3f4a0c5b
VZ
66 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
67 #include <errno.h>
68 #endif
c801d85f 69#endif
e90c1d2a 70
91b4c08d
VZ
71#if wxUSE_GUI
72 #include "wx/colordlg.h"
bf31fa26 73 #include "wx/fontdlg.h"
d1c8aaa3 74 #include "wx/notebook.h"
d1c8aaa3 75 #include "wx/statusbr.h"
91b4c08d
VZ
76#endif // wxUSE_GUI
77
1c193821 78#ifndef __WXWINCE__
c801d85f 79#include <time.h>
1c193821
JS
80#else
81#include "wx/msw/wince/time.h"
82#endif
e90c1d2a 83
f14d6dd1
JS
84#ifdef __WXMAC__
85#include "wx/mac/private.h"
86#ifndef __DARWIN__
87#include "InternetConfig.h"
88#endif
89#endif
90
4676948b 91#if !defined(__MWERKS__) && !defined(__WXWINCE__)
e90c1d2a
VZ
92 #include <sys/types.h>
93 #include <sys/stat.h>
469e1e5c 94#endif
c801d85f 95
82ef81ed 96#if defined(__WXMSW__)
5e1febfa 97 #include "wx/msw/private.h"
3452f00b 98 #include "wx/msw/registry.h"
b21d68c6 99 #include <shellapi.h> // needed for SHELLEXECUTEINFO
c801d85f
KB
100#endif
101
ec67cff1 102#if wxUSE_BASE
7c072018 103
73deed44
VZ
104// ----------------------------------------------------------------------------
105// common data
106// ----------------------------------------------------------------------------
107
e90c1d2a
VZ
108// ============================================================================
109// implementation
110// ============================================================================
c801d85f 111
c801d85f 112// Array used in DecToHex conversion routine.
223d09f6 113static wxChar hexArray[] = wxT("0123456789ABCDEF");
c801d85f
KB
114
115// Convert 2-digit hex number to decimal
fd71308f 116int wxHexToDec(const wxString& buf)
c801d85f 117{
657a7545 118 int firstDigit, secondDigit;
3f4a0c5b 119
657a7545
WS
120 if (buf.GetChar(0) >= wxT('A'))
121 firstDigit = buf.GetChar(0) - wxT('A') + 10;
122 else
123 firstDigit = buf.GetChar(0) - wxT('0');
c801d85f 124
657a7545
WS
125 if (buf.GetChar(1) >= wxT('A'))
126 secondDigit = buf.GetChar(1) - wxT('A') + 10;
127 else
128 secondDigit = buf.GetChar(1) - wxT('0');
3f4a0c5b 129
657a7545 130 return (firstDigit & 0xF) * 16 + (secondDigit & 0xF );
c801d85f
KB
131}
132
133// Convert decimal integer to 2-character hex string
84fff0b3 134void wxDecToHex(int dec, wxChar *buf)
c801d85f 135{
657a7545
WS
136 int firstDigit = (int)(dec/16.0);
137 int secondDigit = (int)(dec - (firstDigit*16.0));
138 buf[0] = hexArray[firstDigit];
139 buf[1] = hexArray[secondDigit];
140 buf[2] = 0;
c801d85f
KB
141}
142
fd71308f
JS
143// Convert decimal integer to 2-character hex string
144wxString wxDecToHex(int dec)
145{
84fff0b3 146 wxChar buf[3];
fd71308f
JS
147 wxDecToHex(dec, buf);
148 return wxString(buf);
149}
150
7c072018
VZ
151// ----------------------------------------------------------------------------
152// misc functions
153// ----------------------------------------------------------------------------
c801d85f
KB
154
155// Return the current date/time
e90c1d2a 156wxString wxNow()
c801d85f 157{
4676948b
JS
158#ifdef __WXWINCE__
159#if wxUSE_DATETIME
160 wxDateTime now = wxDateTime::Now();
161 return now.Format();
162#else
163 return wxEmptyString;
164#endif
165#else
2b5f62a0
VZ
166 time_t now = time((time_t *) NULL);
167 char *date = ctime(&now);
168 date[24] = '\0';
169 return wxString::FromAscii(date);
4676948b 170#endif
c801d85f
KB
171}
172
08873d36
VZ
173void wxUsleep(unsigned long milliseconds)
174{
175 wxMilliSleep(milliseconds);
176}
177
7c072018
VZ
178const wxChar *wxGetInstallPrefix()
179{
180 wxString prefix;
181
182 if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
183 return prefix.c_str();
184
185#ifdef wxINSTALL_PREFIX
186 return wxT(wxINSTALL_PREFIX);
187#else
525d8583 188 return wxEmptyString;
7c072018
VZ
189#endif
190}
191
192wxString wxGetDataDir()
193{
10f206ad
RL
194 wxString dir = wxGetInstallPrefix();
195 dir << wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx");
7c072018
VZ
196 return dir;
197}
e90c1d2a 198
8bb6b2c0 199bool wxIsPlatformLittleEndian()
2739d4f0 200{
8bb6b2c0
VZ
201 // Are we little or big endian? This method is from Harbison & Steele.
202 union
203 {
204 long l;
205 char c[sizeof(long)];
206 } u;
207 u.l = 1;
208
209 return u.c[0] == 1;
2739d4f0 210}
1e6feb95 211
8bb6b2c0 212
230c9077
JS
213/*
214 * Class to make it easier to specify platform-dependent values
215 */
216
217wxArrayInt* wxPlatform::sm_customPlatforms = NULL;
218
4bfec179 219void wxPlatform::Copy(const wxPlatform& platform)
230c9077 220{
4bfec179
JS
221 m_longValue = platform.m_longValue;
222 m_doubleValue = platform.m_doubleValue;
223 m_stringValue = platform.m_stringValue;
224}
225
226wxPlatform wxPlatform::If(int platform, long value)
227{
228 if (Is(platform))
229 return wxPlatform(value);
230 else
231 return wxPlatform();
232}
233
234wxPlatform wxPlatform::IfNot(int platform, long value)
235{
236 if (!Is(platform))
237 return wxPlatform(value);
238 else
239 return wxPlatform();
240}
241
242wxPlatform& wxPlatform::ElseIf(int platform, long value)
243{
244 if (Is(platform))
230c9077
JS
245 m_longValue = value;
246 return *this;
247}
248
4bfec179 249wxPlatform& wxPlatform::ElseIfNot(int platform, long value)
230c9077 250{
4bfec179 251 if (!Is(platform))
230c9077
JS
252 m_longValue = value;
253 return *this;
254}
255
4bfec179 256wxPlatform wxPlatform::If(int platform, double value)
230c9077 257{
4bfec179
JS
258 if (Is(platform))
259 return wxPlatform(value);
260 else
261 return wxPlatform();
262}
263
264wxPlatform wxPlatform::IfNot(int platform, double value)
265{
266 if (!Is(platform))
267 return wxPlatform(value);
268 else
269 return wxPlatform();
270}
271
272wxPlatform& wxPlatform::ElseIf(int platform, double value)
273{
274 if (Is(platform))
230c9077
JS
275 m_doubleValue = value;
276 return *this;
277}
278
4bfec179 279wxPlatform& wxPlatform::ElseIfNot(int platform, double value)
230c9077 280{
4bfec179 281 if (!Is(platform))
230c9077
JS
282 m_doubleValue = value;
283 return *this;
284}
285
4bfec179
JS
286wxPlatform wxPlatform::If(int platform, const wxString& value)
287{
288 if (Is(platform))
289 return wxPlatform(value);
290 else
291 return wxPlatform();
292}
293
294wxPlatform wxPlatform::IfNot(int platform, const wxString& value)
295{
296 if (!Is(platform))
297 return wxPlatform(value);
298 else
299 return wxPlatform();
300}
301
302wxPlatform& wxPlatform::ElseIf(int platform, const wxString& value)
230c9077 303{
4bfec179 304 if (Is(platform))
230c9077
JS
305 m_stringValue = value;
306 return *this;
307}
308
4bfec179 309wxPlatform& wxPlatform::ElseIfNot(int platform, const wxString& value)
230c9077 310{
4bfec179 311 if (!Is(platform))
230c9077
JS
312 m_stringValue = value;
313 return *this;
314}
315
4bfec179 316wxPlatform& wxPlatform::Else(long value)
230c9077
JS
317{
318 m_longValue = value;
319 return *this;
320}
321
4bfec179 322wxPlatform& wxPlatform::Else(double value)
230c9077
JS
323{
324 m_doubleValue = value;
325 return *this;
326}
327
4bfec179 328wxPlatform& wxPlatform::Else(const wxString& value)
230c9077
JS
329{
330 m_stringValue = value;
331 return *this;
332}
333
334void wxPlatform::AddPlatform(int platform)
335{
336 if (!sm_customPlatforms)
337 sm_customPlatforms = new wxArrayInt;
338 sm_customPlatforms->Add(platform);
339}
340
341void wxPlatform::ClearPlatforms()
342{
343 delete sm_customPlatforms;
344 sm_customPlatforms = NULL;
345}
346
347/// Function for testing current platform
348
4bfec179 349bool wxPlatform::Is(int platform)
230c9077
JS
350{
351#ifdef __WXMSW__
216c3543 352 if (platform == wxOS_WINDOWS)
230c9077
JS
353 return true;
354#endif
355#ifdef __WXWINCE__
216c3543 356 if (platform == wxOS_WINDOWS_CE)
230c9077
JS
357 return true;
358#endif
a6e8c584
WS
359
360#if 0
361
362// FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols
363
230c9077
JS
364#if defined(__WXWINCE__) && defined(__POCKETPC__)
365 if (platform == wxWinPocketPC)
366 return true;
367#endif
368#if defined(__WXWINCE__) && defined(__SMARTPHONE__)
6aa68c25 369 if (platform == wxWinSmartPhone)
230c9077
JS
370 return true;
371#endif
a6e8c584
WS
372
373#endif
374
230c9077 375#ifdef __WXGTK__
216c3543 376 if (platform == wxPORT_GTK)
230c9077
JS
377 return true;
378#endif
379#ifdef __WXMAC__
216c3543 380 if (platform == wxPORT_MAC)
230c9077
JS
381 return true;
382#endif
383#ifdef __WXX11__
216c3543 384 if (platform == wxPORT_X11)
230c9077
JS
385 return true;
386#endif
387#ifdef __UNIX__
216c3543 388 if (platform == wxOS_UNIX)
230c9077
JS
389 return true;
390#endif
391#ifdef __WXMGL__
216c3543 392 if (platform == wxPORT_MGL)
230c9077
JS
393 return true;
394#endif
8ab09e65
SN
395#ifdef __OS2__
396 if (platform == wxOS_OS2)
397 return true;
398#endif
399#ifdef __WXPM__
400 if (platform == wxPORT_PM)
230c9077
JS
401 return true;
402#endif
55d452c6 403#ifdef __WXCOCOA__
216c3543 404 if (platform == wxPORT_MAC)
230c9077
JS
405 return true;
406#endif
407
408 if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND)
409 return true;
410
411 return false;
412}
413
e90c1d2a 414// ----------------------------------------------------------------------------
7c072018 415// network and user id functions
e90c1d2a 416// ----------------------------------------------------------------------------
c801d85f 417
7c072018
VZ
418// Get Full RFC822 style email address
419bool wxGetEmailAddress(wxChar *address, int maxSize)
c801d85f 420{
7c072018
VZ
421 wxString email = wxGetEmailAddress();
422 if ( !email )
cb719f2e 423 return false;
c801d85f 424
7c072018
VZ
425 wxStrncpy(address, email, maxSize - 1);
426 address[maxSize - 1] = wxT('\0');
427
cb719f2e 428 return true;
c801d85f
KB
429}
430
7c072018 431wxString wxGetEmailAddress()
47bc1060 432{
7c072018 433 wxString email;
974e8d94 434
7c072018 435 wxString host = wxGetFullHostName();
4055ed82 436 if ( !host.empty() )
1e6feb95 437 {
7c072018 438 wxString user = wxGetUserId();
4055ed82 439 if ( !user.empty() )
1e6feb95 440 {
7c072018 441 email << user << wxT('@') << host;
974e8d94 442 }
974e8d94
VZ
443 }
444
7c072018 445 return email;
974e8d94
VZ
446}
447
7c072018 448wxString wxGetUserId()
c801d85f 449{
7c072018 450 static const int maxLoginLen = 256; // FIXME arbitrary number
c801d85f 451
7c072018 452 wxString buf;
4c3ebca9 453 bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen);
c801d85f 454
7c072018
VZ
455 if ( !ok )
456 buf.Empty();
c801d85f 457
7c072018 458 return buf;
c801d85f
KB
459}
460
7c072018 461wxString wxGetUserName()
c801d85f 462{
7c072018 463 static const int maxUserNameLen = 1024; // FIXME arbitrary number
1e6feb95 464
7c072018 465 wxString buf;
4c3ebca9 466 bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen);
7c072018
VZ
467
468 if ( !ok )
469 buf.Empty();
470
471 return buf;
59a12e90
JS
472}
473
7c072018 474wxString wxGetHostName()
59a12e90 475{
7c072018 476 static const size_t hostnameSize = 257;
c67d6888 477
7c072018 478 wxString buf;
4c3ebca9 479 bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
59a12e90 480
7c072018
VZ
481 if ( !ok )
482 buf.Empty();
59a12e90 483
7c072018 484 return buf;
59a12e90
JS
485}
486
7c072018 487wxString wxGetFullHostName()
59a12e90 488{
7c072018 489 static const size_t hostnameSize = 257;
c801d85f 490
7c072018 491 wxString buf;
4c3ebca9 492 bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
7c072018
VZ
493
494 if ( !ok )
495 buf.Empty();
c801d85f 496
7c072018
VZ
497 return buf;
498}
c801d85f 499
7c072018
VZ
500wxString wxGetHomeDir()
501{
502 wxString home;
503 wxGetHomeDir(&home);
c801d85f 504
7c072018
VZ
505 return home;
506}
c801d85f 507
c801d85f
KB
508#if 0
509
7c072018 510wxString wxGetCurrentDir()
c801d85f 511{
7c072018
VZ
512 wxString dir;
513 size_t len = 1024;
514 bool ok;
515 do
516 {
517 ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
518 dir.UngetWriteBuf();
c801d85f 519
7c072018
VZ
520 if ( !ok )
521 {
522 if ( errno != ERANGE )
523 {
524 wxLogSysError(_T("Failed to get current directory"));
c801d85f 525
7c072018
VZ
526 return wxEmptyString;
527 }
3f4a0c5b 528 else
7c072018
VZ
529 {
530 // buffer was too small, retry with a larger one
531 len *= 2;
532 }
3f4a0c5b 533 }
7c072018
VZ
534 //else: ok
535 } while ( !ok );
c801d85f 536
7c072018 537 return dir;
c801d85f
KB
538}
539
7c072018 540#endif // 0
e90c1d2a
VZ
541
542// ----------------------------------------------------------------------------
7c072018 543// wxExecute
e90c1d2a 544// ----------------------------------------------------------------------------
ead7ce10 545
7c072018
VZ
546// wxDoExecuteWithCapture() helper: reads an entire stream into one array
547//
cb719f2e 548// returns true if ok, false if error
7c072018
VZ
549#if wxUSE_STREAMS
550static bool ReadAll(wxInputStream *is, wxArrayString& output)
dfad0599 551{
cb719f2e 552 wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") );
dfad0599 553
7c072018
VZ
554 // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
555 is->Reset();
1e6feb95 556
7c072018 557 wxTextInputStream tis(*is);
1e6feb95 558
cb719f2e 559 bool cont = true;
7c072018 560 while ( cont )
d2f50933 561 {
7c072018
VZ
562 wxString line = tis.ReadLine();
563 if ( is->Eof() )
564 break;
565
566 if ( !*is )
567 {
cb719f2e 568 cont = false;
7c072018
VZ
569 }
570 else
571 {
572 output.Add(line);
573 }
d2f50933
VZ
574 }
575
7c072018 576 return cont;
dfad0599 577}
7c072018 578#endif // wxUSE_STREAMS
d2f50933 579
7c072018
VZ
580// this is a private function because it hasn't a clean interface: the first
581// array is passed by reference, the second by pointer - instead we have 2
582// public versions of wxExecute() below
583static long wxDoExecuteWithCapture(const wxString& command,
584 wxArrayString& output,
4d172154
VZ
585 wxArrayString* error,
586 int flags)
d2f50933 587{
7c072018
VZ
588 // create a wxProcess which will capture the output
589 wxProcess *process = new wxProcess;
590 process->Redirect();
dfad0599 591
4d172154 592 long rc = wxExecute(command, wxEXEC_SYNC | flags, process);
1e6feb95 593
7c072018
VZ
594#if wxUSE_STREAMS
595 if ( rc != -1 )
bf31fa26 596 {
7c072018
VZ
597 if ( !ReadAll(process->GetInputStream(), output) )
598 rc = -1;
91b4c08d 599
7c072018
VZ
600 if ( error )
601 {
602 if ( !ReadAll(process->GetErrorStream(), *error) )
603 rc = -1;
604 }
91b4c08d 605
7c072018 606 }
e70ba80d
WS
607#else
608 wxUnusedVar(output);
609 wxUnusedVar(error);
610#endif // wxUSE_STREAMS/!wxUSE_STREAMS
91b4c08d 611
7c072018 612 delete process;
1e6feb95 613
7c072018 614 return rc;
7c072018 615}
bf31fa26 616
4d172154 617long wxExecute(const wxString& command, wxArrayString& output, int flags)
bf31fa26 618{
4d172154 619 return wxDoExecuteWithCapture(command, output, NULL, flags);
7c072018 620}
bf31fa26 621
7c072018
VZ
622long wxExecute(const wxString& command,
623 wxArrayString& output,
4d172154
VZ
624 wxArrayString& error,
625 int flags)
7c072018 626{
4d172154 627 return wxDoExecuteWithCapture(command, output, &error, flags);
bf31fa26
VZ
628}
629
498a1eeb
RN
630// ----------------------------------------------------------------------------
631// Launch default browser
632// ----------------------------------------------------------------------------
633
42d0df00 634bool wxLaunchDefaultBrowser(const wxString& urlOrig, int flags)
498a1eeb 635{
42d0df00
VZ
636 wxUnusedVar(flags);
637
7999124f 638 // set the scheme of url to http if it does not have one
889fda0c 639 // RR: This doesn't work if the url is just a local path
7999124f 640 wxString url(urlOrig);
6f6dd276
VZ
641 wxURI uri(url);
642 if ( !uri.HasScheme() )
7999124f 643 url.Prepend(wxT("http://"));
889fda0c 644
532d575b 645
7999124f 646#if defined(__WXMSW__)
5ccb95f6
WS
647
648#if wxUSE_IPC
42d0df00
VZ
649 if ( flags & wxBROWSER_NEW_WINDOW )
650 {
651 // ShellExecuteEx() opens the URL in an existing window by default so
652 // we can't use it if we need a new window
6f6dd276
VZ
653 wxRegKey key(wxRegKey::HKCR, uri.GetScheme() + _T("\\shell\\open"));
654 if ( !key.Exists() )
655 {
656 // try default browser, it must be registered at least for http URLs
657 key.SetName(wxRegKey::HKCR, _T("http\\shell\\open"));
658 }
659
42d0df00
VZ
660 if ( key.Exists() )
661 {
662 wxRegKey keyDDE(key, wxT("DDEExec"));
663 if ( keyDDE.Exists() )
664 {
665 const wxString ddeTopic = wxRegKey(keyDDE, wxT("topic"));
666
667 // we only know the syntax of WWW_OpenURL DDE request for IE,
668 // optimistically assume that all other browsers are compatible
669 // with it
670 wxString ddeCmd;
671 bool ok = ddeTopic == wxT("WWW_OpenURL");
672 if ( ok )
673 {
588c80de 674 ddeCmd = keyDDE.QueryDefaultValue();
42d0df00
VZ
675 ok = !ddeCmd.empty();
676 }
677
678 if ( ok )
679 {
680 // for WWW_OpenURL, the index of the window to open the URL
681 // in is -1 (meaning "current") by default, replace it with
682 // 0 which means "new" (see KB article 160957)
683 ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
684 false /* only first occurence */) == 1;
685 }
686
687 if ( ok )
688 {
689 // and also replace the parameters: the topic should
690 // contain a placeholder for the URL
691 ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
692 }
693
694 if ( ok )
695 {
696 // try to send it the DDE request now but ignore the errors
697 wxLogNull noLog;
698
699 const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
700 if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCmd) )
701 return true;
702
703 // this is not necessarily an error: maybe browser is
704 // simply not running, but no matter, in any case we're
705 // going to launch it using ShellExecuteEx() below now and
706 // we shouldn't try to open a new window if we open a new
707 // browser anyhow
708 }
709 }
710 }
711 }
5ccb95f6 712#endif // wxUSE_IPC
42d0df00 713
7999124f
VZ
714 WinStruct<SHELLEXECUTEINFO> sei;
715 sei.lpFile = url.c_str();
716 sei.lpVerb = _T("open");
717 sei.nShow = SW_SHOWNORMAL;
498a1eeb 718
7999124f 719 ::ShellExecuteEx(&sei);
657a7545 720
7999124f 721 const int nResult = (int) sei.hInstApp;
498a1eeb 722
7999124f
VZ
723 // Firefox returns file not found for some reason, so make an exception
724 // for it
725 if ( nResult > 32 || nResult == SE_ERR_FNF )
498a1eeb 726 {
657a7545 727#ifdef __WXDEBUG__
498a1eeb 728 // Log something if SE_ERR_FNF happens
7999124f
VZ
729 if ( nResult == SE_ERR_FNF )
730 wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?"));
731#endif // __WXDEBUG__
732 return true;
657a7545 733 }
f14d6dd1
JS
734#elif defined(__WXMAC__)
735 OSStatus err;
736 ICInstance inst;
fb743cab
SC
737 long int startSel;
738 long int endSel;
f14d6dd1
JS
739
740 err = ICStart(&inst, 'STKA'); // put your app creator code here
13a1e96f
DS
741 if (err == noErr)
742 {
f14d6dd1 743#if !TARGET_CARBON
13a1e96f 744 err = ICFindConfigFile(inst, 0, NULL);
f14d6dd1
JS
745#endif
746 if (err == noErr)
747 {
748 ConstStr255Param hint = 0;
749 startSel = 0;
76b49cf4 750 endSel = url.length();
f14d6dd1
JS
751 err = ICLaunchURL(inst, hint, url.fn_str(), endSel, &startSel, &endSel);
752 if (err != noErr)
753 wxLogDebug(wxT("ICLaunchURL error %d"), (int) err);
754 }
755 ICStop(inst);
756 return true;
757 }
758 else
759 {
760 wxLogDebug(wxT("ICStart error %d"), (int) err);
761 return false;
762 }
889fda0c
RR
763#else
764 // (non-Mac, non-MSW)
765
766#ifdef __UNIX__
17ede0b1
RR
767
768 wxString desktop = wxTheApp->GetTraits()->GetDesktopEnvironment();
769
770 // GNOME and KDE desktops have some applications which should be always installed
771 // together with their main parts, which give us the
772 if (desktop == wxT("GNOME"))
889fda0c
RR
773 {
774 wxArrayString errors;
775 wxArrayString output;
17ede0b1
RR
776
777 // gconf will tell us the path of the application to use as browser
778 long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"),
779 output, errors, wxEXEC_NODISABLE );
889fda0c
RR
780 if (res >= 0 && errors.GetCount() == 0)
781 {
782 wxString cmd = output[0];
783 cmd << _T(' ') << url;
784 if (wxExecute(cmd))
785 return true;
786 }
787 }
17ede0b1
RR
788 else if (desktop == wxT("KDE"))
789 {
790 // kfmclient directly opens the given URL
791 if (wxExecute(wxT("kfmclient openURL ") + url))
792 return true;
793 }
889fda0c
RR
794#endif
795
13a1e96f
DS
796 bool ok = false;
797 wxString cmd;
798
1b1b5318 799#if wxUSE_MIMETYPE
13a1e96f 800 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
7999124f 801 if ( ft )
657a7545 802 {
7999124f
VZ
803 wxString mt;
804 ft->GetMimeType(&mt);
498a1eeb 805
13a1e96f 806 ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
7999124f 807 delete ft;
498a1eeb 808 }
1b1b5318 809#endif // wxUSE_MIMETYPE
13a1e96f
DS
810
811 if ( !ok || cmd.empty() )
2830b4a4 812 {
13a1e96f
DS
813 // fallback to checking for the BROWSER environment variable
814 cmd = wxGetenv(wxT("BROWSER"));
815 if ( !cmd.empty() )
816 cmd << _T(' ') << url;
2830b4a4 817 }
13a1e96f
DS
818
819 ok = ( !cmd.empty() && wxExecute(cmd) );
820 if (ok)
821 return ok;
822
823 // no file type for HTML extension
824 wxLogError(_T("No default application configured for HTML files."));
825
7999124f 826#endif // !wxUSE_MIMETYPE && !__WXMSW__
532d575b 827
7999124f
VZ
828 wxLogSysError(_T("Failed to open URL \"%s\" in default browser."),
829 url.c_str());
657a7545 830
7999124f 831 return false;
498a1eeb
RN
832}
833
91b4c08d 834// ----------------------------------------------------------------------------
7c072018 835// wxApp::Yield() wrappers for backwards compatibility
91b4c08d
VZ
836// ----------------------------------------------------------------------------
837
7c072018 838bool wxYield()
469e1e5c 839{
7c072018 840 return wxTheApp && wxTheApp->Yield();
469e1e5c 841}
7c072018
VZ
842
843bool wxYieldIfNeeded()
469e1e5c 844{
cb719f2e 845 return wxTheApp && wxTheApp->Yield(true);
469e1e5c 846}
7c072018 847
ec67cff1 848#endif // wxUSE_BASE
7c072018
VZ
849
850// ============================================================================
851// GUI-only functions from now on
852// ============================================================================
853
854#if wxUSE_GUI
855
4c3ebca9
MB
856// Id generation
857static long wxCurrentId = 100;
858
c838b68e 859long wxNewId()
4c3ebca9 860{
c838b68e
VS
861 // skip the part of IDs space that contains hard-coded values:
862 if (wxCurrentId == wxID_LOWEST)
863 wxCurrentId = wxID_HIGHEST + 1;
864
865 return wxCurrentId++;
4c3ebca9
MB
866}
867
868long
869wxGetCurrentId(void) { return wxCurrentId; }
870
871void
872wxRegisterId (long id)
873{
874 if (id >= wxCurrentId)
875 wxCurrentId = id + 1;
876}
877
e90c1d2a 878// ----------------------------------------------------------------------------
7c072018 879// Menu accelerators related functions
e90c1d2a
VZ
880// ----------------------------------------------------------------------------
881
7c072018 882wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
e90c1d2a 883{
9a6384ca 884#if wxUSE_MENUS
7c072018 885 wxString s = wxMenuItem::GetLabelFromText(in);
9a6384ca
WS
886#else
887 wxString str(in);
888 wxString s = wxStripMenuCodes(str);
889#endif // wxUSE_MENUS
7c072018
VZ
890 if ( out )
891 {
892 // go smash their buffer if it's not big enough - I love char * params
893 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
894 }
895 else
896 {
f526f752
MB
897 // MYcopystring - for easier search...
898 out = new wxChar[s.length() + 1];
899 wxStrcpy(out, s.c_str());
7c072018
VZ
900 }
901
902 return out;
e90c1d2a
VZ
903}
904
74639764 905wxString wxStripMenuCodes(const wxString& in, int flags)
e90c1d2a 906{
74639764
VZ
907 wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
908
7c072018 909 wxString out;
79f585d9 910
7c072018
VZ
911 size_t len = in.length();
912 out.reserve(len);
79f585d9 913
7c072018
VZ
914 for ( size_t n = 0; n < len; n++ )
915 {
916 wxChar ch = in[n];
74639764 917 if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
cd6ce4a9 918 {
7c072018
VZ
919 // skip it, it is used to introduce the accel char (or to quote
920 // itself in which case it should still be skipped): note that it
921 // can't be the last character of the string
922 if ( ++n == len )
79f585d9 923 {
7c072018
VZ
924 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
925 }
926 else
927 {
928 // use the next char instead
929 ch = in[n];
79f585d9 930 }
cd6ce4a9 931 }
74639764 932 else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
79f585d9 933 {
7c072018
VZ
934 // everything after TAB is accel string, exit the loop
935 break;
79f585d9 936 }
7c072018
VZ
937
938 out += ch;
225fe9d6
VZ
939 }
940
7c072018 941 return out;
cd6ce4a9
VZ
942}
943
cbc66a27 944// ----------------------------------------------------------------------------
7c072018 945// Window search functions
cbc66a27
VZ
946// ----------------------------------------------------------------------------
947
7c072018
VZ
948/*
949 * If parent is non-NULL, look through children for a label or title
950 * matching the specified string. If NULL, look through all top-level windows.
951 *
952 */
e2a6f233 953
7c072018
VZ
954wxWindow *
955wxFindWindowByLabel (const wxString& title, wxWindow * parent)
134677bd 956{
7c072018
VZ
957 return wxWindow::FindWindowByLabel( title, parent );
958}
b829bf55 959
b829bf55 960
7c072018
VZ
961/*
962 * If parent is non-NULL, look through children for a name
963 * matching the specified string. If NULL, look through all top-level windows.
964 *
965 */
134677bd 966
7c072018
VZ
967wxWindow *
968wxFindWindowByName (const wxString& name, wxWindow * parent)
2c18f21d 969{
7c072018 970 return wxWindow::FindWindowByName( name, parent );
2c18f21d
VS
971}
972
cb719f2e 973// Returns menu item id or wxNOT_FOUND if none.
7c072018
VZ
974int
975wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
e2a6f233 976{
7c072018 977#if wxUSE_MENUS
9a6384ca
WS
978 wxMenuBar *menuBar = frame->GetMenuBar ();
979 if ( menuBar )
980 return menuBar->FindMenuItem (menuString, itemString);
7c072018 981#endif // wxUSE_MENUS
0fb67cd1 982
9a6384ca 983 return wxNOT_FOUND;
e2a6f233
JS
984}
985
7c072018
VZ
986// Try to find the deepest child that contains 'pt'.
987// We go backwards, to try to allow for controls that are spacially
988// within other controls, but are still siblings (e.g. buttons within
989// static boxes). Static boxes are likely to be created _before_ controls
990// that sit inside them.
991wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
e2a6f233 992{
7c072018
VZ
993 if (!win->IsShown())
994 return NULL;
0fb67cd1 995
7c072018
VZ
996 // Hack for wxNotebook case: at least in wxGTK, all pages
997 // claim to be shown, so we must only deal with the selected one.
998#if wxUSE_NOTEBOOK
999 if (win->IsKindOf(CLASSINFO(wxNotebook)))
e2a6f233 1000 {
7c072018
VZ
1001 wxNotebook* nb = (wxNotebook*) win;
1002 int sel = nb->GetSelection();
1003 if (sel >= 0)
1004 {
1005 wxWindow* child = nb->GetPage(sel);
1006 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1007 if (foundWin)
1008 return foundWin;
1009 }
e2a6f233 1010 }
7c072018 1011#endif
0fb67cd1 1012
df5168c4 1013 wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
7c072018
VZ
1014 while (node)
1015 {
1016 wxWindow* child = node->GetData();
1017 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1018 if (foundWin)
1019 return foundWin;
1020 node = node->GetPrevious();
1021 }
1022
1023 wxPoint pos = win->GetPosition();
1024 wxSize sz = win->GetSize();
7aa7d2d4 1025 if ( !win->IsTopLevel() && win->GetParent() )
7c072018
VZ
1026 {
1027 pos = win->GetParent()->ClientToScreen(pos);
1028 }
1029
1030 wxRect rect(pos, sz);
22a35096 1031 if (rect.Contains(pt))
7c072018 1032 return win;
622eb786
VZ
1033
1034 return NULL;
0fb67cd1
VZ
1035}
1036
7c072018 1037wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
0fb67cd1 1038{
7c072018
VZ
1039 // Go backwards through the list since windows
1040 // on top are likely to have been appended most
1041 // recently.
df5168c4 1042 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
7c072018
VZ
1043 while (node)
1044 {
1045 wxWindow* win = node->GetData();
1046 wxWindow* found = wxFindWindowAtPoint(win, pt);
1047 if (found)
1048 return found;
1049 node = node->GetPrevious();
1050 }
1051 return NULL;
1052}
0fb67cd1 1053
7c072018
VZ
1054// ----------------------------------------------------------------------------
1055// GUI helpers
1056// ----------------------------------------------------------------------------
0fb67cd1 1057
7c072018
VZ
1058/*
1059 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1060 * since otherwise the generic code may be pulled in unnecessarily.
1061 */
0fb67cd1 1062
7c072018 1063#if wxUSE_MSGDLG
0fb67cd1 1064
7c072018
VZ
1065int wxMessageBox(const wxString& message, const wxString& caption, long style,
1066 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
0fb67cd1 1067{
53a6ac21
DS
1068 long decorated_style = style;
1069
1070 if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1071 {
1072 decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1073 }
1074
1075 wxMessageDialog dialog(parent, message, caption, decorated_style);
0fb67cd1 1076
7c072018
VZ
1077 int ans = dialog.ShowModal();
1078 switch ( ans )
1079 {
1080 case wxID_OK:
1081 return wxOK;
1082 case wxID_YES:
1083 return wxYES;
1084 case wxID_NO:
1085 return wxNO;
1086 case wxID_CANCEL:
1087 return wxCANCEL;
1088 }
0fb67cd1 1089
7c072018 1090 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
0fb67cd1 1091
7c072018 1092 return wxCANCEL;
e2a6f233
JS
1093}
1094
7c072018 1095#endif // wxUSE_MSGDLG
518b5d2f 1096
7c072018 1097#if wxUSE_TEXTDLG
518b5d2f 1098
7c072018
VZ
1099wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1100 const wxString& defaultValue, wxWindow *parent,
13d13a9e 1101 wxCoord x, wxCoord y, bool centre )
7c072018
VZ
1102{
1103 wxString str;
13d13a9e
WS
1104 long style = wxTextEntryDialogStyle;
1105
1106 if (centre)
1107 style |= wxCENTRE;
1108 else
1109 style &= ~wxCENTRE;
1110
1111 wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1112
7c072018
VZ
1113 if (dialog.ShowModal() == wxID_OK)
1114 {
1115 str = dialog.GetValue();
1116 }
0fb67cd1 1117
7c072018 1118 return str;
518b5d2f
VZ
1119}
1120
7c072018
VZ
1121wxString wxGetPasswordFromUser(const wxString& message,
1122 const wxString& caption,
1123 const wxString& defaultValue,
b3bb2a74
KH
1124 wxWindow *parent,
1125 wxCoord x, wxCoord y, bool centre )
96c5bd7f 1126{
7c072018 1127 wxString str;
b3bb2a74
KH
1128 long style = wxTextEntryDialogStyle;
1129
1130 if (centre)
1131 style |= wxCENTRE;
1132 else
1133 style &= ~wxCENTRE;
1134
12cfa304
KH
1135 wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1136 style, wxPoint(x, y));
7c072018
VZ
1137 if ( dialog.ShowModal() == wxID_OK )
1138 {
1139 str = dialog.GetValue();
1140 }
96c5bd7f 1141
7c072018
VZ
1142 return str;
1143}
96c5bd7f 1144
7c072018 1145#endif // wxUSE_TEXTDLG
96c5bd7f 1146
7c072018 1147#if wxUSE_COLOURDLG
96c5bd7f 1148
f14d6dd1 1149wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit, const wxString& caption)
c51deffc 1150{
7c072018 1151 wxColourData data;
cb719f2e 1152 data.SetChooseFull(true);
7c072018
VZ
1153 if ( colInit.Ok() )
1154 {
1155 data.SetColour((wxColour &)colInit); // const_cast
1156 }
c51deffc 1157
7c072018
VZ
1158 wxColour colRet;
1159 wxColourDialog dialog(parent, &data);
76b49cf4 1160 if (!caption.empty())
f14d6dd1 1161 dialog.SetTitle(caption);
7c072018
VZ
1162 if ( dialog.ShowModal() == wxID_OK )
1163 {
1164 colRet = dialog.GetColourData().GetColour();
1165 }
1166 //else: leave it invalid
1167
1168 return colRet;
c51deffc 1169}
bc385ba9 1170
7c072018 1171#endif // wxUSE_COLOURDLG
bc385ba9 1172
7c072018
VZ
1173#if wxUSE_FONTDLG
1174
f14d6dd1 1175wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
bc385ba9 1176{
7c072018
VZ
1177 wxFontData data;
1178 if ( fontInit.Ok() )
bc385ba9 1179 {
7c072018
VZ
1180 data.SetInitialFont(fontInit);
1181 }
bc385ba9 1182
7c072018
VZ
1183 wxFont fontRet;
1184 wxFontDialog dialog(parent, data);
76b49cf4 1185 if (!caption.empty())
f14d6dd1 1186 dialog.SetTitle(caption);
7c072018
VZ
1187 if ( dialog.ShowModal() == wxID_OK )
1188 {
1189 fontRet = dialog.GetFontData().GetChosenFont();
1190 }
1191 //else: leave it invalid
bc385ba9 1192
7c072018 1193 return fontRet;
bc385ba9
VZ
1194}
1195
7c072018 1196#endif // wxUSE_FONTDLG
2b5f62a0 1197
7c072018
VZ
1198// ----------------------------------------------------------------------------
1199// wxSafeYield and supporting functions
1200// ----------------------------------------------------------------------------
2b5f62a0 1201
7c072018
VZ
1202void wxEnableTopLevelWindows(bool enable)
1203{
df5168c4 1204 wxWindowList::compatibility_iterator node;
7c072018
VZ
1205 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1206 node->GetData()->Enable(enable);
1207}
2b5f62a0 1208
7c072018
VZ
1209wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1210{
1211 // remember the top level windows which were already disabled, so that we
1212 // don't reenable them later
1213 m_winDisabled = NULL;
1214
df5168c4 1215 wxWindowList::compatibility_iterator node;
7c072018 1216 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
2b5f62a0 1217 {
7c072018
VZ
1218 wxWindow *winTop = node->GetData();
1219 if ( winTop == winToSkip )
1220 continue;
2b5f62a0 1221
7c072018
VZ
1222 // we don't need to disable the hidden or already disabled windows
1223 if ( winTop->IsEnabled() && winTop->IsShown() )
2b5f62a0 1224 {
7c072018 1225 winTop->Disable();
2b5f62a0
VZ
1226 }
1227 else
1228 {
7c072018
VZ
1229 if ( !m_winDisabled )
1230 {
1231 m_winDisabled = new wxWindowList;
1232 }
1233
1234 m_winDisabled->Append(winTop);
2b5f62a0
VZ
1235 }
1236 }
2b5f62a0
VZ
1237}
1238
7c072018 1239wxWindowDisabler::~wxWindowDisabler()
cd6ce4a9 1240{
df5168c4 1241 wxWindowList::compatibility_iterator node;
7c072018 1242 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
cd6ce4a9 1243 {
7c072018
VZ
1244 wxWindow *winTop = node->GetData();
1245 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
cd6ce4a9 1246 {
7c072018 1247 winTop->Enable();
cd6ce4a9 1248 }
7c072018 1249 //else: had been already disabled, don't reenable
cd6ce4a9 1250 }
f6bcfd97 1251
7c072018 1252 delete m_winDisabled;
f6bcfd97
BP
1253}
1254
7c072018
VZ
1255// Yield to other apps/messages and disable user input to all windows except
1256// the given one
1257bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
f6bcfd97 1258{
7c072018 1259 wxWindowDisabler wd(win);
21709999 1260
7c072018
VZ
1261 bool rc;
1262 if (onlyIfNeeded)
1263 rc = wxYieldIfNeeded();
1264 else
1265 rc = wxYield();
8461e4c2 1266
7c072018 1267 return rc;
8461e4c2
VZ
1268}
1269
7c072018
VZ
1270// Don't synthesize KeyUp events holding down a key and producing KeyDown
1271// events with autorepeat. On by default and always on in wxMSW. wxGTK version
1272// in utilsgtk.cpp.
1273#ifndef __WXGTK__
1274bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
8461e4c2 1275{
cb719f2e 1276 return true; // detectable auto-repeat is the only mode MSW supports
8461e4c2 1277}
7c072018
VZ
1278#endif // !wxGTK
1279
1280#endif // wxUSE_GUI