bool wxTaskBarIconEx::SetBalloon(const wxIcon& icon, const wxString title, const wxString message, unsigned int timeout, unsigned int iconballoon)
{
if (!IsOK())
return false;
if (!icon.Ok())
return false;
memset(¬ifyData, 0, sizeof(notifyData));
notifyData.cbSize = sizeof(notifyData);
notifyData.hWnd = (HWND) m_hWnd;
notifyData.uID = 99;
notifyData.uCallbackMessage = sm_taskbarMsg;
notifyData.uFlags = NIF_MESSAGE | NIF_INFO | NIF_TIP | NIF_ICON;
notifyData.dwInfoFlags = iconballoon | NIIF_NOSOUND;
notifyData.uTimeout = timeout;
notifyData.uVersion = NOTIFYICON_VERSION;
lstrcpyn(notifyData.szInfo, WXSTRINGCAST message, sizeof(notifyData.szInfo));
lstrcpyn(notifyData.szInfoTitle, WXSTRINGCAST title, sizeof(notifyData.szInfoTitle));
lstrcpyn(notifyData.szTip, WXSTRINGCAST wxEmptyString, sizeof(notifyData.szTip));
notifyData.hIcon = (HICON) icon.GetHICON();
UpdateIcon();
return m_iconAdded;
}
// This function converts to the right size with the given background colour
wxBitmap PrepareIcon(wxIcon icon, wxSize size)
{
if (icon.GetWidth() == size.GetWidth() && icon.GetHeight() == size.GetHeight())
return icon;
wxBitmap bmp;
bmp.CopyFromIcon(icon);
return bmp.ConvertToImage().Rescale(size.GetWidth(), size.GetHeight());
}
void wxGCDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
{
wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawIcon - invalid DC") );
wxCHECK_RET( icon.IsOk(), wxT("wxGCDC(cg)::DoDrawIcon - invalid icon") );
wxCoord w = icon.GetWidth();
wxCoord h = icon.GetHeight();
m_graphicContext->DrawIcon( icon , x, y, w, h );
}
wxIcon &GetGreyIcon(wxIcon &icon)
{
wxBitmap bmp;
bmp.CopyFromIcon(icon);
wxImage img = bmp.ConvertToImage();
GreyOutImage(img);
wxBitmap bmp2(img,32);
static wxIcon rval;
rval.CopyFromBitmap(bmp2);
return rval;
}
void wxFrame::DoSetIcon(const wxIcon& icon)
{
if (!m_frameShell)
return;
if (!icon.Ok() || !icon.GetDrawable())
return;
XtVaSetValues((Widget) m_frameShell,
XtNiconPixmap, icon.GetDrawable(),
NULL);
}
void wxMotifDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
{
wxCHECK_RET( IsOk(), "invalid dc" );
wxCHECK_RET( icon.IsOk(), "invalid icon" );
DoDrawBitmap(icon, x, y, true);
}
// Operations
bool wxTaskBarIconEx::SetIcon(const wxIcon& icon, const wxString& message)
{
if (!IsOK())
return false;
if (!icon.Ok())
return false;
wxBitmap bitmap = icon;
if (!g_pStatusIcon)
{
g_pStatusIcon = gtk_status_icon_new_from_pixbuf(bitmap.GetPixbuf());
g_signal_connect(g_pStatusIcon, "activate", G_CALLBACK(status_icon_activate), this);
g_signal_connect(g_pStatusIcon, "popup_menu", G_CALLBACK(status_icon_popup_menu), this);
}
gtk_status_icon_set_from_pixbuf(g_pStatusIcon, bitmap.GetPixbuf());
if (!message.empty())
{
gtk_status_icon_set_tooltip(g_pStatusIcon, message.mb_str());
}
gtk_status_icon_set_visible(g_pStatusIcon, TRUE);
return true;
}
void wxDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
{
wxCHECK_RET( Ok(), "invalid dc" );
wxCHECK_RET( icon.Ok(), "invalid icon" );
DoDrawBitmap(icon, x, y, true);
}
void wxIconBundle::AddIcon( const wxIcon& icon )
{
size_t i, max = m_icons.GetCount();
for( i = 0; i < max; ++i )
{
wxIcon& tmp = m_icons[i];
if( tmp.Ok() && tmp.GetWidth() == icon.GetWidth() &&
tmp.GetHeight() == icon.GetHeight() )
{
tmp = icon;
return;
}
}
m_icons.Add( icon );
}
int wxImageList::Add( const wxIcon &bitmap )
{
wxASSERT_MSG( (bitmap.GetWidth() == m_width && bitmap.GetHeight() == m_height)
|| (m_width == 0 && m_height == 0),
wxT("invalid bitmap size in wxImageList: this might work ")
wxT("on this platform but definitely won't under Windows.") );
m_images.Append( new wxIcon( bitmap ) );
if (m_width == 0 && m_height == 0)
{
m_width = bitmap.GetWidth();
m_height = bitmap.GetHeight();
}
return m_images.GetCount() - 1;
}
// Operations:
bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
{
wxBitmap bmp( icon ) ;
OSStatus err = noErr ;
CGImageRef pImage;
#if 0 // is always available under OSX now -- crashes on 10.2 in CFRetain() - RN
pImage = (CGImageRef) bmp.CGImageCreate() ;
#else
WXHBITMAP iconport ;
WXHBITMAP maskport ;
iconport = bmp.GetHBITMAP( &maskport ) ;
if (!maskport)
{
// Make a mask with no transparent pixels
wxBitmap mbmp(icon.GetWidth(), icon.GetHeight());
wxMemoryDC dc;
dc.SelectObject(mbmp);
dc.SetBackground(*wxBLACK_BRUSH);
dc.Clear();
dc.SelectObject(wxNullBitmap);
bmp.SetMask( new wxMask(mbmp, *wxWHITE) ) ;
iconport = bmp.GetHBITMAP( &maskport ) ;
}
//create the icon from the bitmap and mask bitmap contained within
err = CreateCGImageFromPixMaps(
GetGWorldPixMap(MAC_WXHBITMAP(iconport)),
GetGWorldPixMap(MAC_WXHBITMAP(maskport)),
&pImage
);
wxASSERT(err == 0);
#endif
wxASSERT(pImage != NULL );
err = SetApplicationDockTileImage(pImage);
wxASSERT(err == 0);
if (pImage != NULL)
CGImageRelease(pImage);
return m_iconAdded = err == noErr;
}
void wxTopLevelWindowBase::SetIcon(const wxIcon& icon)
{
// passing wxNullIcon to SetIcon() is possible (it means that we shouldn't
// have any icon), but adding an invalid icon to wxIconBundle is not
wxIconBundle icons;
if ( icon.IsOk() )
icons.AddIcon(icon);
SetIcons(icons);
}
// Set icon
void wxMDIChildFrame::SetIcon(const wxIcon& icon)
{
m_icons = wxIconBundle( icon );
if (icon.Ok())
{
// Not appropriate since there are no icons in
// a tabbed window
}
}
void wxStdRenderer::DrawFrameIcon(wxDC& dc,
const wxRect& rect,
const wxIcon& icon,
int flags)
{
if ( icon.Ok() )
{
wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
dc.DrawIcon(icon, r.x, r.y);
}
}
void wxTopLevelWindowX11::DoSetIcon(const wxIcon& icon)
{
if (icon.IsOk() && X11GetMainWindow())
{
#if !wxUSE_NANOX
XWMHints *wmHints = XAllocWMHints();
wmHints->icon_pixmap = (Pixmap) icon.GetPixmap();
wmHints->flags = IconPixmapHint;
if (icon.GetMask())
{
wmHints->flags |= IconMaskHint;
wmHints->icon_mask = (Pixmap) icon.GetMask()->GetBitmap();
}
XSetWMHints(wxGlobalDisplay(), (Window) X11GetMainWindow(), wmHints);
XFree(wmHints);
#endif
}
}
// Operations
bool wxTaskBarIconEx::SetIcon(const wxIcon& icon)
{
if (!IsOK())
return FALSE;
memset(¬ifyData, 0, sizeof(notifyData));
notifyData.cbSize = sizeof(notifyData);
notifyData.hWnd = (HWND) m_hWnd;
notifyData.uID = 99;
notifyData.uCallbackMessage = sm_taskbarMsg;
notifyData.uFlags = NIF_MESSAGE;
notifyData.uVersion = NOTIFYICON_VERSION;
if (icon.Ok())
{
notifyData.uFlags |= NIF_ICON;
notifyData.hIcon = (HICON) icon.GetHICON();
}
UpdateIcon();
return m_iconAdded;
}
int wxGxContentView::GetIconPos(wxIcon icon_small, wxIcon icon_large)
{
wxCriticalSectionLocker locker(m_CritSect);
int pos(0);
if(icon_small.IsOk())
{
for(size_t i = 0; i < m_IconsArray.size(); ++i)
{
if(m_IconsArray[i].bLarge)
continue;
if(m_IconsArray[i].oIcon.IsSameAs(icon_small))
{
pos = m_IconsArray[i].iImageIndex;
break;
}
}
if(pos == 0)
{
pos = m_ImageListSmall.Add(icon_small);
ICONDATA myicondata = {icon_small, pos, false};
m_IconsArray.push_back(myicondata);
wxIcon temp_large_icon(document_48_xpm);
if(!icon_large.IsOk())
icon_large = temp_large_icon;
pos = m_ImageListLarge.Add(icon_large);
ICONDATA myicondata1 = {icon_large, pos, true};
m_IconsArray.push_back(myicondata1);
}
}
else
pos = 2;//0 col img, 1 - col img
return pos;
}
// Operations
bool wxTaskBarIconEx::SetIcon(const wxIcon& icon)
{
if (!IsOK())
return false;
if (!icon.Ok())
return false;
memset(¬ifyData, 0, sizeof(notifyData));
notifyData.cbSize = sizeof(notifyData);
notifyData.hWnd = (HWND) m_hWnd;
notifyData.uID = 99;
notifyData.uCallbackMessage = sm_taskbarMsg;
notifyData.uFlags = NIF_MESSAGE | NIF_ICON;
notifyData.uVersion = NOTIFYICON_VERSION;
lstrcpyn(notifyData.szInfo, WXSTRINGCAST wxEmptyString, sizeof(notifyData.szInfo));
lstrcpyn(notifyData.szInfoTitle, WXSTRINGCAST wxEmptyString, sizeof(notifyData.szInfoTitle));
lstrcpyn(notifyData.szTip, WXSTRINGCAST wxEmptyString, sizeof(notifyData.szTip));
notifyData.hIcon = (HICON) icon.GetHICON();
UpdateIcon();
return m_iconAdded;
}
// Operations
bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
{
// NB: we have to create the window lazily because of backward compatibility,
// old applications may create a wxTaskBarIcon instance before wxApp
// is initialized (as samples/taskbar used to do)
if (!m_win)
{
m_win = new wxTaskBarIconWindow(this);
}
m_icon = icon;
m_strTooltip = tooltip;
NotifyIconData notifyData(GetHwndOf(m_win));
if (icon.IsOk())
{
notifyData.uFlags |= NIF_ICON;
notifyData.hIcon = GetHiconOf(icon);
}
// set NIF_TIP even for an empty tooltip: otherwise it would be impossible
// to remove an existing tooltip using this function
notifyData.uFlags |= NIF_TIP;
if ( !tooltip.empty() )
{
wxStrlcpy(notifyData.szTip, tooltip.t_str(), WXSIZEOF(notifyData.szTip));
}
bool ok = Shell_NotifyIcon(m_iconAdded ? NIM_MODIFY
: NIM_ADD, ¬ifyData) != 0;
if ( !ok )
{
wxLogLastError(wxT("Shell_NotifyIcon(NIM_MODIFY/ADD)"));
}
if ( !m_iconAdded && ok )
m_iconAdded = true;
return ok;
}
// Operations
bool gcTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
{
#ifdef WIN32
m_icon = icon;
m_strTooltip = tooltip;
NotifyIconData notifyData(GetHwndOf(m_win));
if (icon.Ok())
{
notifyData.uFlags |= NIF_ICON;
notifyData.hIcon = GetHiconOf(icon);
}
// set NIF_TIP even for an empty tooltip: otherwise it would be impossible
// to remove an existing tooltip using this function
notifyData.uFlags |= NIF_TIP;
if ( !tooltip.empty() )
{
wxStrlcpy(notifyData.szTip, tooltip.wx_str(), WXSIZEOF(notifyData.szTip));
}
bool ok = wxShellNotifyIcon(m_iconAdded ? NIM_MODIFY
: NIM_ADD, ¬ifyData) != 0;
if ( !ok )
{
wxLogLastError(wxT("wxShellNotifyIcon(NIM_MODIFY/ADD)"));
}
if ( !m_iconAdded && ok )
m_iconAdded = true;
return ok;
#else
return wxTaskBarIcon::SetIcon(icon, tooltip);
#endif
}
// Create a drag image from an icon and optional cursor
bool wxDragImage::Create(const wxIcon& image, const wxCursor& cursor)
{
if ( m_hImageList )
ImageList_Destroy(GetHimageList());
m_hImageList = 0;
#ifdef __WXWINCE__
UINT flags = ILC_COLOR;
#else
UINT flags wxDUMMY_INITIALIZE(0) ;
if (image.GetDepth() <= 4)
flags = ILC_COLOR4;
else if (image.GetDepth() <= 8)
flags = ILC_COLOR8;
else if (image.GetDepth() <= 16)
flags = ILC_COLOR16;
else if (image.GetDepth() <= 24)
flags = ILC_COLOR24;
else
flags = ILC_COLOR32;
#endif
flags |= ILC_MASK;
m_hImageList = (WXHIMAGELIST) ImageList_Create(image.GetWidth(), image.GetHeight(), flags, 1, 1);
HICON hIcon = (HICON) image.GetHICON();
int index = ImageList_AddIcon(GetHimageList(), hIcon);
if ( index == -1 )
{
wxLogError(_("Couldn't add an image to the image list."));
}
m_cursor = cursor; // Can only combine with drag image after calling BeginDrag.
return (index != -1) ;
}
void wxNotificationMessageWindow::SetMessageIcon(const wxIcon& icon)
{
m_messageBmp->SetBitmap(icon);
m_messageBmp->Show(icon.IsOk());
}
wxRichToolTipPopup(wxWindow* parent,
const wxString& title,
const wxString& message,
const wxIcon& icon,
wxTipKind tipKind,
const wxFont& titleFont_) :
m_timer(this)
{
Create(parent, wxFRAME_SHAPED);
wxBoxSizer* const sizerTitle = new wxBoxSizer(wxHORIZONTAL);
if ( icon.IsOk() )
{
sizerTitle->Add(new wxStaticBitmap(this, wxID_ANY, icon),
wxSizerFlags().Centre().Border(wxRIGHT));
}
//else: Simply don't show any icon.
wxStaticText* const labelTitle = new wxStaticText(this, wxID_ANY, "");
labelTitle->SetLabelText(title);
wxFont titleFont(titleFont_);
if ( !titleFont.IsOk() )
{
// Determine the appropriate title font for the current platform.
titleFont = labelTitle->GetFont();
#ifdef __WXMSW__
// When using themes MSW tooltips use larger bluish version of the
// normal font.
wxUxThemeEngine* const theme = GetTooltipTheme();
if ( theme )
{
titleFont.MakeLarger();
COLORREF c;
if ( FAILED(theme->GetThemeColor
(
wxUxThemeHandle(parent, L"TOOLTIP"),
TTP_BALLOONTITLE,
0,
TMT_TEXTCOLOR,
&c
)) )
{
// Use the standard value of this colour as fallback.
c = 0x993300;
}
labelTitle->SetForegroundColour(wxRGBToColour(c));
}
else
#endif // __WXMSW__
{
// Everything else, including "classic" MSW look uses just the
// bold version of the base font.
titleFont.MakeBold();
}
}
labelTitle->SetFont(titleFont);
sizerTitle->Add(labelTitle, wxSizerFlags().Centre());
wxBoxSizer* const sizerTop = new wxBoxSizer(wxVERTICAL);
sizerTop->Add(sizerTitle,
wxSizerFlags().DoubleBorder(wxLEFT|wxRIGHT|wxTOP));
// Use a spacer as we don't want to have a double border between the
// elements, just a simple one will do.
sizerTop->AddSpacer(wxSizerFlags::GetDefaultBorder());
wxTextSizerWrapper wrapper(this);
wxSizer* sizerText = wrapper.CreateSizer(message, -1 /* No wrapping */);
#ifdef __WXMSW__
if ( icon.IsOk() && GetTooltipTheme() )
{
// Themed tooltips under MSW align the text with the title, not
// with the icon, so use a helper horizontal sizer in this case.
wxBoxSizer* const sizerTextIndent = new wxBoxSizer(wxHORIZONTAL);
sizerTextIndent->AddSpacer(icon.GetWidth());
sizerTextIndent->Add(sizerText,
wxSizerFlags().Border(wxLEFT).Centre());
sizerText = sizerTextIndent;
}
#endif // !__WXMSW__
sizerTop->Add(sizerText,
wxSizerFlags().DoubleBorder(wxLEFT|wxRIGHT|wxBOTTOM)
.Centre());
SetSizer(sizerTop);
const int offsetY = SetTipShapeAndSize(tipKind, GetBestSize());
if ( offsetY > 0 )
{
// Offset our contents by the tip height to make it appear in the
// main rectangle.
sizerTop->PrependSpacer(offsetY);
}
Layout();
}
void
wxSetIconsX11(WXDisplay* display, WXWindow window, const wxIconBundle& ib)
{
size_t size = 0;
const size_t numIcons = ib.GetIconCount();
for ( size_t i = 0; i < numIcons; ++i )
{
const wxIcon icon = ib.GetIconByIndex(i);
size += 2 + icon.GetWidth() * icon.GetHeight();
}
wxMAKE_ATOM(_NET_WM_ICON, (Display*)display);
if ( size > 0 )
{
unsigned long* data = new unsigned long[size];
unsigned long* ptr = data;
for ( size_t i = 0; i < numIcons; ++i )
{
const wxImage image = ib.GetIconByIndex(i).ConvertToImage();
int width = image.GetWidth(),
height = image.GetHeight();
unsigned char* imageData = image.GetData();
unsigned char* imageDataEnd = imageData + ( width * height * 3 );
bool hasMask = image.HasMask();
unsigned char rMask, gMask, bMask;
unsigned char r, g, b, a;
if( hasMask )
{
rMask = image.GetMaskRed();
gMask = image.GetMaskGreen();
bMask = image.GetMaskBlue();
}
else // no mask, but still init the variables to avoid warnings
{
rMask =
gMask =
bMask = 0;
}
*ptr++ = width;
*ptr++ = height;
while ( imageData < imageDataEnd )
{
r = imageData[0];
g = imageData[1];
b = imageData[2];
if( hasMask && r == rMask && g == gMask && b == bMask )
a = 0;
else
a = 255;
*ptr++ = ( a << 24 ) | ( r << 16 ) | ( g << 8 ) | b;
imageData += 3;
}
}
XChangeProperty( (Display*)display,
WindowCast(window),
_NET_WM_ICON,
XA_CARDINAL, 32,
PropModeReplace,
(unsigned char*)data, size );
delete[] data;
}
else
{
XDeleteProperty( (Display*)display,
WindowCast(window),
_NET_WM_ICON );
}
}
bool wxTaskBarIconEx::SetBalloon(const wxIcon& icon, const wxString title, const wxString message, unsigned int iconballoon)
{
wxLogTrace(wxT("Function Start/End"), wxT("wxTaskBarIconEx::SetBalloon - Function Begin"));
bool retval = false;
GError* error = NULL;
if (!IsOK())
return false;
if (!icon.Ok())
return false;
if (!SetIcon(icon, wxEmptyString))
return false;
gchar* desired_icon = NULL;
switch(iconballoon)
{
case BALLOONTYPE_INFO:
desired_icon = GTK_STOCK_DIALOG_INFO;
break;
case BALLOONTYPE_WARNING:
desired_icon = GTK_STOCK_DIALOG_WARNING;
break;
case BALLOONTYPE_ERROR:
desired_icon = GTK_STOCK_DIALOG_ERROR;
break;
}
if (!g_pNotification)
{
// Old Style
if (my_notify_notification_new_with_status_icon) {
g_pNotification =
(*my_notify_notification_new_with_status_icon)(
title.mb_str(),
message.mb_str(),
desired_icon,
g_pStatusIcon
);
}
// New Style
if (my_notify_notification_new) {
g_pNotification =
(*my_notify_notification_new)(
title.mb_str(),
message.mb_str(),
gtk_status_icon_get_icon_name(g_pStatusIcon)
);
}
g_signal_connect(
g_pNotification,
"closed",
G_CALLBACK(status_icon_notification_closed),
this
);
notify_notification_add_action(
g_pNotification,
"default",
"Do Default Action",
NOTIFY_ACTION_CALLBACK(status_icon_notification_actions),
this,
NULL
);
}
else
{
notify_notification_update(
g_pNotification,
title.mb_str(),
message.mb_str(),
desired_icon
);
}
retval = notify_notification_show(g_pNotification, &error);
g_clear_error(&error);
wxLogTrace(wxT("Function Start/End"), wxT("wxTaskBarIconEx::SetBalloon - Function End"));
return retval;
}
