dnl Provides a test to determine the correct way to call
dnl getservbyname_r:
dnl
-dnl - defines HAVE_FUNC_GETSERVBYNAME_R_6 if it needs 6 arguments (e.g linux)
+dnl - defines HAVE_FUNC_GETSERVBYNAME_R_6 if it needs 6 arguments (e.g. linux)
dnl - defines HAVE_FUNC_GETSERVBYNAME_R_5 if it needs 5 arguments (e.g. solaris)
dnl - defines HAVE_FUNC_GETSERVBYNAME_R_4 if it needs 4 arguments (e.g. osf/1)
dnl
fi
done
else
- dnl try to guess the most apropriate toolkit for this platform
+ dnl try to guess the most appropriate toolkit for this platform
for toolkit in $ALL_TOOLKITS; do
var=DEFAULT_DEFAULT_wxUSE_$toolkit
eval "wxUSE_$toolkit=\$${var}"
dnl check for vsnprintf() -- a safe version of vsprintf())
dnl
-dnl the trouble here is that on some systems (e.g HP-UX 10) this function is
+dnl the trouble here is that on some systems (e.g. HP-UX 10) this function is
dnl present in libc but not in the system headers and so AC_CHECK_FUNCS (which,
dnl stupidly, provides a dummy function declaration inside its extension)
dnl succeeds, even with C++ compiler, but the compilation of wxWidgets fails
wxWindows :-)) to wxBombs.
3) Added SetClientData to resize the window on Restart; eliminated
-scrollbars; made the frame unresizeable.
+scrollbars; made the frame unresizable.
4) Added makefile.dos for VC++ 1.x, makefile.wat for Watcom C++.
\ No newline at end of file
- Fix centering wxFileDialog and allow positioning it.
- Allow centering wxMessageDialog on its parent window (troelsk).
- Use vertical scrollbar in wxMessageDialog if it's too big to fit on screen.
-- Show resize gripper on resizeable dialogs (Kolya Kosenko).
+- Show resize gripper on resizable dialogs (Kolya Kosenko).
- Implement support for display enumeration under WinCE (Vince Harron).
- Use different Win32 class names in different wx instances (Thomas Hauk).
- Support multiline labels for wxCheckBox and wxToggleButton.
- Fixed centering of top level windows on secondary displays.
- Implemented wxDisplay::GetFromWindow() for platforms other than MSW.
- UpdateUI handler can now show/hide the window too (Ronald Weiss).
-- More than one filter allowed in in wxDocTemplate filter.
+- More than one filter allowed in wxDocTemplate filter.
- Added wxListBox::HitTest().
- Added wxDisplay::GetClientArea().
- Indices and counts in wxControlWithItems derived API are unsigned.
- several fixes to owner drawn menu items (Christian Sturmlechner)
- wxGauge now supports full 32 bit range (Miroslav Rajcic)
- make it possible to give focus to the notebook tabs (Hajo Kirchhoff)
-- MDI child frames are not always resizeable any more (Andrei Fortuna)
+- MDI child frames are not always resizable any more (Andrei Fortuna)
- fixed enumerating of entries/groups under '/' in wxRegConfig
- added wxSYS_ICONTITLE_FONT (Andreas Pflug)
- added wxPATH_NORM_SHORTCUT to wxFileName
- added wxRenderer class allowing to customize the drawing of generic controls
- added wxCLOSE_BOX style for dialogs and frames
- added wxSplitterWindow and wxWizard handlers to XRC
-- wxWizard is now sizer-friendly and may be made resizeable (Robert Vazan)
+- wxWizard is now sizer-friendly and may be made resizable (Robert Vazan)
- added proportion to wxFlexGridSizer::AddGrowableRow/Col (Maxim Babitski)
- added wxFlexGridSizer::SetFlexibleDirection() (Szczepan Holyszewski)
- implemented GetEditControl for wxGenericTreeCtrl (Peter Stieber)
- wxFileDialog: adjusts struct size if there's an error (struct
sizes can be different on different versions of Windows)
- wxImageList::GetSize() documented and added to wxMSW
-- fixed default dialog style to make them non resizeable again
+- fixed default dialog style to make them non resizable again
- fixed wxFrame::IsShown() which always returned TRUE before
wxGTK:
These classes define objects for performing conversions between different
multibyte and Unicode encodings and wide character strings.
-@li wxMBConv: Base class for all convertors, defines the API implemented by all
- the other convertor classes.
-@li wxMBConvUTF7: Convertor for UTF-7
-@li wxMBConvUTF8: Convertor for UTF-8
-@li wxMBConvUTF16: Convertor for UTF-16
-@li wxMBConvUTF32: Convertor for UTF-32
-@li wxCSConv: Convertor for any system-supported encoding which can be
+@li wxMBConv: Base class for all converters, defines the API implemented by all
+ the other converter classes.
+@li wxMBConvUTF7: Converter for UTF-7
+@li wxMBConvUTF8: Converter for UTF-8
+@li wxMBConvUTF16: Converter for UTF-16
+@li wxMBConvUTF32: Converter for UTF-32
+@li wxCSConv: Converter for any system-supported encoding which can be
specified by name.
Related Overviews: @ref overview_mbconv
- declaring the real widget class inheriting from the Base version in
platform-specific headers; see for example the wxWidgets' @c "wx/gtk/button.h" file.
-- separing the different implementations in different source files, putting
+- separating the different implementations in different source files, putting
all common stuff in a separate source.
See for example the wxWidgets' @c "src/common/btncmn.cpp", @c "src/gtk/button.cpp"
and @c "src/msw/button.cpp" files.
As well as comprehensive support for the usual widgets, advanced
features include: HTML viewing/printing, wxImage class providing
-handlers for reading and writing many image types, resizeable panels
+handlers for reading and writing many image types, resizable panels
and dialogs on all platforms, document/view, OpenGL support,
HTML-based and context-sensitive help, wizards, drag and drop,
a grid class, ODBC support, threads, sockets, container classes,
// main (ie. topmost) window of a composite control (default = this)
wxWindow* m_mainCtrlWnd;
- // used to prevent immediate re-popupping incase closed popup
+ // used to prevent immediate re-popupping in case closed popup
// by clicking on the combo control (needed because of inconsistent
// transient implementation across platforms).
wxLongLong m_timeCanAcceptClick;
wxTRANSPARENT,
/* Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */
- /* Note also that stippling a Pen IS meaningfull, because a Line is */
+ /* Note also that stippling a Pen IS meaningful, because a Line is */
wxSTIPPLE_MASK_OPAQUE, /* mask is used for blitting monochrome using text fore and back ground colors */
wxSTIPPLE_MASK, /* mask is used for masking areas in the stipple bitmap (TO DO) */
/* drawn with a Pen, and without any Brush -- and it can be stippled. */
bool IsConnectedEvent() const
{ return GetEventType() == wxEVT_DIALUP_CONNECTED; }
- // does this event come from wxDialUpManager::Dial() or from some extrenal
+ // does this event come from wxDialUpManager::Dial() or from some external
// process (i.e. does it result from our own attempt to establish the
// connection)?
bool IsOwnEvent() const { return m_id != 0; }
// that wants to export a wxArray daubed with your own import/export goo.
//
// Finally, you can define the macro below as something special to modify the
-// arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
+// arrays defined by a simple WX_FOO_ARRAY as well. By default is empty.
#define wxARRAY_DEFAULT_EXPORT
// ----------------------------------------------------------------------------
// is successful and after the next Layout the item will be resized.
bool SetSpan( const wxGBSpan& span );
- // Returns true if this item and the other item instersect
+ // Returns true if this item and the other item intersect
bool Intersects(const wxGBSizerItem& other);
// Returns true if the given pos/span would intersect with this item.
virtual wxControl *AsControl() { return this; }
-public: // overrideable
+public: // overridable
virtual wxDialog *CreateDialog() = 0;
pos, size, style, validator, name);
}
-public: // overrideable
+public: // overridable
virtual long GetDialogStyle() const
{
pos, size, style, validator, name);
}
-public: // overrideable
+public: // overridable
virtual long GetDialogStyle() const
{
virtual void InitColours();
// true if the status bar shows the size grip: for this it must have
- // wxSTB_SIZEGRIP style and the window it is attached to must be resizeable
+ // wxSTB_SIZEGRIP style and the window it is attached to must be resizable
// and not maximized
bool ShowsSizeGrip() const;
inline wxSize GetSize()
{ return wxSize((int) m_width, (int) m_height); }
- // for the edge and corner accessors there are two setters conterparts, the Set.. functions keep the other corners at their
- // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners apropriately
+ // for the edge and corner accessors there are two setters counterparts, the Set.. functions keep the other corners at their
+ // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners appropriately
inline wxDouble GetLeft() const { return m_x; }
inline void SetLeft( wxDouble n ) { m_width += m_x - n; m_x = n; }
inline wxPoint2DInt GetPosition() { return wxPoint2DInt(m_x, m_y); }
inline wxSize GetSize() { return wxSize(m_width, m_height); }
- // for the edge and corner accessors there are two setters conterparts, the Set.. functions keep the other corners at their
- // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners apropriately
+ // for the edge and corner accessors there are two setters counterparts, the Set.. functions keep the other corners at their
+ // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners appropriately
inline wxInt32 GetLeft() const { return m_x; }
inline void SetLeft( wxInt32 n ) { m_width += m_x - n; m_x = n; }
WX_GL_MIN_ACCUM_BLUE, // use blue buffer with most bits (> MIN_ACCUM_BLUE bits)
WX_GL_MIN_ACCUM_ALPHA, // use alpha buffer with most bits (> MIN_ACCUM_ALPHA bits)
WX_GL_SAMPLE_BUFFERS, // 1 for multisampling support (antialiasing)
- WX_GL_SAMPLES // 4 for 2x2 antialising supersampling on most graphics cards
+ WX_GL_SAMPLES // 4 for 2x2 antialiasing supersampling on most graphics cards
};
#define wxGLCanvasName wxT("GLCanvas")
virtual void SetSortOrder( bool ascending );
virtual void SetAsSortKey(bool sort = true);
- virtual void SetResizeable( bool resizeable );
+ virtual void SetResizeable( bool resizable );
virtual void SetHidden( bool hidden );
virtual void SetMinWidth( int minWidth );
void GtkUpdateScrollbar(int orient);
// Called from GTK signal handlers. it indicates that
- // the layouting functions have to be called later on
+ // the layout functions have to be called later on
// (i.e. in idle time, implemented in OnInternalIdle() ).
void GtkUpdateSize() { m_sizeSet = false; }
// unspecified/default
virtual int GetWidth() const = 0;
- // minimal width can be set for resizeable columns to forbid resizing them
+ // minimal width can be set for resizable columns to forbid resizing them
// below the specified size (set to 0 to remove)
virtual int GetMinWidth() const = 0;
void ClearFlag(int flag);
void ToggleFlag(int flag);
- virtual void SetResizeable(bool resizeable)
- { ChangeFlag(wxCOL_RESIZABLE, resizeable); }
+ virtual void SetResizeable(bool resizable)
+ { ChangeFlag(wxCOL_RESIZABLE, resizable); }
virtual void SetSortable(bool sortable)
{ ChangeFlag(wxCOL_SORTABLE, sortable); }
virtual void SetReorderable(bool reorderable)
// Each wxHtmlWindow has it's own parser because sharing one global
// parser would be problematic (because of reentrancy)
wxHtmlWinParser *m_Parser;
- // contains name of actualy opened page or empty string if no page opened
+ // contains name of actually opened page or empty string if no page opened
wxString m_OpenedPage;
// contains name of current anchor within m_OpenedPage
wxString m_OpenedAnchor;
- // contains title of actualy opened page or empty string if no <TITLE> tag
+ // contains title of actually opened page or empty string if no <TITLE> tag
wxString m_OpenedPageTitle;
// class for opening files (file system)
wxFileSystem* m_FS;
// operations
// expand a string in the format of GetOpenCommand (which may contain
- // '%s' and '%t' format specificators for the file name and mime type
+ // '%s' and '%t' format specifiers for the file name and mime type
// and %{param} constructions).
static wxString ExpandCommand(const wxString& command,
const MessageParameters& params);
// this option is always enabled (there doesn't seem to be any good reason to
// disable it) for desktop Windows versions but Windows CE dialogs are usually
-// not resizeable and never show resize gripper anyhow so don't use it there
+// not resizable and never show resize gripper anyhow so don't use it there
#ifdef __WXWINCE__
#define wxUSE_DIALOG_SIZEGRIP 0
#else
private:
#if wxUSE_DIALOG_SIZEGRIP
// these functions deal with the gripper window shown in the corner of
- // resizeable dialogs
+ // resizable dialogs
void CreateGripper();
void DestroyGripper();
void ShowGripper(bool show);
// Recommended setting: 1, required by wxMediaCtrl
#define wxUSE_ACTIVEX 1
-// wxDC cacheing implementation
+// wxDC caching implementation
#define wxUSE_DC_CACHEING 1
// Set this to 1 to enable wxDIB class used internally for manipulating
// Recommended setting: 1, required by wxMediaCtrl
#define wxUSE_ACTIVEX 1
-// wxDC cacheing implementation
+// wxDC caching implementation
#define wxUSE_DC_CACHEING 1
// Set this to 1 to enable wxDIB class used internally for manipulating
virtual void SetMaxWidth (int maxWidth);
virtual void SetMinWidth (int minWidth);
virtual void SetReorderable(bool reorderable);
- virtual void SetResizeable (bool resizeable);
+ virtual void SetResizeable (bool resizable);
virtual void SetSortable (bool sortable);
virtual void SetSortOrder (bool ascending);
virtual void SetTitle (wxString const& title);
/*
Preprocessor in older Borland compilers have major problems
concatenating with ##. Specifically, if the string operands being
- concatenated have special meaning (e.g L"str", 123i64 etc)
+ concatenated have special meaning (e.g. L"str", 123i64 etc)
then ## will not concatenate the operands correctly.
As a workaround, define wxPREPEND* and wxAPPEND* without using
/**
Set proportion of a auto-stretchable column. wxPG_SPLITTER_AUTO_CENTER
window style needs to be used to indicate that columns are auto-
- resizeable.
+ resizable.
@returns Returns @false on failure.
wxString GetPortCmdArgument(const wxIPV4address& Local, const wxIPV4address& New);
// accept connection from server in active mode, returns the same socket as
- // passed in in passive mode
+ // passed in passive mode
wxSocketBase *AcceptIfActive(wxSocketBase *sock);
// data access
// -----------
- // access to invidividual colour components
+ // access to individual colour components
ChannelType& Red() { return m_ptr[PixelFormat::RED]; }
ChannelType& Green() { return m_ptr[PixelFormat::GREEN]; }
ChannelType& Blue() { return m_ptr[PixelFormat::BLUE]; }
virtual ~wxRichTextObject();
-// Overrideables
+// Overridables
/**
Draw the item, within the given range. Some objects may ignore the range (for
wxRichTextCompositeObject(wxRichTextObject* parent = NULL);
virtual ~wxRichTextCompositeObject();
-// Overrideables
+// Overridables
/// Hit-testing: returns a flag indicating hit test details, plus
/// information about position
wxRichTextParagraphLayoutBox(const wxRichTextParagraphLayoutBox& obj): wxRichTextCompositeObject() { Init(); Copy(obj); }
~wxRichTextParagraphLayoutBox();
-// Overrideables
+// Overridables
/// Hit-testing: returns a flag indicating hit test details, plus
/// information about position
wxRichTextBox(const wxRichTextBox& obj): wxRichTextParagraphLayoutBox() { Copy(obj); }
-// Overrideables
+// Overridables
/**
Draws the item.
wxRichTextLine(const wxRichTextLine& obj) { Init( NULL); Copy(obj); }
virtual ~wxRichTextLine() {}
-// Overrideables
+// Overridables
// Accessors
virtual ~wxRichTextParagraph();
wxRichTextParagraph(const wxRichTextParagraph& obj): wxRichTextCompositeObject() { Copy(obj); }
-// Overrideables
+// Overridables
/// Draw the item
virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
wxRichTextPlainText(const wxString& text = wxEmptyString, wxRichTextObject* parent = NULL, wxRichTextAttr* style = NULL);
wxRichTextPlainText(const wxRichTextPlainText& obj): wxRichTextObject() { Copy(obj); }
-// Overrideables
+// Overridables
/// Draw the item
virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent = NULL, wxRichTextAttr* charStyle = NULL);
wxRichTextImage(const wxRichTextImage& obj): wxRichTextObject(obj) { Copy(obj); }
-// Overrideables
+// Overridables
/// Draw the item
virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
wxRichTextCell(const wxRichTextCell& obj): wxRichTextBox() { Copy(obj); }
-// Overrideables
+// Overridables
/**
Draws the item.
wxRichTextTable(const wxRichTextTable& obj): wxRichTextBox() { Copy(obj); }
-// Overrideables
+// Overridables
// Draws the object.
virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
// Problem: if boxes are immediate children of a box, this will cause problems
// with wxRichTextParagraphLayoutBox functions (and functions elsewhere) that
// expect to find just paragraphs. May have to adjust the way we handle the
- // hierarchy to accept non-paragraph objects in a a paragraph layout box.
+ // hierarchy to accept non-paragraph objects in a paragraph layout box.
// We'll be overriding much wxRichTextParagraphLayoutBox functionality so this
// may not be such a problem. Perhaps the table should derive from a different
// class?
wxRichTextFormattingDialogFactory() {}
virtual ~wxRichTextFormattingDialogFactory() {}
-// Overrideables
+// Overridables
/// Create all pages, under the dialog's book control, also calling AddPage
virtual bool CreatePages(long pages, wxRichTextFormattingDialog* dialog);
// ----------------------------------------------------------------------------
/*
- Summary of the bits used (some of them are defined in wx/frame.g and
+ Summary of the bits used (some of them are defined in wx/frame.h and
wx/dialog.h and not here):
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
// Recommended setting: 1, required by wxMediaCtrl
#define wxUSE_ACTIVEX 1
-// wxDC cacheing implementation
+// wxDC caching implementation
#define wxUSE_DC_CACHEING 1
// Set this to 1 to enable wxDIB class used internally for manipulating
// return the frame icon bitmap
virtual wxBitmap GetFrameButtonBitmap(FrameButtonType type) = 0;
- // get the width of either normal or resizeable frame border depending on
+ // get the width of either normal or resizable frame border depending on
// whether flags contains wxTOPLEVEL_RESIZEABLE bit
//
// notice that these methods only make sense with standard border drawing
// windows this is just the client area of the window, but for
// some like scrolled windows it is more or less independent of
// the screen window size. You may override the DoXXXVirtual
- // methods below for classes where that is is the case.
+ // methods below for classes where that is the case.
void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); }
void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); }
/**
This function may be called if something fatal happens: an unhandled
- exception under Win32 or a a fatal signal under Unix, for example. However,
+ exception under Win32 or a fatal signal under Unix, for example. However,
this will not happen by default: you have to explicitly call
wxHandleFatalExceptions() to enable this.
A transparent brush is simply a brush with wxBRUSHSTYLE_TRANSPARENT
style.
- Notice that this function works even for non-initialized brushs (for
+ Notice that this function works even for non-initialized brushes (for
which it returns @false) unlike tests of the form <code>GetStyle() ==
wxBRUSHSTYLE_TRANSPARENT</code> which would assert if the brush is
invalid.
/**
Returns @true if the caret is visible and @false if it is permanently
- hidden (if it is is blinking and not shown currently but will be after
+ hidden (if it is blinking and not shown currently but will be after
the next blink, this method still returns @true).
*/
bool IsVisible() const;
This macro can be used in the code which needs to compile with both
wxWidgets 2 and 3 versions in places where v2 API requires a Unicode string
- (in Unicode build) and v3 API only accepts a standard standard narrow
+ (in Unicode build) and v3 API only accepts a standard narrow
string as in e.g. wxCmdLineEntryDesc structure objects initializers.
Example of use:
know the ordering of Undos; the user can never Undo at an arbitrary
position in the command history.
- Restore the entire document state (perhaps using document
- transactioning). Potentially very inefficient, but possibly easier to
+ transacting). Potentially very inefficient, but possibly easier to
code if the user interface and data are complex, and an "inverse
execute" operation is hard to write. The docview sample uses the
first method, to remove or restore segments in the drawing.
of colour data, which will be copied to the colour dialog's colour
data.
- Custom colours from colour data object will be be used in the dialog's
+ Custom colours from colour data object will be used in the dialog's
colour palette. Invalid entries in custom colours list will be ignored
on some platforms(GTK) or replaced with white colour on platforms where
custom colours palette has fixed size (MSW).
/**
Sets the RGB intensity values using the given values (first overload),
extracting them from the packed long (second overload), using the given
- string (third overloard).
+ string (third overload).
When using third form, Set() accepts: colour names (those listed in
wxColourDatabase), the CSS-like @c "rgb(r,g,b)" or @c "rgba(r,g,b,a)" syntax
void SetCustomColour(int i, const wxColour& colour);
/**
- Converts the colours saved in this class in a string form, separing
+ Converts the colours saved in this class in a string form, separating
the various colours with a comma.
*/
wxString ToString() const;
/**
This member function is not normally called in application code.
Instead, it can be implemented in a derived class to return default
- wxComboPopup, incase @a popup is @NULL.
+ wxComboPopup, in case @a popup is @NULL.
@note If you have implemented OnButtonClick() to do something else than
show the popup, then DoSetPopupControl() must always set @a popup
@n The @c wxCONFIG_USE_NO_ESCAPE_CHARACTERS style can be helpful if your
config file must be read or written to by a non-wxWidgets program
(which might not understand the escape characters). Note, however,
- that if @c wxCONFIG_USE_NO_ESCAPE_CHARACTERS style is used, it is is
+ that if @c wxCONFIG_USE_NO_ESCAPE_CHARACTERS style is used, it is
now your application's responsibility to ensure that there is no
newline or other illegal characters in a value, before writing that
value to the file.
/**
Delete the whole underlying object (disk file, registry key, ...).
- Primarly for use by uninstallation routine.
+ Primarily for use by uninstallation routine.
*/
virtual bool DeleteAll() = 0;
@param stream
The output stream.
@param conv
- Charset conversion object object used to encoding Unicode strings
+ Charset conversion object used to encoding Unicode strings
before writing them to the stream in Unicode mode (see
WriteString() for a detailed description). Note that you must not
destroy @a conv before you destroy this wxDataOutputStream
@param stream
The input stream.
@param conv
- Charset conversion object object used to decode strings in Unicode
+ Charset conversion object used to decode strings in Unicode
mode (see ReadString() for a detailed description). Note that you
must not destroy @a conv before you destroy this wxDataInputStream
instance!
In Unicode build of wxWidgets, the fuction first reads multibyte
(char*) string from the stream and then converts it to Unicode using
the @e conv object passed to constructor and returns the result as
- wxString. You are responsible for using the same convertor as when
+ wxString. You are responsible for using the same converter as when
writing the stream.
@see wxDataOutputStream::WriteString()
@class wxBufferedDC
This class provides a simple way to avoid flicker: when drawing on it,
- everything is infact first drawn on an in-memory buffer (a wxBitmap) and
+ everything is in fact first drawn on an in-memory buffer (a wxBitmap) and
then copied to the screen, using the associated wxDC, only once, when this
object is destroyed. wxBufferedDC itself is typically associated with
wxClientDC, if you want to use it in your @c EVT_PAINT handler, you should
The difference between wxBufferedPaintDC and this class is that this class
won't double-buffer on platforms which have native double-buffering
- already, avoiding any unneccessary buffering to avoid flicker.
+ already, avoiding any unnecessary buffering to avoid flicker.
wxAutoBufferedPaintDC is simply a typedef of wxPaintDC on platforms that
have native double-buffering, otherwise, it is a typedef of
/**
Retrieves the name (relative to GetDirectory()) and the description of
the file with the given index. If @a n is greater than or equal to the
- number of filse, @false is returned.
+ number of files, then @false is returned.
*/
bool GetFile(size_t n, wxString* name, wxString* desc) const;
*/
wxBOTH = wxVERTICAL | wxHORIZONTAL,
- /// A synonim for @c wxBOTH.
+ /// A synonym for @c wxBOTH.
wxORIENTATION_MASK = wxBOTH
};
Equivalent to a combination of wxCAPTION, wxCLOSE_BOX and
wxSYSTEM_MENU (the last one is not used under Unix).
@style{wxRESIZE_BORDER}
- Display a resizeable frame around the window.
+ Display a resizable frame around the window.
@style{wxSYSTEM_MENU}
Display a system menu.
@style{wxCLOSE_BOX}
/**
@class wxDialogLayoutAdapter
- This abstract class is the base for classes that help wxWidgets peform
+ This abstract class is the base for classes that help wxWidgets perform
run-time layout adaptation of dialogs. Principally, this is to cater for
small displays by making part of the dialog scroll, but the application
developer may find other uses for layout adaption.
bool IsConnectedEvent() const;
/**
- Does this event come from wxDialUpManager::Dial() or from some extrenal
+ Does this event come from wxDialUpManager::Dial() or from some external
process (i.e. does it result from our own attempt to establish the
connection)?
*/
@param noTemplates
Number of templates being pointed to by the templates pointer.
@param sort
- If more than one template is passed in in templates, then this
+ If more than one template is passed into templates, then this
parameter indicates whether the list of templates that the user
will have to choose from is sorted or not when shown the choice box
dialog. Default is @false.
@param noTemplates
Number of templates being pointed to by the templates pointer.
@param sort
- If more than one template is passed in in templates, then this
+ If more than one template is passed into templates, then this
parameter indicates whether the list of templates that the user
will have to choose from is sorted or not when shown the choice box
dialog. Default is @false.
however dumb, C++ compiler in the world.
Remember to include @<wx/arrimpl.cpp@> just before each
- WX_DEFINE_OBJARRAY() ocurrence in your code, even if you have several in
+ WX_DEFINE_OBJARRAY() occurrence in your code, even if you have several in
the same file.
Things are much simpler for wxArray and wxSortedArray however: it is enough
{
public:
/**
- Constuctor used by wxWidgets only.
+ Constructor used by wxWidgets only.
*/
wxFindDialogEvent(wxEventType commandType = wxEVT_NULL,
int id = 0);
{
public:
/**
- Constuctor initializes the flags to default value (0).
+ Constructor initializes the flags to default value (0).
*/
wxFindReplaceData(wxUint32 flags = 0);
void Detach();
/**
- Returns @true if the an attempt has been made to read @e past
+ Returns @true if an attempt has been made to read @e past
the end of the file.
Note that the behaviour of the file descriptor based class wxFile is different as
wxFileName::IsDirReadable() use wxFileName::GetPath() whereas methods dealing
with file names like wxFileName::IsFileReadable() use wxFileName::GetFullPath().
- If it is not known wether a string contains a directory name or a complete
+ If it is not known whether a string contains a directory name or a complete
file name (such as when interpreting user input) you need to use the static
function wxFileName::DirExists() (or its identical variants wxDir::Exists() and
wxDirExists()) and construct the wxFileName instance accordingly.
wxPathFormat format = wxPATH_NATIVE);
/**
- Creates the file name from volumne, path, name and extension.
+ Creates the file name from volume, path, name and extension.
*/
void Assign(const wxString& volume, const wxString& path,
const wxString& name,
wxPathFormat format = wxPATH_NATIVE);
/**
- Creates the file name from volumne, path, name and extension.
+ Creates the file name from volume, path, name and extension.
*/
void Assign(const wxString& volume, const wxString& path,
const wxString& name,
suffixes of B, KB, MB, GB, TB for bytes, kilobytes, megabytes,
gigabytes and terabytes respectively. With the IEC convention the names
of the units are changed to B, KiB, MiB, GiB and TiB for bytes,
- kibibytes, mebibyes, gibibytes and tebibytes. Finally, with SI
+ kibibytes, mebibytes, gibibytes and tebibytes. Finally, with SI
convention the same B, KB, MB, GB and TB suffixes are used but in their
correct SI meaning, i.e. as multiples of 1000 and not 1024.
recommended to only use it together with wxCAPTION for consistent
behaviour under all platforms.
@style{wxRESIZE_BORDER}
- Displays a resizeable border around the window.
+ Displays a resizable border around the window.
@style{wxFRAME_TOOL_WINDOW}
Causes a frame with a small title bar to be created; the frame does
not appear in the taskbar under Windows or GTK+.
with the SetShape() method.
@endStyleTable
- The default frame style is for normal, resizeable frames.
+ The default frame style is for normal, resizable frames.
To create a frame which cannot be resized by user, you may use the following
combination of styles:
@class wxFileSystemWatcherEvent
A class of events sent when a file system event occurs. Types of events
- reported may vary depending on a platfrom, however all platforms report
+ reported may vary depending on a platform, however all platforms report
at least creation of new file/directory and access, modification, move
(rename) or deletion of an existing one.
The wxGBSizerItem class is used by the wxGridBagSizer for tracking the
items in the sizer. It adds grid position and spanning information to the
- normal wxSizerItem by adding wxGBPosition and wxGBSpan attrbibutes. Most of
+ normal wxSizerItem by adding wxGBPosition and wxGBSpan attributes. Most of
the time you will not need to use a wxGBSizerItem directly in your code,
but there are a couple of cases where it is handy.
//@}
/**
- Returns @true if this item and the @a other item instersect.
+ Returns @true if this item and the @a other item intersect.
*/
bool Intersects(const wxGBSizerItem& other);
/**
wxPoint2DDouble GetPosition();
wxSize GetSize();
- // for the edge and corner accessors there are two setters conterparts, the Set.. functions keep the other corners at their
- // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners apropriately
+ // for the edge and corner accessors there are two setters counterparts, the Set.. functions keep the other corners at their
+ // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners appropriately
wxDouble GetLeft() const;
void SetLeft( wxDouble n );
wxPoint2DInt GetPosition();
wxSize GetSize();
- // for the edge and corner accessors there are two setters conterparts, the Set.. functions keep the other corners at their
- // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners apropriately
+ // for the edge and corner accessors there are two setters counterparts, the Set.. functions keep the other corners at their
+ // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners appropriately
wxInt32 GetLeft() const;
void SetLeft( wxInt32 n );
/// 1 for multisampling support (antialiasing)
WX_GL_SAMPLE_BUFFERS,
- /// 4 for 2x2 antialising supersampling on most graphics cards
+ /// 4 for 2x2 antialiasing supersampling on most graphics cards
WX_GL_SAMPLES
};
constants. If a constant should be followed by a value, put it in
the next array position. For example, WX_GL_DEPTH_SIZE should be
followed by the value that indicates the number of bits for the
- depth buffer, e.g:
+ depth buffer, e.g.:
@code
attribList[n++] = WX_GL_DEPTH_SIZE;
attribList[n++] = 32;
/**
Creates a native brush with a radial gradient.
- The brush originats at (@a xo, @a yc) and ends on a circle around
+ The brush originates at (@a xo, @a yc) and ends on a circle around
(@a xc, @a yc) with the given @a radius.
The gradient may be specified either by its start and end colours @a
The default table class is called wxGridStringTable and holds an array of
strings. An instance of such a class is created by CreateGrid().
- wxGridCellRenderer is the abstract base class for rendereing contents in a
+ wxGridCellRenderer is the abstract base class for rendering contents in a
cell. The following renderers are predefined:
- wxGridCellBoolRenderer
@a resizeExistingRows is @true.
If @a height is less than GetRowMinimalAcceptableHeight(), then the
- minimal acceptable heihgt is used instead of it.
+ minimal acceptable height is used instead of it.
*/
void SetDefaultRowSize(int height, bool resizeExistingRows = false);
Notice that currently there is no way to make some columns resizable in
a grid where columns can't be resized by default as there doesn't seem
to be any need for this in practice. There is also no way to make the
- column marked as fixed using this method resizeable again because it is
+ column marked as fixed using this method resizable again because it is
supposed that fixed columns are used for static parts of the grid and
so should remain fixed during the entire grid lifetime.
/**
Set the minimal column width.
- This method can be used with resizeable columns (i.e. those for which
+ This method can be used with resizable columns (i.e. those for which
wxCOL_RESIZABLE flag is set in GetFlags() or, alternatively,
IsResizeable() returns @true) to prevent the user from making them
narrower than the given width.
Call this to enable or disable interactive resizing of the column by
the user.
- By default, the columns are resizeable.
+ By default, the columns are resizable.
- Equivalent to ChangeFlag(wxCOL_RESIZABLE, resizeable).
+ Equivalent to ChangeFlag(wxCOL_RESIZABLE, resizable).
*/
- virtual void SetResizeable(bool resizeable);
+ virtual void SetResizeable(bool resizable);
/**
Allow clicking the column to sort the control contents by the field in
virtual bool LoadFile(const wxString& file = wxEmptyString);
/**
- Overrideable member called when this application's viewer is quit by the user.
+ Overridable member called when this application's viewer is quit by the user.
This does not work for all help controllers.
*/
virtual bool OnQuit();
/**
Sets the help controller associated with the dialog.
*/
- void SetController(wxHtmlHelpController* contoller);
+ void SetController(wxHtmlHelpController* controller);
/**
Sets the dialog's title format.
/**
Sets the help controller associated with the frame.
*/
- void SetController(wxHtmlHelpController* contoller);
+ void SetController(wxHtmlHelpController* controller);
/**
Sets the frame's title format.
This class has been rewritten to be type safe and to provide the full API of
the STL std::list container and should be used like it.
The exception is that wxList<T> actually stores pointers and therefore its
- iterators return pointers and not references to the actual objets in the list
+ iterators return pointers and not references to the actual objects in the list
(see example below) and @e value_type is defined as @e T*.
wxList<T> destroys an object after removing it only if wxList<T>::DeleteContents
has been called.
void DeleteContents(bool destroy);
/**
- Deletes the given element refered to by @a iter from the list
+ Deletes the given element referred to by @a iter from the list
if @a iter is a valid iterator. Returns @true if successful.
Deletes the actual object if DeleteContents( @true ) was called previously.
bool DeleteObject(T* object);
/**
- Removes element refered to be @a iter.
+ Removes element referred to be @a iter.
- Deletes the actualy object if DeleteContents( @true ) was called previously.
+ Deletes the actual object if DeleteContents( @true ) was called previously.
*/
void Erase(const compatibility_iterator& iter);
T* object);
/**
- Inserts @a object before the object refered to be @a iter.
+ Inserts @a object before the object referred to be @a iter.
*/
wxList<T>::compatibility_iterator Insert(compatibility_iterator iter,
T* object);
coordinates, of the given subitem, i.e. the part of the row @a item in the
column @a subItem.
- This method is only meaningfull when the wxListCtrl is in the report mode.
+ This method is only meaningful when the wxListCtrl is in the report mode.
If @a subItem parameter is equal to the special value
@c wxLIST_GETSUBITEMRECT_WHOLEITEM the return value is the same as
for GetItemRect().
Note that the latter must be called the same number of times as the former
to undo it, i.e. if you call Suspend() twice you must call Resume() twice as well.
- Note that suspending the logging means that the log sink won't be be flushed
+ Note that suspending the logging means that the log sink won't be flushed
periodically, it doesn't have any effect if the current log target does the
logging immediately without waiting for Flush() to be called (the standard
GUI log target only shows the log dialog when it is flushed, so Suspend()
/**
Sets the timestamp format prepended by the default log targets to all
messages. The string may contain any normal characters as well as %
- prefixed format specificators, see @e strftime() manual for details.
+ prefixed format specifiers, see @e strftime() manual for details.
Passing an empty string to this function disables message time stamping.
*/
static void SetTimestamp(const wxString& format);
/**
Sets the label associated with the menu item.
- Note that if the ID of this menu item corrisponds to a stock ID, then it is
+ Note that if the ID of this menu item corresponds to a stock ID, then it is
not necessary to specify a label: wxWidgets will automatically use the stock
item label associated with that ID. See the @ref wxMenuItem::wxMenuItem "constructor"
for more info.
@style{wxSYSTEM_MENU}
Displays a system menu (Windows and Motif only).
@style{wxRESIZE_BORDER}
- Displays a resizeable border around the window.
+ Displays a resizable border around the window.
@endStyleTable
@remarks
void MapScreenSizeToDevice();
/**
- This sets the user scale of the wxDC assocated with this wxPrintout to the same
+ This sets the user scale of the wxDC associated with this wxPrintout to the same
scale as MapScreenSizeToPaper() but sets the logical origin to the top left corner
of the page rectangle.
*/
void MapScreenSizeToPage();
/**
- This sets the user scale of the wxDC assocated with this wxPrintout to the same
+ This sets the user scale of the wxDC associated with this wxPrintout to the same
scale as MapScreenSizeToPageMargins() but sets the logical origin to the top left
corner of the page margins specified by the given wxPageSetupDialogData object.
*/
wxInputStream* GetInputStream() const;
/**
- It returns an output stream correspoding to the input stream of the subprocess.
+ It returns an output stream corresponding to the input stream of the subprocess.
If it is @NULL, you have not turned on the redirection or already
called CloseOutput().
/**
Set proportion of a auto-stretchable column. wxPG_SPLITTER_AUTO_CENTER
window style needs to be used to indicate that columns are auto-
- resizeable.
+ resizable.
@returns Returns @false on failure.
//@{
/**
- Data Access: Access to invidividual colour components.
+ Data Access: Access to individual colour components.
*/
ChannelType& Red();
ChannelType& Green();
/**
If sizing is not continuous, then return a suitable size for the control
- which is larger then the current size.
+ which is larger than the current size.
@param direction
The direction(s) in which the size should increase.
/**
If sizing is not continuous, then return a suitable size for the control
- which is larger then the given size.
+ which is larger than the given size.
@param direction
The direction(s) in which the size should increase.
Show the panel externally expanded.
When a panel is minimised, it can be shown full-size in a pop-out
- window, which is refered to as being (externally) expanded. Note that
+ window, which is referred to as being (externally) expanded. Note that
when a panel is expanded, there exist two panels - the original panel
- (which is refered to as the dummy panel) and the expanded panel. The
+ (which is referred to as the dummy panel) and the expanded panel. The
original is termed a dummy as it sits in the ribbon bar doing nothing,
while the expanded panel holds the panel children.
- ::wxScrolledCanvas, aka wxScrolled<wxWindow>, derives from wxWindow and
so doesn't handle children specially. This is suitable e.g. for
- implementating scrollable controls such as tree or list controls.
+ implementing scrollable controls such as tree or list controls.
Starting from version 2.4 of wxWidgets, there are several ways to use a
::wxScrolledWindow (and now wxScrolled). In particular, there are
wxSYS_COLOUR_3DLIGHT, //!< Light colour for three-dimensional display elements.
wxSYS_COLOUR_INFOTEXT, //!< Text colour for tooltip controls.
wxSYS_COLOUR_INFOBK, //!< Background colour for tooltip controls.
- wxSYS_COLOUR_LISTBOX, //!< Background colour for list-like contols.
+ wxSYS_COLOUR_LISTBOX, //!< Background colour for list-like controls.
wxSYS_COLOUR_HOTLIGHT, //!< Colour for a hyperlink or hot-tracked item.
/**
//!< Synonym for @c wxSYS_COLOUR_BTNHIGHLIGHT.
/**
- Synonim for @c wxSYS_COLOUR_BTNFACE.
+ Synonym for @c wxSYS_COLOUR_BTNFACE.
On wxMSW this colour should be used as the background colour of
wxFrames which are used as containers of controls; this is in fact the
The value of @a win determines if the metric returned is a global value or
a wxWindow based value, in which case it might determine the widget, the
display the window is on, or something similar. The window given should be as
- close to the metric as possible (e.g a wxTopLevelWindow in case of the
+ close to the metric as possible (e.g. a wxTopLevelWindow in case of the
wxSYS_CAPTION_Y metric).
@a index can be one of the ::wxSystemMetric enum values.
@style{wxSL_SELRANGE}
Allows the user to select a range on the slider. Windows only.
@style{wxSL_INVERSE}
- Inverses the mininum and maximum endpoints on the slider. Not
+ Inverses the minimum and maximum endpoints on the slider. Not
compatible with wxSL_SELRANGE.
@endStyleTable
The line may be only vertical or horizontal. Moreover, not all ports
(notably not wxGTK) support specifying the transversal direction of the
- line (e.g. height for a horizontal line) so for maximial portability you
+ line (e.g. height for a horizontal line) so for maximal portability you
should specify it as wxDefaultCoord.
@beginStyleTable
/**
@deprecated This function is deprecated, please use ToWChar() instead.
- Converts from a string @a in in multibyte encoding to Unicode putting up to
+ Converts from a string @a in multibyte encoding to Unicode putting up to
@a outLen characters into the buffer @e out.
If @a out is @NULL, only the length of the string which would result
/**
Reads the specified amount of bytes and stores the data in buffer.
- To check if the call was successfull you must use LastRead() to check
+ To check if the call was successful you must use LastRead() to check
if this call did actually read @a size bytes (if it didn't, GetLastError()
should return a meaningful value).
@flag{no-maskblt}
1 to never use WIN32's MaskBlt function, 0 to allow it to be used where possible.
Default: 0. In some circumstances the MaskBlt function can be slower than using
- the fallback code, especially if using DC cacheing. By default, MaskBlt will be
+ the fallback code, especially if using DC caching. By default, MaskBlt will be
used where it is implemented by the operating system and driver.
@flag{msw.remap}
If 1 (the default), wxToolBar bitmap colours will be remapped to the current
Also known as wxWINDOW_DEFAULT_VARIANT.
@flag{mac.listctrl.always_use_generic}
Tells wxListCtrl to use the generic control even when it is capable of
- using the native control instead. Also knwon as wxMAC_ALWAYS_USE_GENERIC_LISTCTRL.
+ using the native control instead. Also known as wxMAC_ALWAYS_USE_GENERIC_LISTCTRL.
@flag{mac.textcontrol-use-spell-checker}
This option only has effect for Mac OS X 10.4 and higher.
If 1 activates the spell checking in wxTextCtrl.
void SetTabs(const wxArrayInt& tabs);
/**
- Sets the text foreground colout.
+ Sets the text foreground colour.
*/
void SetTextColour(const wxColour& colText);
@param alpha
Determines how opaque or transparent the window will be, if the
- platform supports the opreration. A value of 0 sets the window to be
+ platform supports the operation. A value of 0 sets the window to be
fully transparent, and a value of 255 sets the window to be fully
opaque.
*/
wxTreeItemId handles, which may be tested for validity by calling
wxTreeItemId::IsOk().
- A similar control with a fully native implemtation for GTK+ and OS X
+ A similar control with a fully native implementation for GTK+ and OS X
as well is wxDataViewTreeCtrl.
To intercept events from a tree control, use the event table macros
y start coordinate, in screen coordinates.
@param x2
- x desintation coordinate, in screen coordinates.
+ x destination coordinate, in screen coordinates.
@param y2
y destination coordinate, in screen coordinates.
each character is stored using a 32-bit value. This is different from
wxString which may store a character either as a UTF-8 or as a UTF-16
sequence and different from @c std::string which stores a string
- as a squence of simple 8-bit charactesr and also different from
+ as a sequence of simple 8-bit characters and also different from
@c std::wstring which stores the string differently depending on
the definition of wchar_t.
/**
- Assigment from a 7-bit ASCII string literal
+ Assignment from a 7-bit ASCII string literal
*/
wxUString &assignFromAscii( const char *str );
/**
- Assigment from a 7-bit ASCII string literal
+ Assignment from a 7-bit ASCII string literal
*/
wxUString &assignFromAscii( const char *str, size_t n );
/**
- Assigment from a UTF-8 string literal
+ Assignment from a UTF-8 string literal
*/
wxUString &assignFromUTF8( const char *str );
/**
- Assigment from a UTF-8 string literal
+ Assignment from a UTF-8 string literal
*/
wxUString &assignFromUTF8( const char *str, size_t n );
/**
- Assigment from a UTF-16 string literal
+ Assignment from a UTF-16 string literal
*/
wxUString &assignFromUTF16( const wxChar16* str );
/**
- Assigment from a UTF-16 string literal
+ Assignment from a UTF-16 string literal
*/
wxUString &assignFromUTF16( const wxChar16* str, size_t n );
/**
- Assigment from a C string literal using wxConvLibc
+ Assignment from a C string literal using wxConvLibc
*/
wxUString &assignFromCString( const char* str );
/**
- Assigment from a C string literal using @a conv
+ Assignment from a C string literal using @a conv
*/
wxUString &assignFromCString( const char* str, const wxMBConv &conv );
'uname -r' command); e.g. "2" and "6" if the machine is using kernel 2.6.19.
For Mac OS X systems (@c wxOS_MAC) the major and minor version integers are the
- natural version numbers associated with the OS; e.g. "10" and and "6" if the machine
+ natural version numbers associated with the OS; e.g. "10" and "6" if the machine
is using Mac OS X Snow Leopard.
For Windows-like systems (@c wxOS_WINDOWS) the major and minor version integers will
wxVector(size_type size, const value_type& value);
/**
- Copy onstructor.
+ Copy constructor.
*/
wxVector(const wxVector<T>& c);
const wxString& name = wxPanelNameStr);
/**
- Same as the non-default constuctor, but returns a status code: @true if
+ Same as the non-default constructor, but returns a status code: @true if
ok, @false if the window couldn't be created.
Just as with the constructor, the @c wxVSCROLL style is always used,
const wxString& name = wxPanelNameStr);
/**
- Same as the non-default constuctor, but returns a status code: @true if
+ Same as the non-default constructor, but returns a status code: @true if
ok, @false if the window couldn't be created.
Just as with the constructor, the @c wxHSCROLL style is always used,
const wxString& name = wxPanelNameStr);
/**
- Same as the non-default constuctor, but returns a status code: @true if
+ Same as the non-default constructor, but returns a status code: @true if
ok, @false if the window couldn't be created.
Just as with the constructor, the @c wxHSCROLL and @c wxVSCROLL styles
*/
wxWindow* GetPrevSibling() const;
/**
- Reparents the window, i.e the window will be removed from its
+ Reparents the window, i.e. the window will be removed from its
current parent window (e.g. a non-standard toolbar in a wxFrame)
and then re-inserted into another.
/**
Sets the style of the window. Please note that some styles cannot be changed
- after the window creation and that Refresh() might need to be be called
+ after the window creation and that Refresh() might need to be called
after changing the others for the change to take place immediately.
See @ref overview_windowstyles "Window styles" for more information about flags.
/**
- @name Constraints, sizers and window layouting functions
+ @name Constraints, sizers and window layout functions
*/
//@{
This method calls SetSizer() and then wxSizer::SetSizeHints which sets the initial
window size to the size needed to accommodate all sizer elements and sets the
size hints which, if this window is a top level one, prevent the user from
- resizing it to be less than this minimial size.
+ resizing it to be less than this minimal size.
*/
void SetSizerAndFit(wxSizer* sizer, bool deleteOld = true);
Also, the wizard will never be smaller than the default size.
The recommended way to use this function is to lay out all wizard pages
- using the sizers (even though the wizard is not resizeable) and then use
+ using the sizers (even though the wizard is not resizable) and then use
wxSizer::CalcMin() in a loop to calculate the maximum of minimal sizes of
the pages and pass it to SetPageSize().
*/
wxT("it to wordpad or any other droptarget accepting text (and of course you can just drag it\n")
wxT("to the right pane). Due to a lot of trace messages, the cursor might take some time to \n")
wxT("change, don't release the mouse button until it does. You can change the string being\n")
- wxT("dragged in in \"File|Test drag...\" dialog.\n")
+ wxT("dragged in \"File|Test drag...\" dialog.\n")
wxT("\n")
wxT("\n")
wxT("Please send all questions/bug reports/suggestions &c to \n")
grid->SetCellAlignment(7, 1, wxALIGN_CENTRE, wxALIGN_CENTRE);
grid->SetCellValue(7, 1, wxT("Big box!"));
- // create a separator-like row: it's grey and it's non-resizeable
+ // create a separator-like row: it's grey and it's non-resizable
grid->DisableRowResize(10);
grid->SetRowSize(10, 30);
attr = new wxGridCellAttr;
#define USE_CONTEXT_MENU 1
#endif
-// this sample is usefull when new port is developed
-// and usually new port has majority of flags turned off
+// this sample is useful when a new port is developed
+// and usually a new port has majority of flags turned off
#if wxUSE_LOG && wxUSE_TEXTCTRL
#define USE_LOG_WINDOW 1
#else
s = wxString::Format(wxT("%i tests failed!!!"), failures);
#ifdef __WXDEBUG__
else
- s = wxString::Format(wxT("All tests were successfull, but there were %i warnings!"), wxPGGlobalVars->m_warnings);
+ s = wxString::Format(wxT("All tests were successful, but there were %i warnings!"), wxPGGlobalVars->m_warnings);
#endif
RT_MSG(s)
for ( i=0; i<errorMessages.size(); i++ )
// the controls
// ------------
- // the contols to choose the checkbox style
+ // the controls to choose the checkbox style
wxCheckBox *m_chkRight;
wxRadioBox *m_radioKind;
class MyResizableListCtrl : public wxListCtrl
{
// Very helpful wxWidgets macro required for wxWidgets-RTTI tracing: By using this
- // you will see "Leaked one object of type myResizeableListCtrl" in the debug log,
+ // you will see "Leaked one object of type myResizableListCtrl" in the debug log,
// along with which line you if was created, but you forget to free the memory.
// NOTE: Using this REQUIRES a default constructor: that means either: giving a
// default value for all parameters in your constructor, or else having a dummy
const wxString &name = wxT("myResizableListCtrl")
);
- // Destuctor.
+ // Destructor.
~MyResizableListCtrl(){};
protected:
before the run loop waits and send the idle events from there.
It also has the desirable effect of only sending the wx idle events when
- the event loop is actualy going to block. If the event loop is being
+ the event loop is actually going to block. If the event loop is being
pumped manualy (e.g. like a PeekMessage) then the kCFRunLoopBeforeWaiting
observer never fires. Our Yield() method depends on this because sending
idle events from within Yield would be bad.
position is at range-thumbsize.
The range of an NSScroller is 0.0 to 1.0. Much easier! NOTE: Apple doesn't really specify
- but GNUStep docs do say that 0.0 is top/left and 1.0 is bottom/right. This is actualy
+ but GNUStep docs do say that 0.0 is top/left and 1.0 is bottom/right. This is actually
in contrast to NSSlider which generally has 1.0 at the TOP when it's done vertically.
*/
CGFloat cocoaScrollPos = [cocoaScroller floatValue];
wxDATAVIEW_CELL_EDITABLE,
-1, // default width
wxALIGN_NOT, // and alignment
- 0 // not resizeable
+ 0 // not resizable
);
return true;
format.Replace("%X",wxLocale::GetInfo(wxLOCALE_TIME_FMT));
#endif
// we have to use our own implementation if the date is out of range of
- // strftime() or if we use non standard specificators
+ // strftime() or if we use non standard specifiers
#ifdef wxHAS_STRFTIME
time_t time = GetTicks();
}
// no, it wasn't the width
- wxFAIL_MSG(wxT("unknown format specificator"));
+ wxFAIL_MSG(wxT("unknown format specifier"));
// fall through and just copy it nevertheless
y2 = y2-y-y+1;
--y;
}
- // old y now to big: set point with old y, old x
+ // old y now too big: set point with old y, old x
if( bNewPoint && x>1)
{
int x1 = x - 1;
{
case wxCOPY: // src
// since we are supporting alpha, _OVER is closer to the intention than _SOURCE
- // since the latter would overwrite even when alpha is is not set to opaque
+ // since the latter would overwrite even when alpha is not set to opaque
*op = wxCOMPOSITION_OVER;
break;
case wxOR: // src OR dst
unsigned char hdr[HDR_SIZE];
stream.Read(hdr, HDR_SIZE); // it's ok to modify the stream position here
- // Check wether we can read the file or not.
+ // Check whether we can read the file or not.
short colorType = hdr[HDR_COLORTYPE];
if ( colorType != wxTGA_UNMAPPED && colorType != wxTGA_MAPPED )
topsizer->Add(m_dirCtrl, wxSizerFlags(flagsBorder2).Proportion(1).Expand());
#ifndef __SMARTPHONE__
- // Make the an option depending on a flag?
+ // TODO: Make this an option depending on a flag?
wxCheckBox *
check = new wxCheckBox(this, ID_SHOW_HIDDEN, _("Show &hidden directories"));
topsizer->Add(check, wxSizerFlags(flagsBorder2).Right());
ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
m_dragLastPos = -1;
}
- else // not on row separator or it's not resizeable
+ else // not on row separator or it's not resizable
{
row = YToRow(y);
if ( row >=0 &&
while ( tk.HasMoreTokens() )
{
wxString tok = tk.GetNextToken();
- //FIXME: this causes us to print an extra unnecesary
+ //FIXME: this causes us to print an extra unnecessary
// space at the end of the line. But it
// is invisible , simplifies the size calculation
// and ensures tokens are separated in the display
pos += col.GetWidth();
- // if the column is resizeable, check if we're approximatively over the
+ // if the column is resizable, check if we're approximatively over the
// line separating it from the next column
//
// TODO: don't hardcode sensitivity
bool isPda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
// create the controls which are always shown and layout them: we use
- // sizers even though our window is not resizeable to calculate the size of
+ // sizers even though our window is not resizable to calculate the size of
// the dialog properly
wxBoxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
wxBoxSizer *sizerAll = new wxBoxSizer(isPda ? wxVERTICAL : wxHORIZONTAL);
// part of a wxComboCtrl visible and the button would still be outside the
// scrolled area. But do so only if the parent fits *entirely* inside the
// scrolled window. In other situations, such as nested wxPanel or
- // wxScrolledWindows, the parent might be way to big to fit inside the
+ // wxScrolledWindows, the parent might be way too big to fit inside the
// scrolled window. If that is the case, then make only the focused window
// visible
if ( win->GetParent() != m_targetWindow)
dlg->callback = NULL;
dlg->userdata = NULL;
- /* the resizeable property of this window is modified by the expander:
- when it's collapsed, the window must be non-resizeable! */
+ /* the resizable property of this window is modified by the expander:
+ when it's collapsed, the window must be non-resizable! */
gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE);
gtk_widget_pop_composite_child ();
gtk_widget_show_all (GTK_WIDGET(dlg));
// 1) need to update our size hints
// NB: this function call won't actually do any long operation
- // (redraw/relayouting/resizing) so that it's flicker-free
+ // (redraw/relayout/resize) so that it's flicker-free
p->SetMinSize(sz);
if (p->HasFlag(wxCP_NO_TLW_RESIZE))
// transition. This may be sometimes undesired but *is*
// necessary and if you look carefully, all GTK+ programs using
// GtkExpander perform this trick (e.g. the standard "open file"
- // dialog of GTK+>=2.4 is not resizeable when the expander is
+ // dialog of GTK+>=2.4 is not resizable when the expander is
// collapsed!)
gtk_window_set_resizable (GTK_WINDOW (top->m_widget), p->IsExpanded());
gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column), !hidden );
}
-void wxDataViewColumn::SetResizeable( bool resizeable )
+void wxDataViewColumn::SetResizeable( bool resizable )
{
- gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column), resizeable );
+ gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column), resizable );
}
void wxDataViewColumn::SetAlignment( wxAlignment align )
// local-only property could be set to false to allow non-local files to be loaded.
// In that case get/set_uri(s) should be used instead of get/set_filename(s) everywhere
// and the GtkFileChooserDialog should probably also be created with a backend,
- // e.g "gnome-vfs", "default", ... (gtk_file_chooser_dialog_new_with_backend).
+ // e.g. "gnome-vfs", "default", ... (gtk_file_chooser_dialog_new_with_backend).
// Currently local-only is kept as the default - true:
// gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true);
// local-only property could be set to false to allow non-local files to be
// loaded. In that case get/set_uri(s) should be used instead of
// get/set_filename(s) everywhere and the GtkFileChooserDialog should
- // probably also be created with a backend, e.g "gnome-vfs", "default", ...
+ // probably also be created with a backend, e.g. "gnome-vfs", "default", ...
// (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept
// as the default - true:
// gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true);
#include "wx/gtk/private/object.h"
-// Usefull to convert angles from/to Rad to/from Deg.
+// Useful to convert angles from/to Rad to/from Deg.
static const double RAD2DEG = 180.0 / M_PI;
static const double DEG2RAD = M_PI / 180.0;
break;
default:
- // unknwon button, don't process
+ // unknown button, don't process
return FALSE;
}
/*
- LAYOUTING :
+ LAYOUT :
*/
s_indent = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
s_width = m_Width - s_indent - ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
- // my own layouting:
+ // my own layout:
wxHtmlCell *cell = m_Cells,
*line = m_Cells;
while (cell != NULL)
// ('width' is the number, 'units' determines its meaning)
int minWidth, maxWidth;
// minimal/maximal column width. This is needed by HTML 4.0
- // layouting algorithm and can be determined by trying to
+ // layout algorithm and can be determined by trying to
// layout table cells with width=1 and width=infinity
int leftpos, pixwidth, maxrealwidth;
// temporary (depends on actual width of table)
/*
- LAYOUTING :
+ LAYOUT :
*/
);
// we must use WS_CLIPSIBLINGS with the buttons or they would draw over
- // each other in any resizeable dialog which has more than one button in
+ // each other in any resizable dialog which has more than one button in
// the bottom
msStyle |= WS_CLIPSIBLINGS;
}
#endif // wxUSE_DIALOG_SIZEGRIP
- // the Windows dialogs unfortunately are not meant to be resizeable
+ // the Windows dialogs unfortunately are not meant to be resizable
// at all and their standard class doesn't include CS_[VH]REDRAW
// styles which means that the window is not refreshed properly
// after the resize and no amount of WS_CLIPCHILDREN/SIBLINGS can
// ----------------------------------------------------------------------------
// standard dialog size for the old Windows systems where the dialog wasn't
-// resizeable
+// resizable
static wxRect gs_rectDialog(0, 0, 428, 266);
// ============================================================================
// ASCII and Unicode versions of this message
case HDN_BEGINTRACKA:
case HDN_BEGINTRACKW:
- // non-resizeable columns can't be resized no matter what, don't
+ // non-resizable columns can't be resized no matter what, don't
// even generate any events for them
if ( !GetColumn(idx).IsResizeable() )
{
m_textCtrl->SubclassWin(hWnd);
m_textCtrl->SetParent(this);
- // we must disallow TABbing away from the control while the edit contol is
+ // we must disallow TABbing away from the control while the edit control is
// shown because this leaves it in some strange state (just try removing
// this line and then pressing TAB while editing an item in listctrl
// inside a panel)
WXDWORD msStyle = wxStatusBarBase::MSWGetStyle(style, exstyle);
// wxSTB_SIZEGRIP is part of our default style but it doesn't make sense to
- // show size grip if this is the status bar of a non-resizeable TLW so turn
+ // show size grip if this is the status bar of a non-resizable TLW so turn
// it off in such case
wxWindow * const parent = GetParent();
wxCHECK_MSG( parent, msStyle, wxS("Status bar must have a parent") );
if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG )
{
// we have different dialog templates to allows creation of dialogs
- // with & without captions under MSWindows, resizeable or not (but a
- // resizeable dialog always has caption - otherwise it would look too
+ // with & without captions under MSWindows, resizable or not (but a
+ // resizable dialog always has caption - otherwise it would look too
// strange)
// we need 3 additional WORDs for dialog menu, class and title (as we
//
// We must use WS_CLIPSIBLINGS with the buttons or they would draw over
- // each other in any resizeable dialog which has more than one button in
+ // each other in any resizable dialog which has more than one button in
// the bottom
//
dwStyle |= WS_CLIPSIBLINGS;
vInsert.fInvalidateRecord = TRUE;
//
- // Check wether we need to allocate our internal data
+ // Check whether we need to allocate our internal data
//
bool bNeedInternalData = ((rInfo.GetMask() & wxLIST_MASK_DATA) ||
rInfo.HasAttributes()
if (m_bmpChecked.Ok())
{
//
- // Is BMP height larger then text height?
+ // Is BMP height larger than text height?
//
size_t nAdjustedHeight = m_bmpChecked.GetHeight() +
wxSystemSettings::GetMetric(wxSYS_EDGE_Y);
{
//
// We have different dialog templates to allow creation of dialogs
- // with & without captions under OS2indows, resizeable or not (but a
- // resizeable dialog always has caption - otherwise it would look too
+ // with & without captions under OS2indows, resizable or not (but a
+ // resizable dialog always has caption - otherwise it would look too
// strange)
//
ULONG ulDlgTemplate;
// use WinQueryWindowPos. This call, unlike the WIN32 call, however,
// returns a position relative to it's parent, so no parent adujstments
// are needed under OS/2. Also, windows should be created using
- // wxWindow coordinates, i.e 0,0 is the TOP left.
+ // wxWindow coordinates, i.e. 0,0 is the TOP left.
//
if (IsKindOf(CLASSINFO(wxFrame)))
{
}
}
-void wxDataViewColumn::SetResizeable(bool resizeable)
+void wxDataViewColumn::SetResizeable(bool resizable)
{
// first set the internal flag of the column:
- if (resizeable)
+ if (resizable)
m_flags |= wxDATAVIEW_COL_RESIZABLE;
else
m_flags &= ~wxDATAVIEW_COL_RESIZABLE;
DataBrowserListViewHeaderDesc headerDescription;
verify_noerr(macDataViewListCtrlPtr->GetHeaderDesc(GetNativeData()->GetPropertyID(),&headerDescription));
- if (resizeable)
+ if (resizable)
{
if (GetMinWidth() >= GetMaxWidth())
{
CGRect r = CGRectMake( (CGFloat) x , (CGFloat) y , (CGFloat) w , (CGFloat) h );
if ( refdata->IsMonochrome() == 1 )
{
- // is is a mask, the '1' in the mask tell where to draw the current brush
+ // is a mask, the '1' in the mask tell where to draw the current brush
if ( !m_brush.IsNull() )
{
if ( ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() )
}
if ( point.y < bounds.top )
- // index(bounds) greater then key(point)
+ // index(bounds) greater than key(point)
high = mid - 1;
else
// index(bounds) less than key(point)
[nativeColumn setMinWidth:column->GetMinWidth()];
[nativeColumn setMaxWidth:column->GetMaxWidth()];
}
- else // column is not resizeable [by user]
+ else // column is not resizable [by user]
{
// if the control doesn't show a header, make the columns resize
// automatically, this is particularly important for the single column
return [m_NativeDataPtr->GetNativeColumnPtr() isHidden];
}
-void wxDataViewColumn::SetResizeable(bool resizeable)
+void wxDataViewColumn::SetResizeable(bool resizable)
{
- wxDataViewColumnBase::SetResizeable(resizeable);
- if (resizeable)
+ wxDataViewColumnBase::SetResizeable(resizable);
+ if (resizable)
[m_NativeDataPtr->GetNativeColumnPtr() setResizingMask:NSTableColumnUserResizingMask];
else
[m_NativeDataPtr->GetNativeColumnPtr() setResizingMask:NSTableColumnNoResizing];
void ButtonTestCase::BitmapMargins()
{
- //Some functions only work on specific platfroms in which case we can use
+ //Some functions only work on specific platforms in which case we can use
//a preprocessor check
#ifdef __WXMSW__
//We must set a bitmap before we can set its margins, when writing unit
const TStreamIn &stream_in = CreateInStream();
CPPUNIT_ASSERT(!stream_in.Eof());
- // Size should be greater then zero.
+ // Size should be greater than zero.
// Note: streams not supporting this should register this test
// with CPPUNIT_TEST_FAIL instead of CPPUNIT_TEST.
CPPUNIT_ASSERT(stream_in.GetSize() != 0);
return;
delete m_pCurrentIn;
m_pCurrentIn = NULL;
- // Incase something extra needs to be done.
+ // In case something extra needs to be done.
DoDeleteInStream();
}
void DeleteOutStream()
delete m_pCurrentOut;
m_pCurrentOut = NULL;
- // Incase something extra needs to be done.
+ // In case something extra needs to be done.
DoDeleteOutStream();
}
// Check if we are in an infinite loop by multiplying value_size
// by 5 to have a *much* bigger range then the real range.
- // Note: Incase you ask your self, why 5, the answer is no reason...
- // it is not to big and not to small a size, nothing more
+ // Note: In case you ask yourself, why 5, the answer is no reason...
+ // it is not too big and not to small a size, nothing more
// nothing less to it.
if (i > (value_size*5))
{
projects / wxWidgets.git / commitdiff
