AutoPtr<ArrayOf<Int32> > RelativeLayoutLayoutParams::GetRules(
/* [in] */ Int32 layoutDirection)
{
if (HasRelativeRules() &&
(mRulesChanged || layoutDirection != GetLayoutDirection())) {
ResolveRules(layoutDirection);
if (layoutDirection != GetLayoutDirection()) {
SetLayoutDirection(layoutDirection);
}
}
return mRules;
}
void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this);
#ifdef __WXGTK20__
// Draw grip first
if ( ShowsSizeGrip() )
{
const wxRect& rc = GetSizeGripRect();
#ifdef __WXGTK3__
GtkWidget* toplevel = gtk_widget_get_toplevel(m_widget);
GdkRectangle rect;
if (toplevel && (!gtk_window_get_resize_grip_area(GTK_WINDOW(toplevel), &rect) ||
rect.width == 0 || rect.height == 0))
{
GtkStyleContext* sc = gtk_widget_get_style_context(toplevel);
gtk_style_context_save(sc);
gtk_style_context_add_class(sc, GTK_STYLE_CLASS_GRIP);
GtkJunctionSides sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
if (GetLayoutDirection() == wxLayout_RightToLeft)
sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
gtk_style_context_set_junction_sides(sc, sides);
gtk_render_handle(sc,
static_cast<cairo_t*>(dc.GetImpl()->GetCairoContext()),
rc.x, rc.y, rc.width, rc.height);
gtk_style_context_restore(sc);
}
#else
GdkWindowEdge edge =
GetLayoutDirection() == wxLayout_RightToLeft ? GDK_WINDOW_EDGE_SOUTH_WEST :
GDK_WINDOW_EDGE_SOUTH_EAST;
gtk_paint_resize_grip(gtk_widget_get_style(m_widget),
GTKGetDrawingWindow(),
gtk_widget_get_state(m_widget),
NULL,
m_widget,
"statusbar",
edge,
rc.x, rc.y, rc.width, rc.height );
#endif
}
#endif // __WXGTK20__
if (GetFont().IsOk())
dc.SetFont(GetFont());
// compute char height only once for all panes:
int textHeight = dc.GetCharHeight();
dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
for (size_t i = 0; i < m_panes.GetCount(); i ++)
DrawField(dc, i, textHeight);
}
void wxStatusBarEx::OnSize(wxSizeEvent& event)
{
#ifdef __WXMSW__
const int count = GetFieldsCount();
if (count && m_columnWidths && m_columnWidths[count - 1] > 0)
{
// No sizegrip on maximized windows
bool isMaximized = m_pParent->IsMaximized();
if (isMaximized != m_parentWasMaximized)
{
m_parentWasMaximized = isMaximized;
if (isMaximized)
m_columnWidths[count - 1] -= 6;
else
m_columnWidths[count - 1] += 6;
wxStatusBar::SetStatusWidths(count, m_columnWidths);
Refresh();
}
}
#endif
for (std::list<struct t_statbar_child>::iterator iter = m_children.begin(); iter != m_children.end(); iter++)
PositionChild(*iter);
#ifdef __WXMSW__
if (GetLayoutDirection() != wxLayout_RightToLeft)
Update();
#endif
}
void CQueueViewBase::OnChar(wxKeyEvent& event)
{
const int code = event.GetKeyCode();
if (code != WXK_LEFT && code != WXK_RIGHT)
{
event.Skip();
return;
}
bool forward;
if (GetLayoutDirection() != wxLayout_RightToLeft)
forward = code == WXK_RIGHT;
else
forward = code == WXK_LEFT;
int selection = m_pQueue->GetSelection();
if (selection > 0 && !forward)
selection--;
else if (selection < (int)m_pQueue->GetPageCount() - 1 && forward)
selection++;
else
return;
m_pQueue->SetSelection(selection);
}
void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this);
#ifdef __WXGTK20__
// Draw grip first
if ( ShowsSizeGrip() )
{
const wxRect& rc = GetSizeGripRect();
GdkWindowEdge edge =
GetLayoutDirection() == wxLayout_RightToLeft ? GDK_WINDOW_EDGE_SOUTH_WEST :
GDK_WINDOW_EDGE_SOUTH_EAST;
gtk_paint_resize_grip(gtk_widget_get_style(m_widget),
GTKGetDrawingWindow(),
gtk_widget_get_state(m_widget),
NULL,
m_widget,
"statusbar",
edge,
rc.x, rc.y, rc.width, rc.height );
}
#endif // __WXGTK20__
if (GetFont().IsOk())
dc.SetFont(GetFont());
// compute char height only once for all panes:
int textHeight = dc.GetCharHeight();
dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
for (size_t i = 0; i < m_panes.GetCount(); i ++)
DrawField(dc, i, textHeight);
}
wxRect wxStatusBarGeneric::GetSizeGripRect() const
{
int width, height;
wxWindow::DoGetClientSize(&width, &height);
if (GetLayoutDirection() == wxLayout_RightToLeft)
return wxRect(2, 2, height-2, height-4);
else
return wxRect(width-height-2, 2, height-2, height-4);
}
void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this);
#ifdef __WXGTK20__
// Draw grip first
if ( ShowsSizeGrip() )
{
const wxRect& rc = GetSizeGripRect();
#ifdef __WXGTK3__
GtkWidget* toplevel = gtk_widget_get_toplevel(m_widget);
GdkRectangle rect;
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
if (toplevel && (!gtk_window_get_resize_grip_area(GTK_WINDOW(toplevel), &rect) ||
rect.width == 0 || rect.height == 0))
wxGCC_WARNING_RESTORE()
{
GtkStyleContext* sc = gtk_widget_get_style_context(toplevel);
gtk_style_context_save(sc);
gtk_style_context_add_class(sc, GTK_STYLE_CLASS_GRIP);
GtkJunctionSides sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
if (GetLayoutDirection() == wxLayout_RightToLeft)
sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
gtk_style_context_set_junction_sides(sc, sides);
gtk_render_handle(sc,
static_cast<cairo_t*>(dc.GetImpl()->GetCairoContext()),
rc.x, rc.y, rc.width, rc.height);
gtk_style_context_restore(sc);
}
#else
GdkWindowEdge edge =
GetLayoutDirection() == wxLayout_RightToLeft ? GDK_WINDOW_EDGE_SOUTH_WEST :
GDK_WINDOW_EDGE_SOUTH_EAST;
gtk_paint_resize_grip(gtk_widget_get_style(m_widget),
GTKGetDrawingWindow(),
gtk_widget_get_state(m_widget),
NULL,
m_widget,
"statusbar",
edge,
rc.x, rc.y, rc.width, rc.height );
#endif
}
ECode ShortcutAndWidgetContainer::IsLayoutRtl(
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
Int32 direction;
GetLayoutDirection(&direction);
*result = direction == LAYOUT_DIRECTION_RTL;
return NOERROR;
}
void CWidgetsStatusBar::OnSize(wxSizeEvent& event)
{
wxStatusBarEx::OnSize(event);
for (int i = 0; i < GetFieldsCount(); i++)
PositionChildren(i);
#ifdef __WXMSW__
if (GetLayoutDirection() != wxLayout_RightToLeft)
Update();
#endif
}
void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this);
dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
#ifdef __WXGTK20__
// Draw grip first
if (HasFlag( wxST_SIZEGRIP ))
{
int width, height;
GetClientSize(&width, &height);
if (GetLayoutDirection() == wxLayout_RightToLeft)
{
gtk_paint_resize_grip( m_widget->style,
GTK_PIZZA(m_wxwindow)->bin_window,
(GtkStateType) GTK_WIDGET_STATE (m_widget),
NULL,
m_widget,
"statusbar",
GDK_WINDOW_EDGE_SOUTH_WEST,
2, 2, height-2, height-4 );
}
else
{
gtk_paint_resize_grip( m_widget->style,
GTK_PIZZA(m_wxwindow)->bin_window,
(GtkStateType) GTK_WIDGET_STATE (m_widget),
NULL,
m_widget,
"statusbar",
GDK_WINDOW_EDGE_SOUTH_EAST,
width-height-2, 2, height-2, height-4 );
}
}
#endif
if (GetFont().Ok())
dc.SetFont(GetFont());
dc.SetBackgroundMode(wxTRANSPARENT);
#ifdef __WXPM__
wxColour vColor;
vColor = wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR);
::WinFillRect(dc.m_hPS, &dc.m_vRclPaint, vColor.GetPixel());
#endif
for (int i = 0; i < m_nFields; i ++)
DrawField(dc, i);
}
wxStatusBarEx::wxStatusBarEx(wxTopLevelWindow* pParent)
{
m_pParent = pParent;
m_columnWidths = 0;
Create(pParent, wxID_ANY);
#ifdef __WXMSW__
m_parentWasMaximized = false;
if (GetLayoutDirection() != wxLayout_RightToLeft)
SetDoubleBuffered(true);
#endif
}
void wxMenuBar::GtkAppend(wxMenu* menu, const wxString& title, int pos)
{
menu->SetLayoutDirection(GetLayoutDirection());
#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
// if the menu has only one item, append it directly to the top level menu
// instead of inserting a useless submenu
if ( menu->GetMenuItemCount() == 1 )
{
wxMenuItem * const item = menu->FindItemByPosition(0);
// remove both mnemonics and accelerator: neither is useful under Maemo
const wxString str(wxStripMenuCodes(item->GetItemLabel()));
if ( item->IsSubMenu() )
{
GtkAppend(item->GetSubMenu(), str, pos);
return;
}
menu->m_owner = gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str ) );
g_signal_connect(menu->m_owner, "activate",
G_CALLBACK(menuitem_activate), item);
item->SetMenuItem(menu->m_owner);
}
else
#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
{
const wxString str(wxConvertMnemonicsToGTK(title));
// This doesn't have much effect right now.
menu->SetTitle( str );
// The "m_owner" is the "menu item"
menu->m_owner = gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str ) );
gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
}
g_object_ref(menu->m_owner);
gtk_widget_show( menu->m_owner );
if (pos == -1)
gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar), menu->m_owner );
else
gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar), menu->m_owner, pos );
if ( m_menuBarFrame )
AttachToFrame( menu, m_menuBarFrame );
}
void CUpdateDialog::Wrap()
{
wxPanel* parentPanel = XRCCTRL(*this, "ID_CONTENT", wxPanel);
wxSize canvas;
canvas.x = GetSize().x - parentPanel->GetSize().x;
canvas.y = GetSize().y - parentPanel->GetSize().y;
// Wrap pages nicely
std::vector<wxWindow*> pages;
for (auto const& panel : panels_) {
pages.push_back(panel);
}
wxGetApp().GetWrapEngine()->WrapRecursive(pages, 1.33, "Update", canvas);
// Keep track of maximum page size
wxSize size = GetSizer()->GetMinSize();
for (auto const& panel : panels_) {
size.IncTo(panel->GetSizer()->GetMinSize());
}
wxSize panelSize = size;
#ifdef __WXGTK__
panelSize.x += 1;
#endif
parentPanel->SetInitialSize(panelSize);
// Adjust pages sizes according to maximum size
for (auto const& panel : panels_) {
panel->GetSizer()->SetMinSize(size);
panel->GetSizer()->Fit(panel);
panel->GetSizer()->SetSizeHints(panel);
if (GetLayoutDirection() == wxLayout_RightToLeft) {
panel->Move(wxPoint(0, 0));
}
}
GetSizer()->Fit(this);
GetSizer()->SetSizeHints(this);
#ifdef __WXGTK__
// Pre-show dialog under GTK, else panels won't get initialized properly
Show();
#endif
for (auto const& panel : panels_) {
panel->Hide();
}
panels_[0]->Show();
}
void wxStatusBarGeneric::OnLeftDown(wxMouseEvent& event)
{
int width, height;
GetClientSize(&width, &height);
GtkWidget* ancestor = gtk_widget_get_toplevel(m_widget);
#ifdef __WXGTK3__
GdkRectangle rect;
if (ancestor && gtk_window_get_resize_grip_area(GTK_WINDOW(ancestor), &rect) &&
rect.width && rect.height)
{
ancestor = NULL;
}
#endif
if (ancestor && ShowsSizeGrip() && event.GetX() > width - height)
{
GdkWindow *source = GTKGetDrawingWindow();
int org_x = 0;
int org_y = 0;
gdk_window_get_origin( source, &org_x, &org_y );
if (GetLayoutDirection() == wxLayout_RightToLeft)
{
gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
GDK_WINDOW_EDGE_SOUTH_WEST,
1,
org_x - event.GetX() + GetSize().x ,
org_y + event.GetY(),
0);
}
else
{
gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
GDK_WINDOW_EDGE_SOUTH_EAST,
1,
org_x + event.GetX(),
org_y + event.GetY(),
0);
}
}
else
{
event.Skip( true );
}
}
void wxStatusBarGeneric::OnLeftDown(wxMouseEvent& event)
{
#ifdef __WXGTK20__
int width, height;
GetClientSize(&width, &height);
if (HasFlag( wxST_SIZEGRIP ) && (event.GetX() > width-height))
{
GtkWidget *ancestor = gtk_widget_get_toplevel( m_widget );
if (!GTK_IS_WINDOW (ancestor))
return;
GdkWindow *source = GTK_PIZZA(m_wxwindow)->bin_window;
int org_x = 0;
int org_y = 0;
gdk_window_get_origin( source, &org_x, &org_y );
if (GetLayoutDirection() == wxLayout_RightToLeft)
{
gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
GDK_WINDOW_EDGE_SOUTH_WEST,
1,
org_x - event.GetX() + GetSize().x ,
org_y + event.GetY(),
0);
}
else
{
gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
GDK_WINDOW_EDGE_SOUTH_EAST,
1,
org_x + event.GetX(),
org_y + event.GetY(),
0);
}
}
else
{
event.Skip( true );
}
#else
event.Skip( true );
#endif
}
ECode RelativeLayoutLayoutParams::ResolveLayoutDirection(
/* [in] */ Int32 layoutDirection)
{
Boolean isLayoutRtl = IsLayoutRtl();
if (isLayoutRtl) {
if (mStart != IViewGroupMarginLayoutParams::DEFAULT_RELATIVE) mRight = mStart;
if (mEnd != IViewGroupMarginLayoutParams::DEFAULT_RELATIVE) mLeft = mEnd;
} else {
if (mStart != IViewGroupMarginLayoutParams::DEFAULT_RELATIVE) mLeft = mStart;
if (mEnd != IViewGroupMarginLayoutParams::DEFAULT_RELATIVE) mRight = mEnd;
}
if (HasRelativeRules() && layoutDirection != GetLayoutDirection()) {
ResolveRules(layoutDirection);
}
// This will set the layout direction
return ViewGroupMarginLayoutParams::ResolveLayoutDirection(layoutDirection);
}
void wxSpinCtrl::DoMoveWindow(int x, int y, int width, int height)
{
int widthBtn = wxSpinButton::DoGetBestSize().x;
int widthText = width - widthBtn - MARGIN_BETWEEN;
if ( widthText < 0 )
{
// This can happen during the initial window layout when it's total
// size is too small to accommodate all the controls and usually is not
// a problem because the window will be relaid out with enough space
// later. Of course, if it isn't and this is our final size, then we
// have a real problem but as we don't know if this is going to be the
// case or not, just hope for the best -- we used to give a debug
// warning here and this was annoying as it could result in dozens of
// perfectly harmless warnings.
widthText = 0;
}
// Because both subcontrols are positioned relatively
// to the parent which can have different layout direction
// then our control, we need to mirror their positions manually.
if ( GetParent()->GetLayoutDirection() == GetLayoutDirection() )
{
// Logical positions: x(Text) < x(Button)
// 1) The buddy window
DoMoveSibling(m_hwndBuddy, x, y, widthText, height);
// 2) The button window
if ( widthText > 0 )
x += widthText + MARGIN_BETWEEN;
wxSpinButton::DoMoveWindow(x, y, widthBtn, height);
}
else
{
// Logical positions: x(Button) < x(Text)
// 1) The button window
wxSpinButton::DoMoveWindow(x, y, widthBtn, height);
// 2) The buddy window
x += widthBtn + MARGIN_BETWEEN;
DoMoveSibling(m_hwndBuddy, x, y, widthText, height);
}
}
CFilelistStatusBar::CFilelistStatusBar(wxWindow* pParent)
: wxStatusBar(pParent, wxID_ANY, 0)
{
m_count_files = 0;
m_count_dirs = 0;
m_total_size = 0;
m_unknown_size = false;
m_hidden = false;
m_count_selected_files = 0;
m_count_selected_dirs = 0;
m_total_selected_size = 0;
m_unknown_selected_size = 0;
m_updateTimer.SetOwner(this);
UpdateText();
#ifdef __WXMSW__
if (GetLayoutDirection() != wxLayout_RightToLeft)
SetDoubleBuffered(true);
#endif
}
bool wxStaticText::Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxStaticText creation failed") );
return false;
}
m_widget = gtk_label_new(NULL);
g_object_ref(m_widget);
GtkJustification justify;
if ( style & wxALIGN_CENTER_HORIZONTAL )
{
#ifndef __WXGTK3__
// This looks like a bug in GTK+ and seems to be fixed in GTK+3, but
// using non-default justification with default ellipsize mode doesn't
// work: the justification is just ignored. In practice, alignment is
// more important, so turn on ellipsize mode even if it was not
// specified to make it work if necessary.
if ( !(style & wxST_ELLIPSIZE_MASK) )
style |= wxST_ELLIPSIZE_MIDDLE;
#endif // GTK+ 2
justify = GTK_JUSTIFY_CENTER;
}
else if ( style & wxALIGN_RIGHT )
{
#ifndef __WXGTK3__
// As above, we need to use a non-default ellipsize mode for the
// alignment to have any effect.
if ( !(style & wxST_ELLIPSIZE_MASK) )
style |= wxST_ELLIPSIZE_START;
#endif // GTK+ 2
justify = GTK_JUSTIFY_RIGHT;
}
else // must be wxALIGN_LEFT which is 0
{
// No need to play games with wxST_ELLIPSIZE_XXX.
justify = GTK_JUSTIFY_LEFT;
}
if (GetLayoutDirection() == wxLayout_RightToLeft)
{
if (justify == GTK_JUSTIFY_RIGHT)
justify = GTK_JUSTIFY_LEFT;
else if (justify == GTK_JUSTIFY_LEFT)
justify = GTK_JUSTIFY_RIGHT;
}
gtk_label_set_justify(GTK_LABEL(m_widget), justify);
// set ellipsize mode
PangoEllipsizeMode ellipsizeMode = PANGO_ELLIPSIZE_NONE;
if ( style & wxST_ELLIPSIZE_START )
ellipsizeMode = PANGO_ELLIPSIZE_START;
else if ( style & wxST_ELLIPSIZE_MIDDLE )
ellipsizeMode = PANGO_ELLIPSIZE_MIDDLE;
else if ( style & wxST_ELLIPSIZE_END )
ellipsizeMode = PANGO_ELLIPSIZE_END;
gtk_label_set_ellipsize( GTK_LABEL(m_widget), ellipsizeMode );
// GTK_JUSTIFY_LEFT is 0, RIGHT 1 and CENTER 2
static const float labelAlignments[] = { 0.0, 1.0, 0.5 };
gtk_misc_set_alignment(GTK_MISC(m_widget), labelAlignments[justify], 0.0);
gtk_label_set_line_wrap( GTK_LABEL(m_widget), TRUE );
SetLabel(label);
m_parent->DoAddChild( this );
PostCreation(size);
#ifndef __WXGTK3__
// GtkLabel does its layout based on its size-request, rather than its
// actual size. The size-request may not always get set, specifically if
// the initial size is fully specified. So make sure it's set here.
gtk_widget_set_size_request(m_widget, m_width, m_height);
#endif
return true;
}
bool wxStaticText::Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name )
{
m_needParent = TRUE;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxStaticText creation failed") );
return FALSE;
}
const wxString labelGTK = GTKConvertMnemonics(label);
m_label = label;
m_widget = gtk_label_new_with_mnemonic(wxGTK_CONV(labelGTK));
GtkJustification justify;
if ( style & wxALIGN_CENTER )
justify = GTK_JUSTIFY_CENTER;
else if ( style & wxALIGN_RIGHT )
justify = GTK_JUSTIFY_RIGHT;
else // wxALIGN_LEFT is 0
justify = GTK_JUSTIFY_LEFT;
if (GetLayoutDirection() == wxLayout_RightToLeft)
{
if (justify == GTK_JUSTIFY_RIGHT)
justify = GTK_JUSTIFY_LEFT;
if (justify == GTK_JUSTIFY_LEFT)
justify = GTK_JUSTIFY_RIGHT;
}
gtk_label_set_justify(GTK_LABEL(m_widget), justify);
// GTK_JUSTIFY_LEFT is 0, RIGHT 1 and CENTER 2
static const float labelAlignments[] = { 0.0, 1.0, 0.5 };
gtk_misc_set_alignment(GTK_MISC(m_widget), labelAlignments[justify], 0.0);
gtk_label_set_line_wrap( GTK_LABEL(m_widget), TRUE );
m_parent->DoAddChild( this );
PostCreation(size);
// the bug below only happens with GTK 2
if ( justify != GTK_JUSTIFY_LEFT )
{
// if we let GTK call wxgtk_window_size_request_callback the label
// always shrinks to its minimal size for some reason and so no
// alignment except the default left doesn't work (in fact it does,
// but you don't see it)
g_signal_handlers_disconnect_by_func (m_widget,
(gpointer) wxgtk_window_size_request_callback,
this);
}
return TRUE;
}
bool wxStaticText::Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxStaticText creation failed") );
return false;
}
m_widget = gtk_label_new(NULL);
g_object_ref(m_widget);
GtkJustification justify;
if ( style & wxALIGN_CENTER_HORIZONTAL )
justify = GTK_JUSTIFY_CENTER;
else if ( style & wxALIGN_RIGHT )
justify = GTK_JUSTIFY_RIGHT;
else
justify = GTK_JUSTIFY_LEFT;
if (GetLayoutDirection() == wxLayout_RightToLeft)
{
if (justify == GTK_JUSTIFY_RIGHT)
justify = GTK_JUSTIFY_LEFT;
else if (justify == GTK_JUSTIFY_LEFT)
justify = GTK_JUSTIFY_RIGHT;
}
gtk_label_set_justify(GTK_LABEL(m_widget), justify);
#ifdef __WXGTK26__
if (!gtk_check_version(2,6,0))
{
// set ellipsize mode
PangoEllipsizeMode ellipsizeMode = PANGO_ELLIPSIZE_NONE;
if ( style & wxST_ELLIPSIZE_START )
ellipsizeMode = PANGO_ELLIPSIZE_START;
else if ( style & wxST_ELLIPSIZE_MIDDLE )
ellipsizeMode = PANGO_ELLIPSIZE_MIDDLE;
else if ( style & wxST_ELLIPSIZE_END )
ellipsizeMode = PANGO_ELLIPSIZE_END;
gtk_label_set_ellipsize( GTK_LABEL(m_widget), ellipsizeMode );
}
#endif // __WXGTK26__
// GTK_JUSTIFY_LEFT is 0, RIGHT 1 and CENTER 2
static const float labelAlignments[] = { 0.0, 1.0, 0.5 };
gtk_misc_set_alignment(GTK_MISC(m_widget), labelAlignments[justify], 0.0);
gtk_label_set_line_wrap( GTK_LABEL(m_widget), TRUE );
SetLabel(label);
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
void wxStatusBarGeneric::DrawFieldText(wxDC& dc, const wxRect& rect, int i, int textHeight)
{
wxString text(GetStatusText(i));
if (text.empty())
return; // optimization
int xpos = rect.x + wxFIELD_TEXT_MARGIN,
maxWidth = rect.width - 2*wxFIELD_TEXT_MARGIN,
ypos = (int) (((rect.height - textHeight) / 2) + rect.y + 0.5);
if (ShowsSizeGrip())
{
// don't write text over the size grip:
// NOTE: overloading DoGetClientSize() and GetClientAreaOrigin() wouldn't
// work because the adjustment needs to be done only when drawing
// the field text and not also when drawing the background, the
// size grip itself, etc
if ((GetLayoutDirection() == wxLayout_RightToLeft && i == 0) ||
(GetLayoutDirection() != wxLayout_RightToLeft &&
i == (int)m_panes.GetCount()-1))
{
const wxRect& gripRc = GetSizeGripRect();
// NOTE: we don't need any special treatment wrt to the layout direction
// since DrawText() will automatically adjust the origin of the
// text accordingly to the layout in use
maxWidth -= gripRc.width;
}
}
// eventually ellipsize the text so that it fits the field width
wxEllipsizeMode ellmode = wxELLIPSIZE_NONE;
if (HasFlag(wxSTB_ELLIPSIZE_START)) ellmode = wxELLIPSIZE_START;
else if (HasFlag(wxSTB_ELLIPSIZE_MIDDLE)) ellmode = wxELLIPSIZE_MIDDLE;
else if (HasFlag(wxSTB_ELLIPSIZE_END)) ellmode = wxELLIPSIZE_END;
if (ellmode == wxELLIPSIZE_NONE)
{
// if we have the wxSTB_SHOW_TIPS we must set the ellipsized flag even if
// we don't ellipsize the text but just truncate it
if (HasFlag(wxSTB_SHOW_TIPS))
SetEllipsizedFlag(i, dc.GetTextExtent(text).GetWidth() > maxWidth);
dc.SetClippingRegion(rect);
}
else
{
text = wxControl::Ellipsize(text, dc,
ellmode,
maxWidth,
wxELLIPSIZE_FLAGS_EXPAND_TABS);
// Ellipsize() will do something only if necessary
// update the ellipsization status for this pane; this is used later to
// decide whether a tooltip should be shown or not for this pane
// (if we have wxSTB_SHOW_TIPS)
SetEllipsizedFlag(i, text != GetStatusText(i));
}
#if defined( __WXGTK__ ) || defined(__WXMAC__)
xpos++;
ypos++;
#endif
// draw the text
dc.DrawText(text, xpos, ypos);
if (ellmode == wxELLIPSIZE_NONE)
dc.DestroyClippingRegion();
}
