them concurrently. To do this, create a separate directory for each build
of wxWidgets - you may also want to create different versions of wxWidgets
and test them concurrently. Most typically, this would be a version configured
-with --enable-debug and one without. Note, that only one build can
-currently be installed with 'make install', so you'd have to use local version of
+with --enable-debug and one without. Note, that only one build can currently
+be installed with 'make install', so you'd have to use a local version of
the library for that purpose.
For building three versions (one GTK+, one Motif and a debug version of the GTK
source) you'd do this:
-md buildmotif
+mkdir buildmotif
cd buildmotif
../configure --with-motif
make
cd ..
-md buildgtk
+mkdir buildgtk
cd buildgtk
../configure --with-gtk
make
cd ..
-md buildgtkd
+mkdir buildgtkd
cd buildgtkd
../configure --with-gtk --enable-debug
make
configure reports, that you don't have GTK+ 1.2 installed although you are
very sure you have. Well, you have installed it, but you also have another
version of the GTK+ installed, which you may need to remove including other
-versions of glib (and its headers). Or maybe you installed it in non default
+versions of glib (and its headers). Or maybe you installed it in a non-default
location and configure can't find it there, so please check that your PATH
variable includes the path to the correct gtk-config. Also check that your
LD_LIBRARY_PATH or equivalent variable contains the path to GTK+ libraries if
-they were installed in a non default location.
+they were installed in a non-default location.
You get errors from make: please use GNU make instead of the native make
program. Currently wxWidgets can be built only with GNU make, BSD make and
./configure options
If you want to use system's C and C++ compiler,
-set environment variables CC and CCC as
+set environment variables CC and CXX as
% setenv CC cc
% setenv CXX CC
/* ---------------------------------------------------------------------------- */
/* Debugging macros */
/* */
-/* All debugging macros rely on ASSERT() which in turn calls user-defined */
+/* All debugging macros rely on ASSERT() which in turn calls the user-defined */
/* OnAssert() function. To keep things simple, it's called even when the */
/* expression is true (i.e. everything is ok) and by default does nothing: just */
/* returns the same value back. But if you redefine it to do something more sexy */
#define wxFAIL_COND_MSG(cond, msg) \
wxOnAssert(__TFILE__, __LINE__, __WXFUNCTION__, _T(cond), msg)
- /* an assert helper used to avoid warning when testing constant expressions, */
+ /* An assert helper used to avoid warning when testing constant expressions, */
/* i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
/* expression being always true, but not using */
/* wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
/* */
- /* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and shouldn't be */
- /* used any longer */
+ /* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */
+ /* longer be used. */
extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
#else
#define wxTrap()
- /* nothing to do in release modes (hopefully at this moment there are */
+ /* nothing to do in release mode (hopefully at this moment there are */
/* no more bugs ;-) */
#define wxASSERT(cond)
#define wxASSERT_MSG(cond, msg)
#define wxAssertFailure wxFalse
-/* NB: the following macros work also in release mode! */
+/* NB: the following macros also work in release mode! */
/*
These macros must be used only in invalid situation: for example, an
- invalid parameter (NULL pointer) is passed to a function. Instead of
+ invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
dereferencing it and causing core dump the function might try using
CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
*/
};
// This class handles generic parsing of HTML document : it scans
-// the document and divide it into blocks of tags (where one block
+// the document and divides it into blocks of tags (where one block
// consists of starting and ending tag and of text between these
// 2 tags.
class WXDLLIMPEXP_HTML wxHtmlParser : public wxObject
// This method does these things:
// 1. call InitParser(source);
// 2. call DoParsing();
- // 3. call GetProduct(); (it's return value is then returned)
+ // 3. call GetProduct(); (its return value is then returned)
// 4. call DoneParser();
wxObject* Parse(const wxString& source);
// <it name="two" value="2">
// </myitems>
// <it> This last it has different meaning, we don't want it to be parsed by myitems handler!
- // handler can handle only 'myitems' (e.g. it's GetSupportedTags returns "MYITEMS")
+ // handler can handle only 'myitems' (e.g. its GetSupportedTags returns "MYITEMS")
// you can call PushTagHandler(handler, "IT") when you find <myitems>
// and call PopTagHandler() when you find </myitems>
void PushTagHandler(wxHtmlTagHandler *handler, const wxString& tags);
wxString* GetSource() {return &m_Source;}
void SetSource(const wxString& src);
- // Sets HTML source and remebers current parser's state so that it can
+ // Sets HTML source and remembers current parser's state so that it can
// later be restored. This is useful for on-line modifications of
// HTML source (for example, <pre> handler replaces spaces with
// and newlines with <br>)
// Each recognized tag is passed to handler which is capable
// of handling it. Each tag is handled in 3 steps:
// 1. Handler will modifies state of parser
-// (using it's public methods)
+// (using its public methods)
// 2. Parser parses source between starting and ending tag
// 3. Handler restores original state of the parser
class WXDLLIMPEXP_HTML wxHtmlTagHandler : public wxObject
wxWindowID id,
const wxString& name)
{
- // the main toolbar can't be recreated (unless it was explicitly deeleted
+ // the main toolbar can't be recreated (unless it was explicitly deleted
// before)
wxCHECK_MSG( !m_frameToolBar, (wxToolBar *)NULL,
wxT("recreating toolbar in wxFrame") );
if ( GetList(fileList, fileName, false) )
{
// Some ftp-servers (Ipswitch WS_FTP Server 1.0.5 does this)
- // displays this behaviour when queried on a non-existing file:
+ // displays this behaviour when queried on a nonexistent file:
// NLST this_file_does_not_exist
// 150 Opening ASCII data connection for directory listing
// (no data transferred)
}
#if wxUSE_THREADS
- // NB: iconv() is MT-safe, but each thread must use it's own iconv_t handle.
- // Unfortunately there is a couple of global wxCSConv objects such as
+ // NB: iconv() is MT-safe, but each thread must use its own iconv_t handle.
+ // Unfortunately there are a couple of global wxCSConv objects such as
// wxConvLocal that are used all over wx code, so we have to make sure
// the handle is used by at most one thread at the time. Otherwise
// only a few wx classes would be safe to use from non-main threads
// NB: This is a hack to prevent deadlock. What could otherwise happen
// in Unicode build: wxConvLocal creation ends up being here
// because of some failure and logs the error. But wxLog will try to
- // attach timestamp, for which it will need wxConvLocal (to convert
- // time to char* and then wchar_t*), but that fails, tries to log
- // error, but wxLog has a (already locked) critical section that
- // guards static buffer.
+ // attach a timestamp, for which it will need wxConvLocal (to convert
+ // time to char* and then wchar_t*), but that fails, tries to log the
+ // error, but wxLog has an (already locked) critical section that
+ // guards the static buffer.
static bool alreadyLoggingError = false;
if (!alreadyLoggingError)
{
6) Display a border (sunken, raised, simple or none).
Normally one might expect, that one wxWidgets window would always correspond
- to one GTK widget. Under GTK, there is no such allround widget that has all
+ to one GTK widget. Under GTK, there is no such all-round widget that has all
the functionality. Moreover, the GTK defines a client area as a different
widget from the actual widget you are handling. Last but not least some
special classes (e.g. wxFrame) handle different categories of widgets and
clicking on a scrollbar belonging to scrolled window will inevitably move
the window. In wxWidgets, the scrollbar will only emit an event, send this
to (normally) a wxScrolledWindow and that class will call ScrollWindow()
- which actually moves the window and its subchildren. Note that GtkPizza
+ which actually moves the window and its sub-windows. Note that GtkPizza
memorizes how much it has been scrolled but that wxWidgets forgets this
so that the two coordinates systems have to be kept in synch. This is done
in various places using the pizza->xoffset and pizza->yoffset values.
III)
- Singularily the most broken code in GTK is the code that is supposed to
+ Singularly the most broken code in GTK is the code that is supposed to
inform subwindows (child windows) about new positions. Very often, duplicate
events are sent without changes in size or position, equally often no
events are sent at all (All this is due to a bug in the GtkContainer code
{
// however only do it if we have a Cancel button in the dialog,
// otherwise the user code may get confused by the events from a
- // non-existing button and, worse, a wxButton might get button event
+ // nonexistent button and, worse, a wxButton might get button event
// from another button which is not really expected
wxWindow *winForCancel = win,
*btnCancel = NULL;
break;
default:
- // unknwon button, don't process
+ // unknown button, don't process
return FALSE;
}
if ( g_captureWindow )
{
- // synthetize a mouse enter or leave event if needed
+ // synthesise a mouse enter or leave event if needed
GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
// This seems to be necessary and actually been added to
// GDK itself in version 2.0.X
else
{
#ifndef __WXMAC__
- // okay, let convert to ISO_8859-1, available always
+ // okay, let's convert to ISO_8859-1, available always
m_OutputEnc = wxFONTENCODING_DEFAULT;
#else
m_OutputEnc = wxLocale::GetSystemEncoding() ;
(m_OutputEnc == wxFONTENCODING_DEFAULT) ?
wxFONTENCODING_ISO8859_1 : m_OutputEnc,
wxCONVERT_SUBSTITUTE))
- { // total failture :-(
+ { // total failure :-(
wxLogError(_("Failed to display HTML document in %s encoding"),
wxFontMapper::GetEncodingName(enc).c_str());
m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
{
return wxString::Format(wxT("DirectShow error \"%s\" \n")
wxT("(numeric %X)\n")
- wxT("occured"),
+ wxT("occurred"),
szError, (int)hrdsv);
}
else
{
return wxString::Format(wxT("Unknown error \n")
wxT("(numeric %X)\n")
- wxT("occured"),
+ wxT("occurred"),
(int)hrdsv);
}
}
#define wxVERIFY(x) wxASSERT((x))
#define wxAMLOG(x) wxLogDebug(GetErrorString(x))
#else
-#define wxAMVERIFY(x) (x)
#define wxVERIFY(x) (x)
#define wxAMLOG(x)
#define wxAMFAIL(x)
!pItem->GetFont().Ok() &&
!pItem->GetBitmap(true).Ok() )
{
- // try to use InsertMenuItem() as it's guaranteed to look correctly
- // while our owner-drawning code is not
+ // try to use InsertMenuItem() as it's guaranteed to look correct
+ // while our owner-drawn code is not
// first compile-time check
#ifdef MIIM_BITMAP
// we can't pass HBITMAP directly as hbmpItem for 2 reasons:
// 1. we can't draw it with transparency then (this is not
// very important now but would be with themed menu bg)
- // 2. worse, Windows inverses the bitmap for the selected
+ // 2. worse, Windows inverts the bitmap for the selected
// item and this looks downright ugly
//
// so instead draw it ourselves in MSWOnDrawItem()
else
#endif // wxUSE_OWNER_DRAWN
{
- // menu is just a normal string (passed in data parameter)
+ // item is just a normal string (passed in data parameter)
flags |= MF_STRING;
#ifdef __WXWINCE__
pData = (wxChar*)itemText.c_str();
}
- // item might have been already inserted by InsertMenuItem() above
+ // item might have already been inserted by InsertMenuItem() above
if ( !ok )
{
if ( !::InsertMenu(GetHmenu(), pos, flags | MF_BYPOSITION, id, pData) )
wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
{
- // we need to find the items position in the child list
+ // we need to find the item's position in the child list
size_t pos;
wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
for ( pos = 0; node; pos++ )
node = node->GetNext();
}
- // DoRemove() (unlike Remove) can only be called for existing item!
+ // DoRemove() (unlike Remove) can only be called for an existing item!
wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
#if wxUSE_ACCEL
if ( IsAttached() && GetMenuBar()->IsAttached() )
{
- // otherwise, the chane won't be visible
+ // otherwise, the change won't be visible
GetMenuBar()->Refresh();
}
#if wxUSE_ACCEL
-// create the wxAcceleratorEntries for our accels and put them into provided
+// create the wxAcceleratorEntries for our accels and put them into the provided
// array - return the number of accels we have
size_t wxMenu::CopyAccels(wxAcceleratorEntry *accels) const
{
WXHMENU wxMenuBar::Create()
{
- // Note: this totally doesn't work on Smartphone,
+ // Note: this doesn't work at all on Smartphone,
// since you have to use resources.
// We'll have to find another way to add a menu
// by changing/adding menu items to an existing menu.
projects / wxWidgets.git / commitdiff
