]> git.saurik.com Git - wxWidgets.git/blame - src/common/utilscmn.cpp
Fix deletes that should be delete[]
[wxWidgets.git] / src / common / utilscmn.cpp
CommitLineData
c801d85f
KB
1/////////////////////////////////////////////////////////////////////////////
2// Name: utilscmn.cpp
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
e4844687
SN
20#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && !defined(__EMX__)
21// Some older compilers (such as EMX) cannot handle
13d13a9e 22// #pragma interface/implementation correctly, iff
e4844687
SN
23// #pragma implementation is used in _two_ translation
24// units (as created by e.g. event.cpp compiled for
25// libwx_base and event.cpp compiled for libwx_gui_core).
26// So we must not use those pragmas for those compilers in
27// such files.
e90c1d2a 28 #pragma implementation "utils.h"
c801d85f
KB
29#endif
30
31// For compilers that support precompilation, includes "wx.h".
32#include "wx/wxprec.h"
33
34#ifdef __BORLANDC__
e90c1d2a 35 #pragma hdrstop
c801d85f
KB
36#endif
37
38#ifndef WX_PRECOMP
fcdb9b38 39 #include "wx/app.h"
e90c1d2a
VZ
40 #include "wx/string.h"
41 #include "wx/utils.h"
974e8d94
VZ
42 #include "wx/intl.h"
43 #include "wx/log.h"
e90c1d2a
VZ
44
45 #if wxUSE_GUI
46 #include "wx/window.h"
e90c1d2a 47 #include "wx/frame.h"
1e6feb95 48 #include "wx/menu.h"
e90c1d2a
VZ
49 #include "wx/msgdlg.h"
50 #include "wx/textdlg.h"
78bcfcfc 51 #include "wx/textctrl.h" // for wxTE_PASSWORD
974e8d94
VZ
52 #if wxUSE_ACCEL
53 #include "wx/menuitem.h"
54 #include "wx/accel.h"
55 #endif // wxUSE_ACCEL
e90c1d2a
VZ
56 #endif // wxUSE_GUI
57#endif // WX_PRECOMP
c801d85f 58
2739d4f0
VZ
59#include "wx/apptrait.h"
60
cd6ce4a9
VZ
61#include "wx/process.h"
62#include "wx/txtstrm.h"
498a1eeb
RN
63#include "wx/uri.h"
64#include "wx/mimetype.h"
65#include "wx/config.h"
cd6ce4a9 66
4676948b
JS
67#if defined(__WXWINCE__) && wxUSE_DATETIME
68#include "wx/datetime.h"
69#endif
70
c801d85f
KB
71#include <ctype.h>
72#include <stdio.h>
73#include <stdlib.h>
74#include <string.h>
e90c1d2a 75
c801d85f 76#if !defined(__WATCOMC__)
3f4a0c5b
VZ
77 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
78 #include <errno.h>
79 #endif
c801d85f 80#endif
e90c1d2a 81
91b4c08d
VZ
82#if wxUSE_GUI
83 #include "wx/colordlg.h"
bf31fa26 84 #include "wx/fontdlg.h"
d1c8aaa3
JS
85 #include "wx/notebook.h"
86 #include "wx/frame.h"
87 #include "wx/statusbr.h"
91b4c08d
VZ
88#endif // wxUSE_GUI
89
1c193821 90#ifndef __WXWINCE__
c801d85f 91#include <time.h>
1c193821
JS
92#else
93#include "wx/msw/wince/time.h"
94#endif
e90c1d2a 95
4676948b 96#if !defined(__MWERKS__) && !defined(__WXWINCE__)
e90c1d2a
VZ
97 #include <sys/types.h>
98 #include <sys/stat.h>
469e1e5c 99#endif
c801d85f 100
82ef81ed 101#if defined(__WXMSW__)
5e1febfa 102 #include "wx/msw/private.h"
c801d85f
KB
103#endif
104
ec67cff1 105#if wxUSE_BASE
7c072018 106
73deed44
VZ
107// ----------------------------------------------------------------------------
108// common data
109// ----------------------------------------------------------------------------
110
111#if WXWIN_COMPATIBILITY_2_2
77ffb593
JS
112 const wxChar *wxInternalErrorStr = wxT("wxWidgets Internal Error");
113 const wxChar *wxFatalErrorStr = wxT("wxWidgets Fatal Error");
73deed44
VZ
114#endif // WXWIN_COMPATIBILITY_2_2
115
e90c1d2a
VZ
116// ============================================================================
117// implementation
118// ============================================================================
c801d85f 119
7c072018
VZ
120#if WXWIN_COMPATIBILITY_2_4
121
0080691b
OK
122wxChar *
123copystring (const wxChar *s)
c801d85f 124{
657a7545
WS
125 if (s == NULL) s = wxEmptyString;
126 size_t len = wxStrlen (s) + 1;
c801d85f 127
657a7545
WS
128 wxChar *news = new wxChar[len];
129 memcpy (news, s, len * sizeof(wxChar)); // Should be the fastest
c801d85f 130
657a7545 131 return news;
c801d85f
KB
132}
133
7c072018
VZ
134#endif // WXWIN_COMPATIBILITY_2_4
135
e12c92c2
VZ
136// ----------------------------------------------------------------------------
137// String <-> Number conversions (deprecated)
138// ----------------------------------------------------------------------------
139
140#if WXWIN_COMPATIBILITY_2_4
141
fd242375
VS
142WXDLLIMPEXP_DATA_BASE(const wxChar *) wxFloatToStringStr = wxT("%.2f");
143WXDLLIMPEXP_DATA_BASE(const wxChar *) wxDoubleToStringStr = wxT("%.2f");
e12c92c2 144
3f4a0c5b 145void
bc87fd68 146StringToFloat (const wxChar *s, float *number)
c801d85f 147{
657a7545
WS
148 if (s && *s && number)
149 *number = (float) wxStrtod (s, (wxChar **) NULL);
c801d85f
KB
150}
151
3f4a0c5b 152void
bc87fd68 153StringToDouble (const wxChar *s, double *number)
c801d85f 154{
657a7545
WS
155 if (s && *s && number)
156 *number = wxStrtod (s, (wxChar **) NULL);
c801d85f
KB
157}
158
0080691b
OK
159wxChar *
160FloatToString (float number, const wxChar *fmt)
c801d85f 161{
657a7545 162 static wxChar buf[256];
c801d85f 163
657a7545
WS
164 wxSprintf (buf, fmt, number);
165 return buf;
c801d85f
KB
166}
167
0080691b
OK
168wxChar *
169DoubleToString (double number, const wxChar *fmt)
c801d85f 170{
657a7545 171 static wxChar buf[256];
c801d85f 172
657a7545
WS
173 wxSprintf (buf, fmt, number);
174 return buf;
c801d85f
KB
175}
176
3f4a0c5b 177void
bc87fd68 178StringToInt (const wxChar *s, int *number)
c801d85f 179{
657a7545
WS
180 if (s && *s && number)
181 *number = (int) wxStrtol (s, (wxChar **) NULL, 10);
c801d85f
KB
182}
183
3f4a0c5b 184void
bc87fd68 185StringToLong (const wxChar *s, long *number)
c801d85f 186{
657a7545
WS
187 if (s && *s && number)
188 *number = wxStrtol (s, (wxChar **) NULL, 10);
c801d85f
KB
189}
190
84fff0b3 191wxChar *
c801d85f
KB
192IntToString (int number)
193{
657a7545 194 static wxChar buf[20];
c801d85f 195
657a7545
WS
196 wxSprintf (buf, wxT("%d"), number);
197 return buf;
c801d85f
KB
198}
199
84fff0b3 200wxChar *
c801d85f
KB
201LongToString (long number)
202{
657a7545 203 static wxChar buf[20];
c801d85f 204
657a7545
WS
205 wxSprintf (buf, wxT("%ld"), number);
206 return buf;
c801d85f
KB
207}
208
e12c92c2
VZ
209#endif // WXWIN_COMPATIBILITY_2_4
210
c801d85f 211// Array used in DecToHex conversion routine.
223d09f6 212static wxChar hexArray[] = wxT("0123456789ABCDEF");
c801d85f
KB
213
214// Convert 2-digit hex number to decimal
fd71308f 215int wxHexToDec(const wxString& buf)
c801d85f 216{
657a7545 217 int firstDigit, secondDigit;
3f4a0c5b 218
657a7545
WS
219 if (buf.GetChar(0) >= wxT('A'))
220 firstDigit = buf.GetChar(0) - wxT('A') + 10;
221 else
222 firstDigit = buf.GetChar(0) - wxT('0');
c801d85f 223
657a7545
WS
224 if (buf.GetChar(1) >= wxT('A'))
225 secondDigit = buf.GetChar(1) - wxT('A') + 10;
226 else
227 secondDigit = buf.GetChar(1) - wxT('0');
3f4a0c5b 228
657a7545 229 return (firstDigit & 0xF) * 16 + (secondDigit & 0xF );
c801d85f
KB
230}
231
232// Convert decimal integer to 2-character hex string
84fff0b3 233void wxDecToHex(int dec, wxChar *buf)
c801d85f 234{
657a7545
WS
235 int firstDigit = (int)(dec/16.0);
236 int secondDigit = (int)(dec - (firstDigit*16.0));
237 buf[0] = hexArray[firstDigit];
238 buf[1] = hexArray[secondDigit];
239 buf[2] = 0;
c801d85f
KB
240}
241
fd71308f
JS
242// Convert decimal integer to 2-character hex string
243wxString wxDecToHex(int dec)
244{
84fff0b3 245 wxChar buf[3];
fd71308f
JS
246 wxDecToHex(dec, buf);
247 return wxString(buf);
248}
249
7c072018
VZ
250// ----------------------------------------------------------------------------
251// misc functions
252// ----------------------------------------------------------------------------
c801d85f
KB
253
254// Return the current date/time
e90c1d2a 255wxString wxNow()
c801d85f 256{
4676948b
JS
257#ifdef __WXWINCE__
258#if wxUSE_DATETIME
259 wxDateTime now = wxDateTime::Now();
260 return now.Format();
261#else
262 return wxEmptyString;
263#endif
264#else
2b5f62a0
VZ
265 time_t now = time((time_t *) NULL);
266 char *date = ctime(&now);
267 date[24] = '\0';
268 return wxString::FromAscii(date);
4676948b 269#endif
c801d85f
KB
270}
271
08873d36
VZ
272void wxUsleep(unsigned long milliseconds)
273{
274 wxMilliSleep(milliseconds);
275}
276
7c072018
VZ
277const wxChar *wxGetInstallPrefix()
278{
279 wxString prefix;
280
281 if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
282 return prefix.c_str();
283
284#ifdef wxINSTALL_PREFIX
285 return wxT(wxINSTALL_PREFIX);
286#else
525d8583 287 return wxEmptyString;
7c072018
VZ
288#endif
289}
290
291wxString wxGetDataDir()
292{
10f206ad
RL
293 wxString dir = wxGetInstallPrefix();
294 dir << wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx");
7c072018
VZ
295 return dir;
296}
e90c1d2a 297
2739d4f0
VZ
298int wxGetOsVersion(int *verMaj, int *verMin)
299{
300 // we want this function to work even if there is no wxApp
301 wxConsoleAppTraits traitsConsole;
302 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
303 if ( ! traits )
304 traits = &traitsConsole;
305
324899f6 306 wxToolkitInfo& info = traits->GetToolkitInfo();
a8eaaeb2 307 if ( verMaj )
324899f6 308 *verMaj = info.versionMajor;
a8eaaeb2 309 if ( verMin )
324899f6
VS
310 *verMin = info.versionMinor;
311 return info.os;
2739d4f0 312}
1e6feb95 313
e90c1d2a 314// ----------------------------------------------------------------------------
7c072018 315// network and user id functions
e90c1d2a 316// ----------------------------------------------------------------------------
c801d85f 317
7c072018
VZ
318// Get Full RFC822 style email address
319bool wxGetEmailAddress(wxChar *address, int maxSize)
c801d85f 320{
7c072018
VZ
321 wxString email = wxGetEmailAddress();
322 if ( !email )
cb719f2e 323 return false;
c801d85f 324
7c072018
VZ
325 wxStrncpy(address, email, maxSize - 1);
326 address[maxSize - 1] = wxT('\0');
327
cb719f2e 328 return true;
c801d85f
KB
329}
330
7c072018 331wxString wxGetEmailAddress()
47bc1060 332{
7c072018 333 wxString email;
974e8d94 334
7c072018 335 wxString host = wxGetFullHostName();
4055ed82 336 if ( !host.empty() )
1e6feb95 337 {
7c072018 338 wxString user = wxGetUserId();
4055ed82 339 if ( !user.empty() )
1e6feb95 340 {
7c072018 341 email << user << wxT('@') << host;
974e8d94 342 }
974e8d94
VZ
343 }
344
7c072018 345 return email;
974e8d94
VZ
346}
347
7c072018 348wxString wxGetUserId()
c801d85f 349{
7c072018 350 static const int maxLoginLen = 256; // FIXME arbitrary number
c801d85f 351
7c072018 352 wxString buf;
4c3ebca9 353 bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen);
c801d85f 354
7c072018
VZ
355 if ( !ok )
356 buf.Empty();
c801d85f 357
7c072018 358 return buf;
c801d85f
KB
359}
360
7c072018 361wxString wxGetUserName()
c801d85f 362{
7c072018 363 static const int maxUserNameLen = 1024; // FIXME arbitrary number
1e6feb95 364
7c072018 365 wxString buf;
4c3ebca9 366 bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen);
7c072018
VZ
367
368 if ( !ok )
369 buf.Empty();
370
371 return buf;
59a12e90
JS
372}
373
7c072018 374wxString wxGetHostName()
59a12e90 375{
7c072018 376 static const size_t hostnameSize = 257;
c67d6888 377
7c072018 378 wxString buf;
4c3ebca9 379 bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
59a12e90 380
7c072018
VZ
381 if ( !ok )
382 buf.Empty();
59a12e90 383
7c072018 384 return buf;
59a12e90
JS
385}
386
7c072018 387wxString wxGetFullHostName()
59a12e90 388{
7c072018 389 static const size_t hostnameSize = 257;
c801d85f 390
7c072018 391 wxString buf;
4c3ebca9 392 bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
7c072018
VZ
393
394 if ( !ok )
395 buf.Empty();
c801d85f 396
7c072018
VZ
397 return buf;
398}
c801d85f 399
7c072018
VZ
400wxString wxGetHomeDir()
401{
402 wxString home;
403 wxGetHomeDir(&home);
c801d85f 404
7c072018
VZ
405 return home;
406}
c801d85f 407
c801d85f
KB
408#if 0
409
7c072018 410wxString wxGetCurrentDir()
c801d85f 411{
7c072018
VZ
412 wxString dir;
413 size_t len = 1024;
414 bool ok;
415 do
416 {
417 ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
418 dir.UngetWriteBuf();
c801d85f 419
7c072018
VZ
420 if ( !ok )
421 {
422 if ( errno != ERANGE )
423 {
424 wxLogSysError(_T("Failed to get current directory"));
c801d85f 425
7c072018
VZ
426 return wxEmptyString;
427 }
3f4a0c5b 428 else
7c072018
VZ
429 {
430 // buffer was too small, retry with a larger one
431 len *= 2;
432 }
3f4a0c5b 433 }
7c072018
VZ
434 //else: ok
435 } while ( !ok );
c801d85f 436
7c072018 437 return dir;
c801d85f
KB
438}
439
7c072018 440#endif // 0
e90c1d2a
VZ
441
442// ----------------------------------------------------------------------------
7c072018 443// wxExecute
e90c1d2a 444// ----------------------------------------------------------------------------
ead7ce10 445
7c072018
VZ
446// wxDoExecuteWithCapture() helper: reads an entire stream into one array
447//
cb719f2e 448// returns true if ok, false if error
7c072018
VZ
449#if wxUSE_STREAMS
450static bool ReadAll(wxInputStream *is, wxArrayString& output)
dfad0599 451{
cb719f2e 452 wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") );
dfad0599 453
7c072018
VZ
454 // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
455 is->Reset();
1e6feb95 456
7c072018 457 wxTextInputStream tis(*is);
1e6feb95 458
cb719f2e 459 bool cont = true;
7c072018 460 while ( cont )
d2f50933 461 {
7c072018
VZ
462 wxString line = tis.ReadLine();
463 if ( is->Eof() )
464 break;
465
466 if ( !*is )
467 {
cb719f2e 468 cont = false;
7c072018
VZ
469 }
470 else
471 {
472 output.Add(line);
473 }
d2f50933
VZ
474 }
475
7c072018 476 return cont;
dfad0599 477}
7c072018 478#endif // wxUSE_STREAMS
d2f50933 479
7c072018
VZ
480// this is a private function because it hasn't a clean interface: the first
481// array is passed by reference, the second by pointer - instead we have 2
482// public versions of wxExecute() below
483static long wxDoExecuteWithCapture(const wxString& command,
484 wxArrayString& output,
4d172154
VZ
485 wxArrayString* error,
486 int flags)
d2f50933 487{
7c072018
VZ
488 // create a wxProcess which will capture the output
489 wxProcess *process = new wxProcess;
490 process->Redirect();
dfad0599 491
4d172154 492 long rc = wxExecute(command, wxEXEC_SYNC | flags, process);
1e6feb95 493
7c072018
VZ
494#if wxUSE_STREAMS
495 if ( rc != -1 )
bf31fa26 496 {
7c072018
VZ
497 if ( !ReadAll(process->GetInputStream(), output) )
498 rc = -1;
91b4c08d 499
7c072018
VZ
500 if ( error )
501 {
502 if ( !ReadAll(process->GetErrorStream(), *error) )
503 rc = -1;
504 }
91b4c08d 505
7c072018 506 }
e70ba80d
WS
507#else
508 wxUnusedVar(output);
509 wxUnusedVar(error);
510#endif // wxUSE_STREAMS/!wxUSE_STREAMS
91b4c08d 511
7c072018 512 delete process;
1e6feb95 513
7c072018 514 return rc;
7c072018 515}
bf31fa26 516
4d172154 517long wxExecute(const wxString& command, wxArrayString& output, int flags)
bf31fa26 518{
4d172154 519 return wxDoExecuteWithCapture(command, output, NULL, flags);
7c072018 520}
bf31fa26 521
7c072018
VZ
522long wxExecute(const wxString& command,
523 wxArrayString& output,
4d172154
VZ
524 wxArrayString& error,
525 int flags)
7c072018 526{
4d172154 527 return wxDoExecuteWithCapture(command, output, &error, flags);
bf31fa26
VZ
528}
529
498a1eeb
RN
530// ----------------------------------------------------------------------------
531// Launch default browser
532// ----------------------------------------------------------------------------
533
534bool wxLaunchDefaultBrowser(const wxString& url)
535{
532d575b
WS
536 bool success = true;
537
498a1eeb
RN
538 wxString finalurl = url;
539
540 //if it isn't a full url, try appending http:// to it
541 if(wxURI(url).IsReference())
542 finalurl = wxString(wxT("http://")) + url;
543
657a7545
WS
544#if defined(__WXMSW__) && wxUSE_CONFIG_NATIVE
545
498a1eeb
RN
546 wxString command;
547
548 // ShellExecute() always opens in the same window,
549 // so do it manually for new window (from Mahogany)
550 wxRegKey key(wxRegKey::HKCR, url.BeforeFirst(':') + wxT("\\shell\\open"));
551 if ( key.Exists() )
552 {
553 wxRegKey keyDDE(key, wxT("DDEExec"));
554 if ( keyDDE.Exists() )
555 {
657a7545
WS
556 wxString ddeTopic = wxRegKey(keyDDE, wxT("topic"));
557
558 // we only know the syntax of WWW_OpenURL DDE request
559 if ( ddeTopic == wxT("WWW_OpenURL") )
560 {
561 wxString ddeCmd = keyDDE;
562
563 // this is a bit naive but should work as -1 can't appear
564 // elsewhere in the DDE topic, normally
565 if ( ddeCmd.Replace(wxT("-1"), wxT("0"),
566 false /* only first occurence */) == 1 )
567 {
568 // and also replace the parameters
569 if ( ddeCmd.Replace(wxT("%1"), url, false) == 1 )
570 {
571 // magic incantation understood by wxMSW
572 command << wxT("WX_DDE#")
573 << wxRegKey(key, wxT("command")).QueryDefaultValue() << wxT('#')
574 << wxRegKey(keyDDE, wxT("application")).QueryDefaultValue()
575 << wxT('#') << ddeTopic << wxT('#')
576 << ddeCmd;
577 }
578 }
579 }
498a1eeb
RN
580 }
581 }
582
657a7545
WS
583 //Try wxExecute - if it doesn't work or the regkey stuff
584 //above failed, fallback to opening the file in the same
585 //browser window
586 if ( command.empty() || wxExecute(command) == -1)
587 {
fab79d44
JS
588 int nResult; //HINSTANCE error code
589
590#if !defined(__WXWINCE__)
657a7545
WS
591 // CYGWIN and MINGW may have problems - so load ShellExecute
592 // dynamically
fab79d44 593 typedef HINSTANCE (WINAPI *LPShellExecute)(HWND hwnd, const wxChar* lpOperation,
657a7545
WS
594 const wxChar* lpFile,
595 const wxChar* lpParameters,
596 const wxChar* lpDirectory,
597 INT nShowCmd);
598
599 HINSTANCE hShellDll = ::LoadLibrary(wxT("shell32.dll"));
600 if(hShellDll == NULL)
601 return false;
602
603 LPShellExecute lpShellExecute =
604 (LPShellExecute) ::GetProcAddress(hShellDll,
605 wxString::Format(wxT("ShellExecute%s"),
eb5b252d 606
8cc3b2e9 607#if wxUSE_UNICODE
657a7545 608 wxT("W")
498a1eeb 609#else
657a7545 610 wxT("A")
498a1eeb 611#endif
eb5b252d 612#ifdef __WXWINCE__
498a1eeb 613 )
eb5b252d
RN
614#else
615 ).mb_str(wxConvLocal)
616#endif
617 );
657a7545
WS
618 if(lpShellExecute == NULL)
619 return false;
498a1eeb
RN
620
621 // Windows sometimes doesn't open the browser correctly when using mime
622 // types, so do ShellExecute - i.e. start <url> (from James Carroll)
fab79d44 623 nResult = (int) (*lpShellExecute)(NULL, NULL, finalurl.c_str(),
532d575b 624 NULL, wxT(""), SW_SHOWNORMAL);
498a1eeb
RN
625 // Unload Shell32.dll
626 ::FreeLibrary(hShellDll);
fab79d44
JS
627#else
628 //Windows CE does not have normal ShellExecute - but it has
629 //ShellExecuteEx all the way back to version 1.0
630
631
632 //Set up the SHELLEXECUTEINFO structure to pass to ShellExecuteEx
633 SHELLEXECUTEINFO sei;
634 sei.cbSize = sizeof(SHELLEXECUTEINFO);
635 sei.dwHotKey = 0;
636 sei.fMask = 0;
637 sei.hIcon = NULL;
638 sei.hInstApp = NULL;
639 sei.hkeyClass = NULL;
f8c10795
JS
640 // Not in WinCE
641#if 0
fab79d44 642 sei.hMonitor = NULL;
f8c10795 643#endif
fab79d44
JS
644 sei.hProcess = NULL;
645 sei.hwnd = NULL;
646 sei.lpClass = NULL;
647 sei.lpDirectory = NULL;
648 sei.lpFile = finalurl.c_str();
649 sei.lpIDList = NULL;
650 sei.lpParameters = NULL;
651 sei.lpVerb = TEXT("open");
652 sei.nShow = SW_SHOWNORMAL;
653
654 //Call ShellExecuteEx
655 ShellExecuteEx(&sei);
656
657 //Get error code
658 nResult = (int) sei.hInstApp;
659#endif
498a1eeb
RN
660
661 // Hack for Firefox (returns file not found for some reason)
662 // from Angelo Mandato's wxHyperlinksCtrl
fab79d44
JS
663 // HINSTANCE_ERROR == 32 (HINSTANCE_ERROR does not exist on Windows CE)
664 if (nResult <= 32 && nResult != SE_ERR_FNF)
657a7545 665 return false;
498a1eeb 666
657a7545 667#ifdef __WXDEBUG__
498a1eeb
RN
668 // Log something if SE_ERR_FNF happens
669 if(nResult == SE_ERR_FNF)
670 wxLogDebug(wxT("Got SE_ERR_FNF from ShellExecute - maybe FireFox"));
657a7545
WS
671#endif
672 }
673
674#elif wxUSE_MIMETYPE
498a1eeb 675
498a1eeb 676 // Non-windows way
657a7545
WS
677 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension (_T("html"));
678 if (!ft)
679 {
680 wxLogError(_T("No default application can open .html extension"));
681 return false;
682 }
498a1eeb
RN
683
684 wxString mt;
685 ft->GetMimeType(&mt);
686
657a7545
WS
687 wxString cmd;
688 bool ok = ft->GetOpenCommand (&cmd, wxFileType::MessageParameters(finalurl));
689 delete ft;
690
691 if (ok)
498a1eeb
RN
692 {
693 if( wxExecute (cmd, wxEXEC_ASYNC) == -1 )
694 {
695 wxLogError(_T("Failed to launch application for wxLaunchDefaultBrowser"));
696 return false;
697 }
698 }
699 else
2830b4a4
RD
700 {
701 // fallback to checking for the BROWSER environment variable
702 cmd = wxGetenv(wxT("BROWSER"));
703 if ( cmd.empty() || wxExecute(cmd + wxT(" ") + finalurl) == -1)
704 return false;
705 }
532d575b 706
657a7545
WS
707
708#else // !wxUSE_MIMETYPE && !(WXMSW && wxUSE_NATIVE_CONFIG)
709
532d575b 710 success = false;
d6a7c33a 711
498a1eeb
RN
712#endif
713
714 //success - hopefully
532d575b 715 return success;
498a1eeb
RN
716}
717
91b4c08d 718// ----------------------------------------------------------------------------
7c072018 719// wxApp::Yield() wrappers for backwards compatibility
91b4c08d
VZ
720// ----------------------------------------------------------------------------
721
7c072018 722bool wxYield()
469e1e5c 723{
7c072018 724 return wxTheApp && wxTheApp->Yield();
469e1e5c 725}
7c072018
VZ
726
727bool wxYieldIfNeeded()
469e1e5c 728{
cb719f2e 729 return wxTheApp && wxTheApp->Yield(true);
469e1e5c 730}
7c072018 731
ec67cff1 732#endif // wxUSE_BASE
7c072018
VZ
733
734// ============================================================================
735// GUI-only functions from now on
736// ============================================================================
737
738#if wxUSE_GUI
739
4c3ebca9
MB
740// Id generation
741static long wxCurrentId = 100;
742
c838b68e 743long wxNewId()
4c3ebca9 744{
c838b68e
VS
745 // skip the part of IDs space that contains hard-coded values:
746 if (wxCurrentId == wxID_LOWEST)
747 wxCurrentId = wxID_HIGHEST + 1;
748
749 return wxCurrentId++;
4c3ebca9
MB
750}
751
752long
753wxGetCurrentId(void) { return wxCurrentId; }
754
755void
756wxRegisterId (long id)
757{
758 if (id >= wxCurrentId)
759 wxCurrentId = id + 1;
760}
761
7c072018 762#if wxUSE_MENUS
e90c1d2a
VZ
763
764// ----------------------------------------------------------------------------
7c072018 765// Menu accelerators related functions
e90c1d2a
VZ
766// ----------------------------------------------------------------------------
767
7c072018 768wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
e90c1d2a 769{
7c072018
VZ
770 wxString s = wxMenuItem::GetLabelFromText(in);
771 if ( out )
772 {
773 // go smash their buffer if it's not big enough - I love char * params
774 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
775 }
776 else
777 {
f526f752
MB
778 // MYcopystring - for easier search...
779 out = new wxChar[s.length() + 1];
780 wxStrcpy(out, s.c_str());
7c072018
VZ
781 }
782
783 return out;
e90c1d2a
VZ
784}
785
7c072018 786wxString wxStripMenuCodes(const wxString& in)
e90c1d2a 787{
7c072018 788 wxString out;
79f585d9 789
7c072018
VZ
790 size_t len = in.length();
791 out.reserve(len);
79f585d9 792
7c072018
VZ
793 for ( size_t n = 0; n < len; n++ )
794 {
795 wxChar ch = in[n];
796 if ( ch == _T('&') )
cd6ce4a9 797 {
7c072018
VZ
798 // skip it, it is used to introduce the accel char (or to quote
799 // itself in which case it should still be skipped): note that it
800 // can't be the last character of the string
801 if ( ++n == len )
79f585d9 802 {
7c072018
VZ
803 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
804 }
805 else
806 {
807 // use the next char instead
808 ch = in[n];
79f585d9 809 }
cd6ce4a9 810 }
7c072018 811 else if ( ch == _T('\t') )
79f585d9 812 {
7c072018
VZ
813 // everything after TAB is accel string, exit the loop
814 break;
79f585d9 815 }
7c072018
VZ
816
817 out += ch;
225fe9d6
VZ
818 }
819
7c072018 820 return out;
cd6ce4a9
VZ
821}
822
7c072018 823#endif // wxUSE_MENUS
e90c1d2a 824
cbc66a27 825// ----------------------------------------------------------------------------
7c072018 826// Window search functions
cbc66a27
VZ
827// ----------------------------------------------------------------------------
828
7c072018
VZ
829/*
830 * If parent is non-NULL, look through children for a label or title
831 * matching the specified string. If NULL, look through all top-level windows.
832 *
833 */
e2a6f233 834
7c072018
VZ
835wxWindow *
836wxFindWindowByLabel (const wxString& title, wxWindow * parent)
134677bd 837{
7c072018
VZ
838 return wxWindow::FindWindowByLabel( title, parent );
839}
b829bf55 840
b829bf55 841
7c072018
VZ
842/*
843 * If parent is non-NULL, look through children for a name
844 * matching the specified string. If NULL, look through all top-level windows.
845 *
846 */
134677bd 847
7c072018
VZ
848wxWindow *
849wxFindWindowByName (const wxString& name, wxWindow * parent)
2c18f21d 850{
7c072018 851 return wxWindow::FindWindowByName( name, parent );
2c18f21d
VS
852}
853
cb719f2e 854// Returns menu item id or wxNOT_FOUND if none.
7c072018
VZ
855int
856wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
e2a6f233 857{
7c072018
VZ
858#if wxUSE_MENUS
859 wxMenuBar *menuBar = frame->GetMenuBar ();
860 if ( menuBar )
861 return menuBar->FindMenuItem (menuString, itemString);
862#endif // wxUSE_MENUS
0fb67cd1 863
cb719f2e 864 return wxNOT_FOUND;
e2a6f233
JS
865}
866
7c072018
VZ
867// Try to find the deepest child that contains 'pt'.
868// We go backwards, to try to allow for controls that are spacially
869// within other controls, but are still siblings (e.g. buttons within
870// static boxes). Static boxes are likely to be created _before_ controls
871// that sit inside them.
872wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
e2a6f233 873{
7c072018
VZ
874 if (!win->IsShown())
875 return NULL;
0fb67cd1 876
7c072018
VZ
877 // Hack for wxNotebook case: at least in wxGTK, all pages
878 // claim to be shown, so we must only deal with the selected one.
879#if wxUSE_NOTEBOOK
880 if (win->IsKindOf(CLASSINFO(wxNotebook)))
e2a6f233 881 {
7c072018
VZ
882 wxNotebook* nb = (wxNotebook*) win;
883 int sel = nb->GetSelection();
884 if (sel >= 0)
885 {
886 wxWindow* child = nb->GetPage(sel);
887 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
888 if (foundWin)
889 return foundWin;
890 }
e2a6f233 891 }
7c072018 892#endif
0fb67cd1 893
df5168c4 894 wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
7c072018
VZ
895 while (node)
896 {
897 wxWindow* child = node->GetData();
898 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
899 if (foundWin)
900 return foundWin;
901 node = node->GetPrevious();
902 }
903
904 wxPoint pos = win->GetPosition();
905 wxSize sz = win->GetSize();
906 if (win->GetParent())
907 {
908 pos = win->GetParent()->ClientToScreen(pos);
909 }
910
911 wxRect rect(pos, sz);
912 if (rect.Inside(pt))
913 return win;
914 else
915 return NULL;
0fb67cd1
VZ
916}
917
7c072018 918wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
0fb67cd1 919{
7c072018
VZ
920 // Go backwards through the list since windows
921 // on top are likely to have been appended most
922 // recently.
df5168c4 923 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
7c072018
VZ
924 while (node)
925 {
926 wxWindow* win = node->GetData();
927 wxWindow* found = wxFindWindowAtPoint(win, pt);
928 if (found)
929 return found;
930 node = node->GetPrevious();
931 }
932 return NULL;
933}
0fb67cd1 934
7c072018
VZ
935// ----------------------------------------------------------------------------
936// GUI helpers
937// ----------------------------------------------------------------------------
0fb67cd1 938
7c072018
VZ
939/*
940 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
941 * since otherwise the generic code may be pulled in unnecessarily.
942 */
0fb67cd1 943
7c072018 944#if wxUSE_MSGDLG
0fb67cd1 945
7c072018
VZ
946int wxMessageBox(const wxString& message, const wxString& caption, long style,
947 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
0fb67cd1 948{
53a6ac21
DS
949 long decorated_style = style;
950
951 if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
952 {
953 decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
954 }
955
956 wxMessageDialog dialog(parent, message, caption, decorated_style);
0fb67cd1 957
7c072018
VZ
958 int ans = dialog.ShowModal();
959 switch ( ans )
960 {
961 case wxID_OK:
962 return wxOK;
963 case wxID_YES:
964 return wxYES;
965 case wxID_NO:
966 return wxNO;
967 case wxID_CANCEL:
968 return wxCANCEL;
969 }
0fb67cd1 970
7c072018 971 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
0fb67cd1 972
7c072018 973 return wxCANCEL;
e2a6f233
JS
974}
975
7c072018 976#endif // wxUSE_MSGDLG
518b5d2f 977
7c072018 978#if wxUSE_TEXTDLG
518b5d2f 979
7c072018
VZ
980wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
981 const wxString& defaultValue, wxWindow *parent,
13d13a9e 982 wxCoord x, wxCoord y, bool centre )
7c072018
VZ
983{
984 wxString str;
13d13a9e
WS
985 long style = wxTextEntryDialogStyle;
986
987 if (centre)
988 style |= wxCENTRE;
989 else
990 style &= ~wxCENTRE;
991
992 wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
993
7c072018
VZ
994 if (dialog.ShowModal() == wxID_OK)
995 {
996 str = dialog.GetValue();
997 }
0fb67cd1 998
7c072018 999 return str;
518b5d2f
VZ
1000}
1001
7c072018
VZ
1002wxString wxGetPasswordFromUser(const wxString& message,
1003 const wxString& caption,
1004 const wxString& defaultValue,
b3bb2a74
KH
1005 wxWindow *parent,
1006 wxCoord x, wxCoord y, bool centre )
96c5bd7f 1007{
7c072018 1008 wxString str;
b3bb2a74
KH
1009 long style = wxTextEntryDialogStyle;
1010
1011 if (centre)
1012 style |= wxCENTRE;
1013 else
1014 style &= ~wxCENTRE;
1015
12cfa304
KH
1016 wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1017 style, wxPoint(x, y));
7c072018
VZ
1018 if ( dialog.ShowModal() == wxID_OK )
1019 {
1020 str = dialog.GetValue();
1021 }
96c5bd7f 1022
7c072018
VZ
1023 return str;
1024}
96c5bd7f 1025
7c072018 1026#endif // wxUSE_TEXTDLG
96c5bd7f 1027
7c072018 1028#if wxUSE_COLOURDLG
96c5bd7f 1029
7c072018 1030wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit)
c51deffc 1031{
7c072018 1032 wxColourData data;
cb719f2e 1033 data.SetChooseFull(true);
7c072018
VZ
1034 if ( colInit.Ok() )
1035 {
1036 data.SetColour((wxColour &)colInit); // const_cast
1037 }
c51deffc 1038
7c072018
VZ
1039 wxColour colRet;
1040 wxColourDialog dialog(parent, &data);
1041 if ( dialog.ShowModal() == wxID_OK )
1042 {
1043 colRet = dialog.GetColourData().GetColour();
1044 }
1045 //else: leave it invalid
1046
1047 return colRet;
c51deffc 1048}
bc385ba9 1049
7c072018 1050#endif // wxUSE_COLOURDLG
bc385ba9 1051
7c072018
VZ
1052#if wxUSE_FONTDLG
1053
1054wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit)
bc385ba9 1055{
7c072018
VZ
1056 wxFontData data;
1057 if ( fontInit.Ok() )
bc385ba9 1058 {
7c072018
VZ
1059 data.SetInitialFont(fontInit);
1060 }
bc385ba9 1061
7c072018
VZ
1062 wxFont fontRet;
1063 wxFontDialog dialog(parent, data);
1064 if ( dialog.ShowModal() == wxID_OK )
1065 {
1066 fontRet = dialog.GetFontData().GetChosenFont();
1067 }
1068 //else: leave it invalid
bc385ba9 1069
7c072018 1070 return fontRet;
bc385ba9
VZ
1071}
1072
7c072018 1073#endif // wxUSE_FONTDLG
2b5f62a0 1074
7c072018
VZ
1075// ----------------------------------------------------------------------------
1076// wxSafeYield and supporting functions
1077// ----------------------------------------------------------------------------
2b5f62a0 1078
7c072018
VZ
1079void wxEnableTopLevelWindows(bool enable)
1080{
df5168c4 1081 wxWindowList::compatibility_iterator node;
7c072018
VZ
1082 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1083 node->GetData()->Enable(enable);
1084}
2b5f62a0 1085
7c072018
VZ
1086wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1087{
1088 // remember the top level windows which were already disabled, so that we
1089 // don't reenable them later
1090 m_winDisabled = NULL;
1091
df5168c4 1092 wxWindowList::compatibility_iterator node;
7c072018 1093 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
2b5f62a0 1094 {
7c072018
VZ
1095 wxWindow *winTop = node->GetData();
1096 if ( winTop == winToSkip )
1097 continue;
2b5f62a0 1098
7c072018
VZ
1099 // we don't need to disable the hidden or already disabled windows
1100 if ( winTop->IsEnabled() && winTop->IsShown() )
2b5f62a0 1101 {
7c072018 1102 winTop->Disable();
2b5f62a0
VZ
1103 }
1104 else
1105 {
7c072018
VZ
1106 if ( !m_winDisabled )
1107 {
1108 m_winDisabled = new wxWindowList;
1109 }
1110
1111 m_winDisabled->Append(winTop);
2b5f62a0
VZ
1112 }
1113 }
2b5f62a0
VZ
1114}
1115
7c072018 1116wxWindowDisabler::~wxWindowDisabler()
cd6ce4a9 1117{
df5168c4 1118 wxWindowList::compatibility_iterator node;
7c072018 1119 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
cd6ce4a9 1120 {
7c072018
VZ
1121 wxWindow *winTop = node->GetData();
1122 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
cd6ce4a9 1123 {
7c072018 1124 winTop->Enable();
cd6ce4a9 1125 }
7c072018 1126 //else: had been already disabled, don't reenable
cd6ce4a9 1127 }
f6bcfd97 1128
7c072018 1129 delete m_winDisabled;
f6bcfd97
BP
1130}
1131
7c072018
VZ
1132// Yield to other apps/messages and disable user input to all windows except
1133// the given one
1134bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
f6bcfd97 1135{
7c072018 1136 wxWindowDisabler wd(win);
21709999 1137
7c072018
VZ
1138 bool rc;
1139 if (onlyIfNeeded)
1140 rc = wxYieldIfNeeded();
1141 else
1142 rc = wxYield();
8461e4c2 1143
7c072018 1144 return rc;
8461e4c2
VZ
1145}
1146
7c072018
VZ
1147// Don't synthesize KeyUp events holding down a key and producing KeyDown
1148// events with autorepeat. On by default and always on in wxMSW. wxGTK version
1149// in utilsgtk.cpp.
1150#ifndef __WXGTK__
1151bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
8461e4c2 1152{
cb719f2e 1153 return true; // detectable auto-repeat is the only mode MSW supports
8461e4c2 1154}
7c072018
VZ
1155#endif // !wxGTK
1156
1157#endif // wxUSE_GUI
21709999 1158