]> git.saurik.com Git - wxWidgets.git/blame - src/common/utilscmn.cpp
Permission for flood-fill code clarified
[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{
536 wxString finalurl = url;
537
538 //if it isn't a full url, try appending http:// to it
539 if(wxURI(url).IsReference())
540 finalurl = wxString(wxT("http://")) + url;
541
657a7545
WS
542#if defined(__WXMSW__) && wxUSE_CONFIG_NATIVE
543
498a1eeb
RN
544 wxString command;
545
546 // ShellExecute() always opens in the same window,
547 // so do it manually for new window (from Mahogany)
548 wxRegKey key(wxRegKey::HKCR, url.BeforeFirst(':') + wxT("\\shell\\open"));
549 if ( key.Exists() )
550 {
551 wxRegKey keyDDE(key, wxT("DDEExec"));
552 if ( keyDDE.Exists() )
553 {
657a7545
WS
554 wxString ddeTopic = wxRegKey(keyDDE, wxT("topic"));
555
556 // we only know the syntax of WWW_OpenURL DDE request
557 if ( ddeTopic == wxT("WWW_OpenURL") )
558 {
559 wxString ddeCmd = keyDDE;
560
561 // this is a bit naive but should work as -1 can't appear
562 // elsewhere in the DDE topic, normally
563 if ( ddeCmd.Replace(wxT("-1"), wxT("0"),
564 false /* only first occurence */) == 1 )
565 {
566 // and also replace the parameters
567 if ( ddeCmd.Replace(wxT("%1"), url, false) == 1 )
568 {
569 // magic incantation understood by wxMSW
570 command << wxT("WX_DDE#")
571 << wxRegKey(key, wxT("command")).QueryDefaultValue() << wxT('#')
572 << wxRegKey(keyDDE, wxT("application")).QueryDefaultValue()
573 << wxT('#') << ddeTopic << wxT('#')
574 << ddeCmd;
575 }
576 }
577 }
498a1eeb
RN
578 }
579 }
580
657a7545
WS
581 //Try wxExecute - if it doesn't work or the regkey stuff
582 //above failed, fallback to opening the file in the same
583 //browser window
584 if ( command.empty() || wxExecute(command) == -1)
585 {
586 // CYGWIN and MINGW may have problems - so load ShellExecute
587 // dynamically
588 typedef HINSTANCE (*LPShellExecute)(HWND hwnd, const wxChar* lpOperation,
589 const wxChar* lpFile,
590 const wxChar* lpParameters,
591 const wxChar* lpDirectory,
592 INT nShowCmd);
593
594 HINSTANCE hShellDll = ::LoadLibrary(wxT("shell32.dll"));
595 if(hShellDll == NULL)
596 return false;
597
598 LPShellExecute lpShellExecute =
599 (LPShellExecute) ::GetProcAddress(hShellDll,
600 wxString::Format(wxT("ShellExecute%s"),
eb5b252d 601
498a1eeb 602#ifdef __WXUNICODE__
657a7545 603 wxT("W")
498a1eeb 604#else
657a7545 605 wxT("A")
498a1eeb 606#endif
eb5b252d 607#ifdef __WXWINCE__
498a1eeb 608 )
eb5b252d
RN
609#else
610 ).mb_str(wxConvLocal)
611#endif
612 );
657a7545
WS
613 if(lpShellExecute == NULL)
614 return false;
498a1eeb
RN
615
616 // Windows sometimes doesn't open the browser correctly when using mime
617 // types, so do ShellExecute - i.e. start <url> (from James Carroll)
657a7545
WS
618 unsigned int nResult = (int) (*lpShellExecute)(NULL, NULL, finalurl.c_str(),
619 NULL, wxT(""), SW_SHOWNORMAL);
498a1eeb
RN
620
621 // Unload Shell32.dll
622 ::FreeLibrary(hShellDll);
623
624 // Hack for Firefox (returns file not found for some reason)
625 // from Angelo Mandato's wxHyperlinksCtrl
626 // HINSTANCE_ERROR == 32
627 if (nResult <= HINSTANCE_ERROR && nResult != SE_ERR_FNF)
657a7545 628 return false;
498a1eeb 629
657a7545 630#ifdef __WXDEBUG__
498a1eeb
RN
631 // Log something if SE_ERR_FNF happens
632 if(nResult == SE_ERR_FNF)
633 wxLogDebug(wxT("Got SE_ERR_FNF from ShellExecute - maybe FireFox"));
657a7545
WS
634#endif
635 }
636
637#elif wxUSE_MIMETYPE
498a1eeb 638
498a1eeb 639 // Non-windows way
657a7545
WS
640 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension (_T("html"));
641 if (!ft)
642 {
643 wxLogError(_T("No default application can open .html extension"));
644 return false;
645 }
498a1eeb
RN
646
647 wxString mt;
648 ft->GetMimeType(&mt);
649
657a7545
WS
650 wxString cmd;
651 bool ok = ft->GetOpenCommand (&cmd, wxFileType::MessageParameters(finalurl));
652 delete ft;
653
654 if (ok)
498a1eeb
RN
655 {
656 if( wxExecute (cmd, wxEXEC_ASYNC) == -1 )
657 {
658 wxLogError(_T("Failed to launch application for wxLaunchDefaultBrowser"));
659 return false;
660 }
661 }
662 else
657a7545
WS
663 return false;
664
665#else // !wxUSE_MIMETYPE && !(WXMSW && wxUSE_NATIVE_CONFIG)
666
667 return false;
d6a7c33a 668
498a1eeb
RN
669#endif
670
671 //success - hopefully
672 return true;
673}
674
91b4c08d 675// ----------------------------------------------------------------------------
7c072018 676// wxApp::Yield() wrappers for backwards compatibility
91b4c08d
VZ
677// ----------------------------------------------------------------------------
678
7c072018 679bool wxYield()
469e1e5c 680{
7c072018 681 return wxTheApp && wxTheApp->Yield();
469e1e5c 682}
7c072018
VZ
683
684bool wxYieldIfNeeded()
469e1e5c 685{
cb719f2e 686 return wxTheApp && wxTheApp->Yield(true);
469e1e5c 687}
7c072018 688
ec67cff1 689#endif // wxUSE_BASE
7c072018
VZ
690
691// ============================================================================
692// GUI-only functions from now on
693// ============================================================================
694
695#if wxUSE_GUI
696
4c3ebca9
MB
697// Id generation
698static long wxCurrentId = 100;
699
c838b68e 700long wxNewId()
4c3ebca9 701{
c838b68e
VS
702 // skip the part of IDs space that contains hard-coded values:
703 if (wxCurrentId == wxID_LOWEST)
704 wxCurrentId = wxID_HIGHEST + 1;
705
706 return wxCurrentId++;
4c3ebca9
MB
707}
708
709long
710wxGetCurrentId(void) { return wxCurrentId; }
711
712void
713wxRegisterId (long id)
714{
715 if (id >= wxCurrentId)
716 wxCurrentId = id + 1;
717}
718
7c072018 719#if wxUSE_MENUS
e90c1d2a
VZ
720
721// ----------------------------------------------------------------------------
7c072018 722// Menu accelerators related functions
e90c1d2a
VZ
723// ----------------------------------------------------------------------------
724
7c072018 725wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
e90c1d2a 726{
7c072018
VZ
727 wxString s = wxMenuItem::GetLabelFromText(in);
728 if ( out )
729 {
730 // go smash their buffer if it's not big enough - I love char * params
731 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
732 }
733 else
734 {
f526f752
MB
735 // MYcopystring - for easier search...
736 out = new wxChar[s.length() + 1];
737 wxStrcpy(out, s.c_str());
7c072018
VZ
738 }
739
740 return out;
e90c1d2a
VZ
741}
742
7c072018 743wxString wxStripMenuCodes(const wxString& in)
e90c1d2a 744{
7c072018 745 wxString out;
79f585d9 746
7c072018
VZ
747 size_t len = in.length();
748 out.reserve(len);
79f585d9 749
7c072018
VZ
750 for ( size_t n = 0; n < len; n++ )
751 {
752 wxChar ch = in[n];
753 if ( ch == _T('&') )
cd6ce4a9 754 {
7c072018
VZ
755 // skip it, it is used to introduce the accel char (or to quote
756 // itself in which case it should still be skipped): note that it
757 // can't be the last character of the string
758 if ( ++n == len )
79f585d9 759 {
7c072018
VZ
760 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
761 }
762 else
763 {
764 // use the next char instead
765 ch = in[n];
79f585d9 766 }
cd6ce4a9 767 }
7c072018 768 else if ( ch == _T('\t') )
79f585d9 769 {
7c072018
VZ
770 // everything after TAB is accel string, exit the loop
771 break;
79f585d9 772 }
7c072018
VZ
773
774 out += ch;
225fe9d6
VZ
775 }
776
7c072018 777 return out;
cd6ce4a9
VZ
778}
779
7c072018 780#endif // wxUSE_MENUS
e90c1d2a 781
cbc66a27 782// ----------------------------------------------------------------------------
7c072018 783// Window search functions
cbc66a27
VZ
784// ----------------------------------------------------------------------------
785
7c072018
VZ
786/*
787 * If parent is non-NULL, look through children for a label or title
788 * matching the specified string. If NULL, look through all top-level windows.
789 *
790 */
e2a6f233 791
7c072018
VZ
792wxWindow *
793wxFindWindowByLabel (const wxString& title, wxWindow * parent)
134677bd 794{
7c072018
VZ
795 return wxWindow::FindWindowByLabel( title, parent );
796}
b829bf55 797
b829bf55 798
7c072018
VZ
799/*
800 * If parent is non-NULL, look through children for a name
801 * matching the specified string. If NULL, look through all top-level windows.
802 *
803 */
134677bd 804
7c072018
VZ
805wxWindow *
806wxFindWindowByName (const wxString& name, wxWindow * parent)
2c18f21d 807{
7c072018 808 return wxWindow::FindWindowByName( name, parent );
2c18f21d
VS
809}
810
cb719f2e 811// Returns menu item id or wxNOT_FOUND if none.
7c072018
VZ
812int
813wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
e2a6f233 814{
7c072018
VZ
815#if wxUSE_MENUS
816 wxMenuBar *menuBar = frame->GetMenuBar ();
817 if ( menuBar )
818 return menuBar->FindMenuItem (menuString, itemString);
819#endif // wxUSE_MENUS
0fb67cd1 820
cb719f2e 821 return wxNOT_FOUND;
e2a6f233
JS
822}
823
7c072018
VZ
824// Try to find the deepest child that contains 'pt'.
825// We go backwards, to try to allow for controls that are spacially
826// within other controls, but are still siblings (e.g. buttons within
827// static boxes). Static boxes are likely to be created _before_ controls
828// that sit inside them.
829wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
e2a6f233 830{
7c072018
VZ
831 if (!win->IsShown())
832 return NULL;
0fb67cd1 833
7c072018
VZ
834 // Hack for wxNotebook case: at least in wxGTK, all pages
835 // claim to be shown, so we must only deal with the selected one.
836#if wxUSE_NOTEBOOK
837 if (win->IsKindOf(CLASSINFO(wxNotebook)))
e2a6f233 838 {
7c072018
VZ
839 wxNotebook* nb = (wxNotebook*) win;
840 int sel = nb->GetSelection();
841 if (sel >= 0)
842 {
843 wxWindow* child = nb->GetPage(sel);
844 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
845 if (foundWin)
846 return foundWin;
847 }
e2a6f233 848 }
7c072018 849#endif
0fb67cd1 850
df5168c4 851 wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
7c072018
VZ
852 while (node)
853 {
854 wxWindow* child = node->GetData();
855 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
856 if (foundWin)
857 return foundWin;
858 node = node->GetPrevious();
859 }
860
861 wxPoint pos = win->GetPosition();
862 wxSize sz = win->GetSize();
863 if (win->GetParent())
864 {
865 pos = win->GetParent()->ClientToScreen(pos);
866 }
867
868 wxRect rect(pos, sz);
869 if (rect.Inside(pt))
870 return win;
871 else
872 return NULL;
0fb67cd1
VZ
873}
874
7c072018 875wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
0fb67cd1 876{
7c072018
VZ
877 // Go backwards through the list since windows
878 // on top are likely to have been appended most
879 // recently.
df5168c4 880 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
7c072018
VZ
881 while (node)
882 {
883 wxWindow* win = node->GetData();
884 wxWindow* found = wxFindWindowAtPoint(win, pt);
885 if (found)
886 return found;
887 node = node->GetPrevious();
888 }
889 return NULL;
890}
0fb67cd1 891
7c072018
VZ
892// ----------------------------------------------------------------------------
893// GUI helpers
894// ----------------------------------------------------------------------------
0fb67cd1 895
7c072018
VZ
896/*
897 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
898 * since otherwise the generic code may be pulled in unnecessarily.
899 */
0fb67cd1 900
7c072018 901#if wxUSE_MSGDLG
0fb67cd1 902
7c072018
VZ
903int wxMessageBox(const wxString& message, const wxString& caption, long style,
904 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
0fb67cd1 905{
53a6ac21
DS
906 long decorated_style = style;
907
908 if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
909 {
910 decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
911 }
912
913 wxMessageDialog dialog(parent, message, caption, decorated_style);
0fb67cd1 914
7c072018
VZ
915 int ans = dialog.ShowModal();
916 switch ( ans )
917 {
918 case wxID_OK:
919 return wxOK;
920 case wxID_YES:
921 return wxYES;
922 case wxID_NO:
923 return wxNO;
924 case wxID_CANCEL:
925 return wxCANCEL;
926 }
0fb67cd1 927
7c072018 928 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
0fb67cd1 929
7c072018 930 return wxCANCEL;
e2a6f233
JS
931}
932
7c072018 933#endif // wxUSE_MSGDLG
518b5d2f 934
7c072018 935#if wxUSE_TEXTDLG
518b5d2f 936
7c072018
VZ
937wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
938 const wxString& defaultValue, wxWindow *parent,
13d13a9e 939 wxCoord x, wxCoord y, bool centre )
7c072018
VZ
940{
941 wxString str;
13d13a9e
WS
942 long style = wxTextEntryDialogStyle;
943
944 if (centre)
945 style |= wxCENTRE;
946 else
947 style &= ~wxCENTRE;
948
949 wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
950
7c072018
VZ
951 if (dialog.ShowModal() == wxID_OK)
952 {
953 str = dialog.GetValue();
954 }
0fb67cd1 955
7c072018 956 return str;
518b5d2f
VZ
957}
958
7c072018
VZ
959wxString wxGetPasswordFromUser(const wxString& message,
960 const wxString& caption,
961 const wxString& defaultValue,
b3bb2a74
KH
962 wxWindow *parent,
963 wxCoord x, wxCoord y, bool centre )
96c5bd7f 964{
7c072018 965 wxString str;
b3bb2a74
KH
966 long style = wxTextEntryDialogStyle;
967
968 if (centre)
969 style |= wxCENTRE;
970 else
971 style &= ~wxCENTRE;
972
12cfa304
KH
973 wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
974 style, wxPoint(x, y));
7c072018
VZ
975 if ( dialog.ShowModal() == wxID_OK )
976 {
977 str = dialog.GetValue();
978 }
96c5bd7f 979
7c072018
VZ
980 return str;
981}
96c5bd7f 982
7c072018 983#endif // wxUSE_TEXTDLG
96c5bd7f 984
7c072018 985#if wxUSE_COLOURDLG
96c5bd7f 986
7c072018 987wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit)
c51deffc 988{
7c072018 989 wxColourData data;
cb719f2e 990 data.SetChooseFull(true);
7c072018
VZ
991 if ( colInit.Ok() )
992 {
993 data.SetColour((wxColour &)colInit); // const_cast
994 }
c51deffc 995
7c072018
VZ
996 wxColour colRet;
997 wxColourDialog dialog(parent, &data);
998 if ( dialog.ShowModal() == wxID_OK )
999 {
1000 colRet = dialog.GetColourData().GetColour();
1001 }
1002 //else: leave it invalid
1003
1004 return colRet;
c51deffc 1005}
bc385ba9 1006
7c072018 1007#endif // wxUSE_COLOURDLG
bc385ba9 1008
7c072018
VZ
1009#if wxUSE_FONTDLG
1010
1011wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit)
bc385ba9 1012{
7c072018
VZ
1013 wxFontData data;
1014 if ( fontInit.Ok() )
bc385ba9 1015 {
7c072018
VZ
1016 data.SetInitialFont(fontInit);
1017 }
bc385ba9 1018
7c072018
VZ
1019 wxFont fontRet;
1020 wxFontDialog dialog(parent, data);
1021 if ( dialog.ShowModal() == wxID_OK )
1022 {
1023 fontRet = dialog.GetFontData().GetChosenFont();
1024 }
1025 //else: leave it invalid
bc385ba9 1026
7c072018 1027 return fontRet;
bc385ba9
VZ
1028}
1029
7c072018 1030#endif // wxUSE_FONTDLG
2b5f62a0 1031
7c072018
VZ
1032// ----------------------------------------------------------------------------
1033// wxSafeYield and supporting functions
1034// ----------------------------------------------------------------------------
2b5f62a0 1035
7c072018
VZ
1036void wxEnableTopLevelWindows(bool enable)
1037{
df5168c4 1038 wxWindowList::compatibility_iterator node;
7c072018
VZ
1039 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1040 node->GetData()->Enable(enable);
1041}
2b5f62a0 1042
7c072018
VZ
1043wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1044{
1045 // remember the top level windows which were already disabled, so that we
1046 // don't reenable them later
1047 m_winDisabled = NULL;
1048
df5168c4 1049 wxWindowList::compatibility_iterator node;
7c072018 1050 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
2b5f62a0 1051 {
7c072018
VZ
1052 wxWindow *winTop = node->GetData();
1053 if ( winTop == winToSkip )
1054 continue;
2b5f62a0 1055
7c072018
VZ
1056 // we don't need to disable the hidden or already disabled windows
1057 if ( winTop->IsEnabled() && winTop->IsShown() )
2b5f62a0 1058 {
7c072018 1059 winTop->Disable();
2b5f62a0
VZ
1060 }
1061 else
1062 {
7c072018
VZ
1063 if ( !m_winDisabled )
1064 {
1065 m_winDisabled = new wxWindowList;
1066 }
1067
1068 m_winDisabled->Append(winTop);
2b5f62a0
VZ
1069 }
1070 }
2b5f62a0
VZ
1071}
1072
7c072018 1073wxWindowDisabler::~wxWindowDisabler()
cd6ce4a9 1074{
df5168c4 1075 wxWindowList::compatibility_iterator node;
7c072018 1076 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
cd6ce4a9 1077 {
7c072018
VZ
1078 wxWindow *winTop = node->GetData();
1079 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
cd6ce4a9 1080 {
7c072018 1081 winTop->Enable();
cd6ce4a9 1082 }
7c072018 1083 //else: had been already disabled, don't reenable
cd6ce4a9 1084 }
f6bcfd97 1085
7c072018 1086 delete m_winDisabled;
f6bcfd97
BP
1087}
1088
7c072018
VZ
1089// Yield to other apps/messages and disable user input to all windows except
1090// the given one
1091bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
f6bcfd97 1092{
7c072018 1093 wxWindowDisabler wd(win);
21709999 1094
7c072018
VZ
1095 bool rc;
1096 if (onlyIfNeeded)
1097 rc = wxYieldIfNeeded();
1098 else
1099 rc = wxYield();
8461e4c2 1100
7c072018 1101 return rc;
8461e4c2
VZ
1102}
1103
7c072018
VZ
1104// Don't synthesize KeyUp events holding down a key and producing KeyDown
1105// events with autorepeat. On by default and always on in wxMSW. wxGTK version
1106// in utilsgtk.cpp.
1107#ifndef __WXGTK__
1108bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
8461e4c2 1109{
cb719f2e 1110 return true; // detectable auto-repeat is the only mode MSW supports
8461e4c2 1111}
7c072018
VZ
1112#endif // !wxGTK
1113
1114#endif // wxUSE_GUI
21709999 1115