wxCC_IFLAG_CREATED = 0x0100,
// Internal use: really put button outside
wxCC_IFLAG_BUTTON_OUTSIDE = 0x0200,
- // Internal use: SetTextIndent has been called
- wxCC_IFLAG_INDENT_SET = 0x0400,
+ // Internal use: SetMargins has been succesfully called
+ wxCC_IFLAG_LEFT_MARGIN_SET = 0x0400,
// Internal use: Set wxTAB_TRAVERSAL to parent when popup is dismissed
wxCC_IFLAG_PARENT_TAB_TRAVERSAL = 0x0800,
// Internal use: Secondary popup window type should be used (if available).
BitmapButton = 0x0002, // Button may be replaced with bitmap
ButtonSpacing = 0x0004, // Button can have spacing from the edge
// of the control
- TextIndent = 0x0008, // SetTextIndent can be used
+ TextIndent = 0x0008, // SetMargins can be used to control
+ // left margin.
PaintControl = 0x0010, // Combo control itself can be custom painted
PaintWritable = 0x0020, // A variable-width area in front of writable
// combo control's textctrl can be custom
const wxBitmap& bmpHover = wxNullBitmap,
const wxBitmap& bmpDisabled = wxNullBitmap );
+#if WXWIN_COMPATIBILITY_2_6
//
// This will set the space in pixels between left edge of the control and the
// text, regardless whether control is read-only (ie. no wxTextCtrl) or not.
// Platform-specific default can be set with value-1.
// Remarks
// * This method may do nothing on some native implementations.
- void SetTextIndent( int indent );
+ wxDEPRECTED( void SetTextIndent( int indent ) );
// Returns actual indentation in pixels.
- wxCoord GetTextIndent() const
- {
- return m_absIndent;
- }
+ wxDEPRECTED( wxCoord GetTextIndent() const );
+#endif
// Returns area covered by the text field.
const wxRect& GetTextRect() const
const wxBitmap& GetBitmapHover() const { return m_bmpHover; }
const wxBitmap& GetBitmapDisabled() const { return m_bmpDisabled; }
+ // Margins functions mirrored from TextEntryBase
+ // (wxComboCtrl does not inherit from wxTextEntry, but may embed a
+ // wxTextCtrl, so we need these). Also note that these functions
+ // have replaced SetTextIndent() in wxWidgets 2.9.1 and later.
+ bool SetMargins(const wxPoint& pt)
+ { return DoSetMargins(pt); }
+ bool SetMargins(wxCoord left, wxCoord top = -1)
+ { return DoSetMargins(wxPoint(left, top)); }
+ wxPoint GetMargins() const
+ { return DoGetMargins(); }
+
// Return internal flags
wxUint32 GetInternalFlags() const { return m_iFlags; }
// called from wxSizeEvent handler
virtual void OnResize() = 0;
- // Return native text identation (for pure text, not textctrl)
+ // Return native text identation
+ // (i.e. text margin, for pure text, not textctrl)
virtual wxCoord GetNativeTextIndent() const;
// Called in syscolourchanged handler and base create
virtual void DoSetToolTip( wxToolTip *tip );
#endif
+ // margins functions
+ virtual bool DoSetMargins(const wxPoint& pt);
+ virtual wxPoint DoGetMargins() const;
+
// This is used when m_text is hidden (readonly).
wxString m_valueString;
// selection indicator.
wxCoord m_widthCustomPaint;
- // absolute text indentation, in pixels
- wxCoord m_absIndent;
+ // left margin, in pixels
+ wxCoord m_marginLeft;
// side on which the popup is aligned
int m_anchorSide;
// custom list stores.
virtual void GTKCreateComboBoxWidget();
- // return the GtkEntry part of the combobox
- GtkEntry *GetEntry() const { return m_entry; }
+ virtual GtkEntry *GetEntry() const
+ { return m_entry; }
GtkEntry* m_entry;
private:
// overridden wxTextEntry virtual methods
virtual GtkEditable *GetEditable() const;
+ virtual GtkEntry *GetEntry() const;
virtual void EnableTextChangedEvents(bool enable);
// change the font for everything in this control
#define _WX_GTK_TEXTENTRY_H_
typedef struct _GtkEditable GtkEditable;
+typedef struct _GtkEntry GtkEntry;
// ----------------------------------------------------------------------------
// wxTextEntry: roughly corresponds to GtkEditable
protected:
virtual wxString DoGetValue() const;
+ // margins functions
+ virtual bool DoSetMargins(const wxPoint& pt);
+ virtual wxPoint DoGetMargins() const;
+
private:
// implement this to return the associated GtkEntry or another widget
// implementing GtkEditable
virtual GtkEditable *GetEditable() const = 0;
+
+ // implement this to return the associated GtkEntry
+ virtual GtkEntry *GetEntry() const = 0;
};
#endif // _WX_GTK_TEXTENTRY_H_
};
virtual void DoSetSelection(long from, long to, int flags = SetSel_Scroll);
+ // margins functions
+ virtual bool DoSetMargins(const wxPoint& pt);
+ virtual wxPoint DoGetMargins() const;
+
private:
// implement this to return the HWND of the EDIT control
virtual WXHWND GetEditHWND() const = 0;
// space between vertical line and value editor control
#define wxPG_XBEFOREWIDGET 1
- // x position adjustment for wxTextCtrl (and like)
- #define wxPG_TEXTCTRLXADJUST 3
-
// comment to use bitmap buttons
#define wxPG_ICON_WIDTH 9
// 1 if wxRendererNative should be employed
#define wxPG_XBEFOREWIDGET 1
// x position adjustment for wxTextCtrl (and like)
- #define wxPG_TEXTCTRLXADJUST 3
+ // NB: Only define wxPG_TEXTCTRLXADJUST for platforms that do not
+ // (yet) support wxTextEntry::SetMargins() for the left margin.
+ //#define wxPG_TEXTCTRLXADJUST 3
// comment to use bitmap buttons
#define wxPG_ICON_WIDTH 9
#ifdef __WXGTK20__
virtual wxWindow *GetEditableWindow() { return this; }
virtual GtkEditable *GetEditable() const { return NULL; }
+ virtual GtkEntry *GetEntry() const { return NULL; }
#endif
// Overrides
virtual wxString GetHint() const;
+ // margins
+ // -------
+
+ // margins are the empty space between borders of control and the text
+ // itself. When setting margin, use value -1 to indicate that specific
+ // margin should not be changed.
+
+ bool SetMargins(const wxPoint& pt)
+ { return DoSetMargins(pt); }
+ bool SetMargins(wxCoord left, wxCoord top = -1)
+ { return DoSetMargins(wxPoint(left, top)); }
+ wxPoint GetMargins() const
+ { return DoGetMargins(); }
+
protected:
// flags for DoSetValue(): common part of SetValue() and ChangeValue() and
// also used to implement WriteText() in wxMSW
// generation and also by generic hints implementation
virtual wxWindow *GetEditableWindow() = 0;
+ // margins functions
+ virtual bool DoSetMargins(const wxPoint& pt);
+ virtual wxPoint DoGetMargins() const;
+
// class which should be used to temporarily disable text change events
//
BitmapButton = 0x0002, ///< Button may be replaced with bitmap.
ButtonSpacing = 0x0004, ///< Button can have spacing from the edge
///< of the control.
- TextIndent = 0x0008, ///< wxComboCtrl::SetTextIndent() can be used.
+ TextIndent = 0x0008, ///< wxComboCtrl::SetMargins() can be used.
PaintControl = 0x0010, ///< Combo control itself can be custom painted.
PaintWritable = 0x0020, ///< A variable-width area in front of writable
///< combo control's textctrl can be custom
*/
virtual long GetLastPosition() const;
+ /**
+ Returns the margins used by the control. The @c x field of the returned
+ point is the horizontal margin and the @c y field is the vertical one.
+
+ @remarks If given margin cannot be accurately determined, its value
+ will be set to -1.
+
+ @see SetMargins()
+
+ @since 2.9.1
+ */
+ wxPoint GetMargins() const;
+
/**
Returns current popup interface that has been set with
SetPopupControl().
/**
Returns actual indentation in pixels.
+
+ @deprecated Use GetMargins() instead.
*/
wxCoord GetTextIndent() const;
*/
virtual void SetInsertionPointEnd();
+ //@{
+ /**
+ Attempts to set the control margins. When margins are given as wxPoint,
+ x indicates the left and y the top margin. Use -1 to indicate that
+ an existing value should be used.
+
+ @return
+ @true if setting of all requested margins was successful.
+
+ @since 2.9.1
+ */
+ bool SetMargins(const wxPoint& pt);
+ bool SetMargins(wxCoord left, wxCoord top = -1);
+ //@}
+
/**
Set side of the control to which the popup will align itself. Valid
values are @c wxLEFT, @c wxRIGHT and 0. The default value 0 means that
This will set the space in pixels between left edge of the control and
the text, regardless whether control is read-only or not. Value -1 can
be given to indicate platform default.
+
+ @deprecated Use SetMargins() instead.
*/
void SetTextIndent(int indent);
*/
virtual wxString GetHint() const;
+ //@{
+ /**
+ Attempts to set the control margins. When margins are given as wxPoint,
+ x indicates the left and y the top margin. Use -1 to indicate that
+ an existing value should be used.
+
+ @return
+ @true if setting of all requested margins was successful.
+
+ @since 2.9.1
+ */
+ bool SetMargins(const wxPoint& pt);
+ bool SetMargins(wxCoord left, wxCoord top = -1);
+ //@}
+
+ /**
+ Returns the margins used by the control. The @c x field of the returned
+ point is the horizontal margin and the @c y field is the vertical one.
+
+ @remarks If given margin cannot be accurately determined, its value
+ will be set to -1. On some platforms you cannot obtain valid
+ margin values until you have called SetMargins().
+
+ @see SetMargins()
+
+ @since 2.9.1
+ */
+ wxPoint GetMargins() const;
+
/**
Sets the new text control value.
#define TEXTCTRL_TEXT_CENTERED 0 // 1 if text in textctrl is vertically centered
#define FOCUS_RING 0 // No focus ring on wxMSW
+#if !defined(__WXWINCE__)
+ // 1 if wxTextEntry::SetMargins() can be used to set the left margin
+ #define LEFT_MARGIN_CAN_BE_SET 1
+#else
+ #define LEFT_MARGIN_CAN_BE_SET 0
+#endif
+
//#undef wxUSE_POPUPWIN
//#define wxUSE_POPUPWIN 0
#elif defined(__WXGTK__)
+#include "wx/gtk/private.h"
+
// NB: It is not recommended to use wxDialog as popup on wxGTK, because of
// this bug: If wxDialog is hidden, its position becomes corrupt
// between hide and next show, but without internal coordinates being
#define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
#define FOCUS_RING 0 // No focus ring on wxGTK
+#if GTK_CHECK_VERSION(2,10,0)
+ // 1 if wxTextEntry::SetMargins() can be used to set the left margin
+ #define LEFT_MARGIN_CAN_BE_SET 1
+#else
+ #define LEFT_MARGIN_CAN_BE_SET 0
+#endif
+
#elif defined(__WXMAC__)
#define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
#undef COMBO_MARGIN
#define COMBO_MARGIN FOCUS_RING
+// 1 if wxTextEntry::SetMargins() can be used to set the left margin
+#define LEFT_MARGIN_CAN_BE_SET 0
+
#else
#define USE_TRANSIENT_POPUP 0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
#define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
#define FOCUS_RING 0
+// 1 if wxTextEntry::SetMargins() can be used to set the left margin
+#define LEFT_MARGIN_CAN_BE_SET 0
+
#endif
combo->PrepareBackground(dc,rect,0);
dc.DrawText( combo->GetValue(),
- rect.x + combo->GetTextIndent(),
+ rect.x + combo->m_marginLeft,
(rect.height-dc.GetCharHeight())/2 + rect.y );
}
}
m_extLeft = 0;
m_extRight = 0;
- m_absIndent = -1;
+ m_marginLeft = -1;
m_iFlags = 0;
m_timeCanAcceptClick = 0;
// Get colours
OnThemeChange();
- m_absIndent = GetNativeTextIndent();
+ m_marginLeft = GetNativeTextIndent();
m_iFlags |= wxCC_IFLAG_CREATED;
}
// Defaul indentation
- if ( m_absIndent < 0 )
- m_absIndent = GetNativeTextIndent();
+ if ( m_marginLeft < 0 )
+ m_marginLeft = GetNativeTextIndent();
int butWidth = btnWidth;
if ( !m_text )
return;
-#if !TEXTCTRL_TEXT_CENTERED
-
wxSize sz = GetClientSize();
int customBorder = m_widthCustomBorder;
if ( (m_text->GetWindowStyleFlag() & wxBORDER_MASK) == wxNO_BORDER )
{
+#if LEFT_MARGIN_CAN_BE_SET
+ // Call SetMargins() on textctrl if LEFT_MARGIN_CAN_BE_SET == 1
+ wxUnusedVar(textCtrlXAdjust);
+ m_text->SetMargins(0);
+ textCtrlXAdjust = 0;
+#endif
+
// Centre textctrl
+#if !TEXTCTRL_TEXT_CENTERED
int tcSizeY = m_text->GetBestSize().y;
- int diff = sz.y - tcSizeY;
- int y = textCtrlYAdjust + (diff/2);
+ int diff0 = sz.y - tcSizeY;
+ int y = textCtrlYAdjust + (diff0/2);
+#else
+ wxUnusedVar(textCtrlYAdjust);
+ int y = 0;
+#endif
if ( y < customBorder )
y = customBorder;
- m_text->SetSize( m_tcArea.x + m_widthCustomPaint + m_absIndent + textCtrlXAdjust,
- y,
- m_tcArea.width - COMBO_MARGIN -
- (textCtrlXAdjust + m_widthCustomPaint + m_absIndent),
- -1 );
+ int x = m_tcArea.x + m_widthCustomPaint +
+ m_marginLeft + textCtrlXAdjust;
+
+ m_text->SetSize(x,
+ y,
+ m_tcArea.width - m_tcArea.x - x,
+ /*m_tcArea.width - COMBO_MARGIN -
+ (textCtrlXAdjust + m_widthCustomPaint +
+ m_marginLeft),*/
+ -1 );
// Make sure textctrl doesn't exceed the bottom custom border
wxSize tsz = m_text->GetSize();
- diff = (y + tsz.y) - (sz.y - customBorder);
- if ( diff >= 0 )
+ int diff1 = (y + tsz.y) - (sz.y - customBorder);
+ if ( diff1 >= 0 )
{
- tsz.y = tsz.y - diff - 1;
+ tsz.y = tsz.y - diff1 - 1;
m_text->SetSize(tsz);
}
}
else
-#else // TEXTCTRL_TEXT_CENTERED
- wxUnusedVar(textCtrlXAdjust);
- wxUnusedVar(textCtrlYAdjust);
-#endif // !TEXTCTRL_TEXT_CENTERED/TEXTCTRL_TEXT_CENTERED
{
- // If it has border, have textctrl will the entire text field.
+ // If it has border, have textctrl fill the entire text field.
m_text->SetSize( m_tcArea.x + m_widthCustomPaint,
m_tcArea.y,
m_tcArea.width - m_widthCustomPaint,
void wxComboCtrlBase::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
{
OnThemeChange();
- // indentation may also have changed
- if ( !(m_iFlags & wxCC_IFLAG_INDENT_SET) )
- m_absIndent = GetNativeTextIndent();
+ // left margin may also have changed
+ if ( !(m_iFlags & wxCC_IFLAG_LEFT_MARGIN_SET) )
+ m_marginLeft = GetNativeTextIndent();
RecalcAndRefresh();
}
RecalcAndRefresh();
}
+bool wxComboCtrlBase::DoSetMargins(const wxPoint& margins)
+{
+ // For general sanity's sake, we ignore top margin. Instead
+ // we will always try to center the text vertically.
+ bool res = true;
+
+ if ( margins.x != -1 )
+ {
+ m_marginLeft = margins.x;
+ m_iFlags |= wxCC_IFLAG_LEFT_MARGIN_SET;
+ }
+ else
+ {
+ m_marginLeft = GetNativeTextIndent();
+ m_iFlags &= ~(wxCC_IFLAG_LEFT_MARGIN_SET);
+ }
+
+ if ( margins.y != -1 )
+ {
+ res = false;
+ }
+
+ RecalcAndRefresh();
+
+ return res;
+}
+
+wxPoint wxComboCtrlBase::DoGetMargins() const
+{
+ return wxPoint(m_marginLeft, -1);
+}
+
+#if WXWIN_COMPATIBILITY_2_6
void wxComboCtrlBase::SetTextIndent( int indent )
{
if ( indent < 0 )
{
- m_absIndent = GetNativeTextIndent();
- m_iFlags &= ~(wxCC_IFLAG_INDENT_SET);
+ m_marginLeft = GetNativeTextIndent();
+ m_iFlags &= ~(wxCC_IFLAG_LEFT_MARGIN_SET);
}
else
{
- m_absIndent = indent;
- m_iFlags |= wxCC_IFLAG_INDENT_SET;
+ m_marginLeft = indent;
+ m_iFlags |= wxCC_IFLAG_LEFT_MARGIN_SET;
}
RecalcAndRefresh();
}
+wxCoord wxComboCtrlBase::GetTextIndent() const;
+{
+ return m_marginLeft;
+}
+#endif
+
wxCoord wxComboCtrlBase::GetNativeTextIndent() const
{
return DEFAULT_TEXT_INDENT;
return m_hintData ? m_hintData->GetHintString() : wxString();
}
+// ----------------------------------------------------------------------------
+// margins support
+// ----------------------------------------------------------------------------
+
+bool wxTextEntryBase::DoSetMargins(const wxPoint& WXUNUSED(pt))
+{
+ return false;
+}
+
+wxPoint wxTextEntryBase::DoGetMargins() const
+{
+ return wxPoint(-1, -1);
+}
+
#endif // wxUSE_TEXTCTRL || wxUSE_COMBOBOX
#if defined(__WXUNIVERSAL__)
-#define TEXTCTRLXADJUST 0 // position adjustment for wxTextCtrl, with zero indent
+// position adjustment for wxTextCtrl, to achieve zero left margin
+// meaningless if LEFT_MARGIN_CAN_BE_SET set to 1 in combocmn.cpp
+#define TEXTCTRLXADJUST 0
+
#define TEXTCTRLYADJUST 0
#define TEXTXADJUST 0 // how much is read-only text's x adjusted
#define DEFAULT_DROPBUTTON_WIDTH 19
#elif defined(__WXMSW__)
-#define TEXTCTRLXADJUST 2 // position adjustment for wxTextCtrl, with zero indent
+// position adjustment for wxTextCtrl, to achieve zero left margin
+// meaningless if LEFT_MARGIN_CAN_BE_SET set to 1 in combocmn.cpp
+#define TEXTCTRLXADJUST 2
+
#define TEXTCTRLYADJUST 3
#define TEXTXADJUST 0 // how much is read-only text's x adjusted
#define DEFAULT_DROPBUTTON_WIDTH 17
#elif defined(__WXGTK__)
-#define TEXTCTRLXADJUST -1 // position adjustment for wxTextCtrl, with zero indent
+// position adjustment for wxTextCtrl, to achieve zero left margin
+// meaningless if LEFT_MARGIN_CAN_BE_SET set to 1 in combocmn.cpp
+#define TEXTCTRLXADJUST -1
+
#define TEXTCTRLYADJUST 0
#define TEXTXADJUST 1 // how much is read-only text's x adjusted
#define DEFAULT_DROPBUTTON_WIDTH 23
#elif defined(__WXMAC__)
-#define TEXTCTRLXADJUST 0 // position adjustment for wxTextCtrl, with zero indent
+// position adjustment for wxTextCtrl, to achieve zero left margin
+// meaningless if LEFT_MARGIN_CAN_BE_SET set to 1 in combocmn.cpp
+#define TEXTCTRLXADJUST 0
+
#define TEXTCTRLYADJUST 0
#define TEXTXADJUST 0 // how much is read-only text's x adjusted
#define DEFAULT_DROPBUTTON_WIDTH 22
#else
-#define TEXTCTRLXADJUST 0 // position adjustment for wxTextCtrl, with zero indent
+// position adjustment for wxTextCtrl, to achieve zero left margin
+// meaningless if LEFT_MARGIN_CAN_BE_SET set to 1 in combocmn.cpp
+#define TEXTCTRLXADJUST 0
+
#define TEXTCTRLYADJUST 0
#define TEXTXADJUST 0 // how much is read-only text's x adjusted
#define DEFAULT_DROPBUTTON_WIDTH 19
if ( flags & wxODCB_PAINTING_CONTROL )
{
dc.DrawText( GetValue(),
- rect.x + GetTextIndent(),
+ rect.x + GetMargins().x,
(rect.height-dc.GetCharHeight())/2 + rect.y );
}
else
return GTK_EDITABLE(m_text);
}
+GtkEntry *wxTextCtrl::GetEntry() const
+{
+ return GTK_ENTRY(m_text);
+}
+
// ----------------------------------------------------------------------------
// flags handling
// ----------------------------------------------------------------------------
win->HandleWindowEvent(event);
}
+// ----------------------------------------------------------------------------
+// margins support
+// ----------------------------------------------------------------------------
+
+bool wxTextEntry::DoSetMargins(const wxPoint& margins)
+{
+#if GTK_CHECK_VERSION(2,10,0)
+ GtkEntry* entry = GetEntry();
+
+ if ( !entry )
+ return false;
+
+ const GtkBorder* oldBorder = gtk_entry_get_inner_border(entry);
+ GtkBorder* newBorder;
+
+ if ( oldBorder )
+ {
+ newBorder = gtk_border_copy(oldBorder);
+ }
+ else
+ {
+ #if GTK_CHECK_VERSION(2,14,0)
+ newBorder = gtk_border_new();
+ #else
+ newBorder = new GtkBorder;
+ #endif
+ // Use some reasonable defaults for initial margins
+ newBorder->left = 2;
+ newBorder->right = 2;
+
+ // These numbers seem to let the text remain vertically centered
+ // in common use scenarios when margins.y == -1.
+ newBorder->top = 3;
+ newBorder->bottom = 3;
+ }
+
+ if ( margins.x != -1 )
+ newBorder->left = (gint) margins.x;
+
+ if ( margins.y != -1 )
+ newBorder->top = (gint) margins.y;
+
+ gtk_entry_set_inner_border(entry, newBorder);
+
+ return true;
+#else
+ wxUnusedVar(margins);
+ return false;
+#endif
+}
+
+wxPoint wxTextEntry::DoGetMargins() const
+{
+#if GTK_CHECK_VERSION(2,10,0)
+ GtkEntry* entry = GetEntry();
+
+ if ( !entry )
+ return wxPoint(-1, -1);
+
+ const GtkBorder* border = gtk_entry_get_inner_border(entry);
+
+ if ( !border )
+ return wxPoint(-1, -1);
+
+ return wxPoint((wxCoord) border->left, (wxCoord) border->top);
+#else
+ return wxPoint(-1, -1);
+#endif
+}
+
#endif // wxUSE_TEXTCTRL || wxUSE_COMBOBOX
#define NATIVE_TEXT_INDENT_XP 4
#define NATIVE_TEXT_INDENT_CLASSIC 2
-#define TEXTCTRLXADJUST_XP 1
#define TEXTCTRLYADJUST_XP 3
-#define TEXTCTRLXADJUST_CLASSIC 1
#define TEXTCTRLYADJUST_CLASSIC 3
#define COMBOBOX_ANIMATION_RESOLUTION 10
//
// Recalculates button and textctrl areas
- int textCtrlXAdjust;
int textCtrlYAdjust;
#if wxUSE_UXTHEME
if ( wxUxThemeEngine::GetIfActive() )
{
- textCtrlXAdjust = TEXTCTRLXADJUST_XP;
textCtrlYAdjust = TEXTCTRLYADJUST_XP;
}
else
#endif
{
- textCtrlXAdjust = TEXTCTRLXADJUST_CLASSIC;
textCtrlYAdjust = TEXTCTRLYADJUST_CLASSIC;
}
CalculateAreas(btnWidth);
// Position textctrl using standard routine
- PositionTextCtrl(textCtrlXAdjust,textCtrlYAdjust);
+ PositionTextCtrl(0, textCtrlYAdjust);
}
// Draws non-XP GUI dotted line around the focus area
#endif // wxUSE_UXTHEME
+// ----------------------------------------------------------------------------
+// margins support
+// ----------------------------------------------------------------------------
+
+bool wxTextEntry::DoSetMargins(const wxPoint& margins)
+{
+#if !defined(__WXWINCE__)
+ bool res = true;
+
+ if ( margins.x != -1 )
+ {
+ // left margin
+ ::SendMessage(GetEditHwnd(), EM_SETMARGINS,
+ EC_LEFTMARGIN, MAKELONG(margins.x, 0));
+ }
+
+ if ( margins.y != -1 )
+ {
+ res = false;
+ }
+
+ return res;
+#else
+ return false;
+#endif
+}
+
+wxPoint wxTextEntry::DoGetMargins() const
+{
+#if !defined(__WXWINCE__)
+ LRESULT lResult = ::SendMessage(GetEditHwnd(), EM_GETMARGINS,
+ 0, 0);
+ int left = LOWORD(lResult);
+ int top = -1;
+ return wxPoint(left, top);
+#else
+ return wxPoint(-1, -1);
+#endif
+}
+
#endif // wxUSE_TEXTCTRL || wxUSE_COMBOBOX
#include "wx/odcombo.h"
-#ifdef __WXMSW__
- #include "wx/msw/private.h"
-#endif
-
// -----------------------------------------------------------------------
#if defined(__WXMSW__)
#define wxPG_CHOICEYADJUST 0
#endif
-#define ODCB_CUST_PAINT_MARGIN 6 // Number added to image width for SetCustomPaintWidth
+// Number added to image width for SetCustomPaintWidth
+#define ODCB_CUST_PAINT_MARGIN 9
// Milliseconds to wait for two mouse-ups after focus inorder
// to trigger a double-click.
//
// Fix indentation, just in case (change in font boldness is one good
// reason).
-#if defined(__WXMSW__) && !defined(__WXWINCE__)
- ::SendMessage(GetHwndOf(tc),
- EM_SETMARGINS,
- EC_LEFTMARGIN | EC_RIGHTMARGIN,
- MAKELONG(0, 0));
-#endif
+ tc->SetMargins(0);
}
// Provided so that, for example, ComboBox editor can use the same code
return rect.width;
}
- virtual void PositionTextCtrl( int WXUNUSED(textCtrlXAdjust),
+ virtual void PositionTextCtrl( int textCtrlXAdjust,
int WXUNUSED(textCtrlYAdjust) )
{
wxPropertyGrid* pg = GetGrid();
+ #ifdef wxPG_TEXTCTRLXADJUST
+ textCtrlXAdjust = wxPG_TEXTCTRLXADJUST -
+ (wxPG_XBEFOREWIDGET+wxPG_CONTROL_MARGIN+1) - 1,
+ #endif
wxOwnerDrawnComboBox::PositionTextCtrl(
- wxPG_TEXTCTRLXADJUST -
- (wxPG_XBEFOREWIDGET+wxPG_CONTROL_MARGIN+1) - 1,
+ textCtrlXAdjust,
pg->GetSpacingY() + 2
);
}
odcbFlags);
cb->SetButtonPosition(si.y,0,wxRIGHT);
- cb->SetTextIndent(wxPG_XBEFORETEXT-1);
+ cb->SetMargins(wxPG_XBEFORETEXT-1);
wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, property->GetCommonValue() );
// Fixes position of wxTextCtrl-like control (wxSpinCtrl usually
// fits into that category as well).
void wxPropertyGrid::FixPosForTextCtrl( wxWindow* ctrl,
- unsigned int forColumn,
+ unsigned int WXUNUSED(forColumn),
const wxPoint& offset )
{
// Center the control vertically
finalPos.y += y_adj;
finalPos.height -= (y_adj+sz_dec);
- int textCtrlXAdjust = wxPG_TEXTCTRLXADJUST;
+#ifndef wxPG_TEXTCTRLXADJUST
+ int textCtrlXAdjust = wxPG_XBEFORETEXT - 1;
- if ( forColumn != 1 )
- textCtrlXAdjust -= 3; // magic number!
+ wxTextCtrl* tc = static_cast<wxTextCtrl*>(ctrl);
+ tc->SetMargins(0);
+#else
+ int textCtrlXAdjust = wxPG_TEXTCTRLXADJUST;
+#endif
finalPos.x += textCtrlXAdjust;
finalPos.width -= textCtrlXAdjust;
{
tc->SetBackgroundColour(m_colSelBack);
tc->SetForegroundColour(m_colSelFore);
-
- // Normalize margins
- #ifdef __WXMSW__
- ::SendMessage(GetHwndOf(tc), EM_SETMARGINS,
- EC_LEFTMARGIN | EC_RIGHTMARGIN,
- MAKELONG(3, 0));
- #endif
}
#ifdef __WXMSW__
#include "wx/timer.h"
#include "wx/dcbuffer.h"
-#ifdef __WXMSW__
- #include "wx/msw/private.h"
-#endif
-
// Two pics for the expand / collapse buttons.
// Files are not supplied with this project (since it is
// recommended to use either custom or native rendering).
if ( (p->m_flags & wxPG_PROP_MODIFIED) && (m_windowStyle & wxPG_BOLD_MODIFIED) )
SetCurControlBoldFont();
- //
- // Fix TextCtrl indentation
- #if defined(__WXMSW__) && !defined(__WXWINCE__)
- wxTextCtrl* tc = NULL;
- if ( primaryCtrl->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
- tc = ((wxOwnerDrawnComboBox*)primaryCtrl)->GetTextCtrl();
- else
- tc = wxDynamicCast(primaryCtrl, wxTextCtrl);
- if ( tc )
- ::SendMessage(GetHwndOf(tc), EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(0, 0));
- #endif
-
// Store x relative to splitter (we'll need it).
m_ctrlXAdjust = m_wndEditor->GetPosition().x - splitterX;
projects / wxWidgets.git / commitdiff
