BOOL CEpgTimerTaskDlg::ChgTipsTaskBar(HWND hWnd, UINT uiID, HICON hIcon, CString strTips)
{
BOOL bRet;
NOTIFYICONDATA stData;
ZeroMemory(&stData, sizeof(NOTIFYICONDATA));
stData.cbSize = sizeof(NOTIFYICONDATA);
stData.hWnd = hWnd;
stData.uID = uiID;
stData.hIcon = hIcon;
stData.uFlags = NIF_ICON | NIF_TIP;
if( strTips.IsEmpty() == false ){
wcsncpy_s(stData.szTip, sizeof(stData.szTip), strTips.GetBuffer(0), sizeof(stData.szTip) );
}
bRet = Shell_NotifyIcon(NIM_MODIFY, &stData);
return bRet;
}
BOOL CSystemTray::HideIcon()
{
if (!m_bEnabled || m_bRemoved || m_bHidden)
return TRUE;
#ifdef SYSTEMTRAY_USEW2K
if (m_bWin2K)
{
m_tnd.uFlags = NIF_STATE;
m_tnd.dwState = NIS_HIDDEN;
m_tnd.dwStateMask = NIS_HIDDEN;
m_bHidden = Shell_NotifyIcon( NIM_MODIFY, &m_tnd);
}
else
#endif
RemoveIcon();
return (m_bHidden == TRUE);
}
BOOL CTrayDialog::TrayUpdate()
{
BOOL bSuccess = FALSE;
if (m_bTrayIconVisible)
{
bSuccess = Shell_NotifyIcon(NIM_MODIFY, &m_nidIconData);
if (!bSuccess) {
//ASSERT(0);
return FALSE; // don't delete 'm_hPrevIconDelete' because it's still attached to the tray
}
}
if (m_hPrevIconDelete != NULL)
{
VERIFY( ::DestroyIcon(m_hPrevIconDelete) );
m_hPrevIconDelete = NULL;
}
return bSuccess;
}
//-------------------------------------------------
void ModifyStatusIcon()
{
NOTIFYICONDATA tnid;
tnid.cbSize = sizeof(NOTIFYICONDATA);
tnid.hWnd = pShMem->hMainDlg;
tnid.uID = ID_VIETKEY_ICON;
if (pShMem->vietKey) {
tnid.hIcon = pShMem->hVietIcon;
lstrcpy(tnid.szTip,_TEXT("Click to turn off Vietnamese mode"));
} else {
tnid.hIcon = pShMem->hEnIcon;
lstrcpy(tnid.szTip,_TEXT("Click to turn on Vietnamese mode"));
}
tnid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
tnid.uCallbackMessage = pShMem->iconMsgId;
Shell_NotifyIcon(pShMem->iconShown?NIM_MODIFY:NIM_ADD, &tnid);
pShMem->iconShown = 1;
}
int CH3CDlg::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CDialog::OnCreate(lpCreateStruct) == -1)
return -1;
// TODO: 在此添加您专用的创建代码
m_threadInfo.hWnd=this->m_hWnd;
tnd.cbSize=NOTIFYICONDATA_V2_SIZE;
tnd.hWnd=this->m_hWnd;
tnd.uID=IDR_MAINFRAME;
tnd.uFlags=NIF_MESSAGE|NIF_ICON|NIF_TIP;
tnd.uCallbackMessage=WM_TRAY;
tnd.hIcon=LoadIcon(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDI_DISCON));
wcsncpy_s(tnd.szTip, _countof(tnd.szTip), _T("H3C 802.1x认证"), 128);
Shell_NotifyIcon(NIM_ADD,&tnd);
return 0;
}
BOOL CEdenDlg::ChgTipsTaskBar(HWND wnd, UINT id, HICON icon, CString tips)
{
BOOL ret=TRUE;
NOTIFYICONDATA data;
ZeroMemory(&data, sizeof(NOTIFYICONDATA));
data.cbSize = sizeof(NOTIFYICONDATA);
data.hWnd = wnd;
data.uID = id;
data.hIcon = icon;
data.uFlags = NIF_ICON | NIF_TIP;
if( tips.IsEmpty() == false ){
wcsncpy_s(data.szTip, sizeof(data.szTip), tips.GetBuffer(0), sizeof(data.szTip) );
}
ret = Shell_NotifyIcon(NIM_MODIFY, &data);
return ret;
}
VOID toggleCursorClipping()
{
if (isClippingEnabled)
{
// Freeing the cursor
ClipCursor(NULL);
// Removing the systray tooltip
notificationIconData.szTip[0] = '\0';
// Changing systray icon
notificationIconData.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_INACTIVE));
}
else
{
HWND hWnd = GetForegroundWindow();
if (hWnd != NULL) {
// Clipping cursor
GetWindowText(hWnd, clippedWindowName, MAX_CLIPPED_WINDOW_NAME_SIZE);
clipCursorToWindow(hWnd);
// Changing the systray tooltip
_snwprintf_s(
notificationIconData.szTip,
sizeof(notificationIconData.szTip),
L"Cursor clipped to: %s",
clippedWindowName);
// Changing systray icon
notificationIconData.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ACTIVE));
}
}
Shell_NotifyIcon(NIM_MODIFY, ¬ificationIconData);
isClippingEnabled = !isClippingEnabled;
}
/*
Can be called multiple times
*/
static int openMonitorIcon()
{
NOTIFYICONDATA data;
HICON iconHandle;
HBITMAP go, stop;
static int doOnce = 0;
int rc;
if (app->monitorMenu == NULL) {
app->monitorMenu = LoadMenu(app->appInst, "monitorMenu");
if (! app->monitorMenu) {
mprError("Can't locate monitorMenu");
return MPR_ERR_CANT_OPEN;
}
}
if (app->subMenu == NULL) {
app->subMenu = GetSubMenu(app->monitorMenu, 0);
go = LoadBitmap(app->appInst, MAKEINTRESOURCE(IDB_GO));
rc = GetLastError();
stop = LoadBitmap(app->appInst, MAKEINTRESOURCE(IDB_STOP));
SetMenuItemBitmaps(app->subMenu, MA_MENU_STATUS, MF_BYCOMMAND, stop, go);
}
iconHandle = (HICON) LoadImage(app->appInst, APPWEB_ICON, IMAGE_ICON, 0, 0, LR_LOADFROMFILE | LR_DEFAULTSIZE);
if (iconHandle == 0) {
mprError("Can't load icon %s", APPWEB_ICON);
return MPR_ERR_CANT_INITIALIZE;
}
data.uID = APPWEB_MONITOR_ID;
data.hWnd = app->appHwnd;
data.hIcon = iconHandle;
data.cbSize = sizeof(NOTIFYICONDATA);
data.uCallbackMessage = APPWEB_MONITOR_MESSAGE;
data.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;
scopy(data.szTip, sizeof(data.szTip), mprGetAppTitle());
Shell_NotifyIcon(NIM_ADD, &data);
if (iconHandle) {
DestroyIcon(iconHandle);
}
return 0;
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
if (!m_wndStatusBar.Create(this) ||
!m_wndStatusBar.SetIndicators(indicators,
sizeof(indicators)/sizeof(UINT)))
{
TRACE0("Failed to create status bar\n");
return -1; // fail to create
}
// TODO: Delete these three lines if you don't want the toolbar to
// be dockable
m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
EnableDocking(CBRS_ALIGN_ANY);
DockControlBar(&m_wndToolBar);
NOTIFYICONDATA &tnd = m_notifyData;
tnd.cbSize=sizeof(NOTIFYICONDATA);
tnd.hWnd=this->m_hWnd;
tnd.uID=IDR_MAINFRAME;
tnd.uFlags=NIF_MESSAGE|NIF_ICON|NIF_TIP;
tnd.uCallbackMessage=WM_MYSYSTRAYNOTIFY;
tnd.hIcon=LoadIcon(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDR_MAINFRAME));
strcpy(tnd.szTip,"菩提字幕");//图标提示为"测试程序"
BOOL rt = Shell_NotifyIcon(NIM_ADD,&tnd);//向任务栏添加图标
if(!rt)
TRACE0("Add systray icon failed!");
return 0;
}
static int openTrayIcon()
{
NOTIFYICONDATA data;
HICON iconHandle;
static int doOnce = 0;
if (trayMenu == NULL) {
trayMenu = LoadMenu(appInst, "trayMenu");
if (! trayMenu) {
mprError(MPR_L, MPR_LOG, "Can't locate trayMenu");
return MPR_ERR_CANT_OPEN;
}
}
if (subMenu == NULL) {
subMenu = GetSubMenu(trayMenu, 0);
}
iconHandle = (HICON) LoadImage(appInst, APPWEB_ICON, IMAGE_ICON, 0, 0,
LR_LOADFROMFILE | LR_DEFAULTSIZE);
if (iconHandle == 0) {
mprError(MPR_L, MPR_LOG, "Can't load icon %s", APPWEB_ICON);
return MPR_ERR_CANT_INITIALIZE;
}
data.uID = APPWEB_TRAY_ID;
data.hWnd = appHwnd;
data.hIcon = iconHandle;
data.cbSize = sizeof(NOTIFYICONDATA);
data.uCallbackMessage = APPWEB_TRAY_MESSAGE;
data.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;
mprStrcpy(data.szTip, sizeof(data.szTip), mp->getAppTitle());
Shell_NotifyIcon(NIM_ADD, &data);
if (iconHandle) {
DestroyIcon(iconHandle);
}
return 0;
}
NS_IMETHODIMP
otSystrayWin::Hide()
{
nsresult rv = otSystrayBase::Hide();
if (NS_SUCCEEDED(rv) && mNid) {
NOTIFYICONDATA nid;
nid.cbSize = sizeof(nid);
nid.hWnd = GetHWND();
nid.uFlags = 0;
nid.uID = mNid;
Shell_NotifyIcon(NIM_DELETE, &nid);
systrays[mNid-100] = 0;
mNid = 0;
}
return rv;
}
BOOL CEpgDataCap_BonDlg::AddTaskBar(HWND wnd, UINT msg, UINT id, HICON icon, CString tips)
{
BOOL ret=TRUE;
NOTIFYICONDATA data;
ZeroMemory(&data, sizeof(NOTIFYICONDATA));
data.cbSize = sizeof(NOTIFYICONDATA);
data.hWnd = wnd;
data.uID = id;
data.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
data.uCallbackMessage = msg;
data.hIcon = icon;
if( tips.IsEmpty() == false ){
wcsncpy_s(data.szTip, sizeof(data.szTip), tips.GetBuffer(0), sizeof(data.szTip) );
}
ret = Shell_NotifyIcon(NIM_ADD, &data);
return ret;
}
BOOL ShowTrayIcon()
{
NOTIFYICONDATA nid;
ZeroMemory(&nid, sizeof(NOTIFYICONDATA));
nid.cbSize = (DWORD)sizeof(NOTIFYICONDATA);
nid.hWnd = hWnd;
nid.uID = NID_UID;
nid.uFlags = NIF_ICON|NIF_MESSAGE|NIF_TIP;
nid.dwInfoFlags=NIIF_INFO;
nid.uCallbackMessage = WM_TASKBARNOTIFY;
nid.hIcon = LoadIcon(hInst, (LPCTSTR)IDI_SMALL);
lstrcpy(nid.szTip, szTooltip);
if (lstrlen(szBalloon) > 0)
{
nid.uFlags |= NIF_INFO;
lstrcpy(nid.szInfo, szBalloon);
lstrcpy(nid.szInfoTitle,szTitle);
}
Shell_NotifyIcon(NIM_ADD, &nid);
return TRUE;
}
BOOL CTrayNotifyIcon::SetIcon(HICON hIcon)
{
BOOL ret_val;
if (!m_bCreated)
return FALSE;
m_NotifyIconData.uFlags = NIF_ICON;
m_NotifyIconData.hIcon = hIcon;
ret_val = Shell_NotifyIcon(NIM_MODIFY, &m_NotifyIconData);
if (ret_val == FALSE) {
bSetIconFailed = TRUE;
}
else {
bSetIconFailed = FALSE;
}
return ret_val;
}
//-----------------------------
void channelPopup(const char *title, const char *msg, bool isPopup = true)
{
String both;
if (*title == '\0') return;
both.append(msg);
both.append(" (");
both.append(title);
both.append(")");
trayIcon.uFlags = NIF_ICON|NIF_TIP;
strncpy(trayIcon.szTip, both.cstr(),sizeof(trayIcon.szTip)-1);
trayIcon.szTip[sizeof(trayIcon.szTip)-1]=0;
if (isPopup) trayIcon.uFlags |= 16;
trayIcon.uTimeoutOrVersion = 10000;
strncpy(trayIcon.szInfo,msg,sizeof(trayIcon.szInfo)-1);
strncpy(trayIcon.szInfoTitle,title,sizeof(trayIcon.szInfoTitle)-1);
Shell_NotifyIcon(NIM_MODIFY, (NOTIFYICONDATA*)&trayIcon);
}
static void CreateTrayIcon(bool create)
{
NOTIFYICONDATA nim;
DBVARIANT dbVar;
if (!db_get_ts(NULL,MOD_NAME,"ToolTipText",&dbVar))
{
mir_sntprintf(nim.szTip, 64, _T("%s"), dbVar.ptszVal);
db_free(&dbVar);
}
else
lstrcpy(nim.szTip, _T("Miranda NG"));
nim.cbSize = sizeof(nim);
nim.hWnd = g_hListenWindow;
nim.uID = 100;
nim.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
nim.hIcon = Skin_GetIcon("hidemim");
nim.uCallbackMessage = WM_USER + 24;
Shell_NotifyIcon(create ? NIM_ADD : NIM_DELETE, &nim);
g_TrayIcon = create;
}
void CMainFrame::OnSize(UINT nType, int cx, int cy)
{
if (nType & SIZE_MINIMIZED)
{
if (!iconData)
{
iconData = new NOTIFYICONDATA;
iconData->cbSize = NOTIFYICONDATA_V1_SIZE;
iconData->hWnd = GetSafeHwnd();
iconData->uID = 0;
iconData->uFlags = NIF_ICON | NIF_MESSAGE;
iconData->uCallbackMessage = ID_ICON_CALLBACK;
iconData->hIcon = (HICON)theApp.LoadIcon(IDR_MAINFRAME);
}
Shell_NotifyIcon(NIM_ADD,iconData);
ShowTaskBarButton(false);
}
CFrameWnd::OnSize(nType, cx, cy);
// TODO: Add your message handler code here
}
void BalloonMgr::clear()
{
if (_pending.empty())
return; // No active balloon!?
// Clear active balloon
Balloon &balloon = _pending.front();
NOTIFYICONDATA nid;
nid.hWnd = balloon.hwnd;
nid.cbSize = sizeof(nid);
nid.uID = IDI_APCUPSD;
nid.uFlags = NIF_INFO;
nid.uTimeout = 0;
nid.szInfoTitle[0] = '\0';
nid.szInfo[0] = '\0';
nid.dwInfoFlags = 0;
Shell_NotifyIcon(NIM_MODIFY, &nid);
// Remove vector entry for active balloon
_pending.erase(_pending.begin());
}
bool
HippoIcon::create(HWND window)
{
NOTIFYICONDATA notifyIconData = { 0 };
HINSTANCE instance = GetModuleHandle(NULL);
window_ = window;
message_ = RegisterWindowMessage(TEXT("HippoNotifyMessage"));
notifyIconData.cbSize = sizeof(NOTIFYICONDATA);
notifyIconData.hWnd = window_;
notifyIconData.uID = 0;
notifyIconData.uFlags = NIF_ICON | NIF_MESSAGE;
notifyIconData.uCallbackMessage = message_;
notifyIconData.hIcon = icon_;
Shell_NotifyIcon(NIM_ADD, ¬ifyIconData);
return true;
}
bool TrayIconsManager::DelIcon(TrayIconHandler* handler)
{
NOTIFYICONDATA data;
BOOL res;
// Remove the actual tray icon
data.cbSize = sizeof(data);
data.hWnd = vdWindow;
data.uID = (UINT)handler;
data.uFlags = 0;
res = Shell_NotifyIcon(NIM_DELETE, &data);
// Unset the message handler
vdWindow.UnSetMessageHandler(handler->m_callbackMessage);
// Remove from the list
m_registered_handlers.erase(handler);
return (res ? true : false);
}
//************************************
// 函数名称: DeleteTrayIcon
// 返回类型: void
// 函数说明:
//************************************
void CTrayIconUI::DeleteTrayIcon()
{
if (pIDuiTimer)
{
StopTwinkling();
pIDuiTimer = NULL;
}
if(m_pDuiTime){
m_pDuiTime->KillDuiTimer();
delete m_pDuiTime;
m_pDuiTime = NULL;
}
Shell_NotifyIcon(NIM_DELETE,&m_trayData);
m_bEnabled = false;
m_bVisible = false;
m_bTwinkling = false;
m_hWnd = NULL;
m_uMessage = UIEVENT_TRAYICON;
}
static void start_stop(HWND dlg)
{
HWND button = GetDlgItem(dlg, IDOK);
if (!button)
err(1, "GetDlgItem()");
if (_tcpcryptd == INVALID_HANDLE_VALUE) {
start();
SetWindowText(button, "Stop");
SetWindowText(GetDlgItem(dlg, IDC_EDIT2), "tcpcrypt ON!");
_nidcur = &_nid[1];
Shell_NotifyIcon(NIM_MODIFY, _nidcur);
SendMessage(_hwnd, WM_SETICON, ICON_SMALL,
(LPARAM) _nidcur->hIcon);
EnableWindow(GetDlgItem(dlg, IDC_BUTTON2), TRUE);
} else {
stop();
do_stop(dlg);
}
}
BOOL CTrayNotifyIcon::SetTooltipText(LPCTSTR pszTooltipText, BOOL bWin2k)
{
if (!m_bCreated)
return FALSE;
if (!bWin2k)
{
ASSERT(_tcslen(pszTooltipText) < 64);
m_NotifyIconData.cbSize = sizeof(NOTIFYICONDATA_1);
}
else
{
ASSERT(_tcslen(pszTooltipText) < 128);
m_NotifyIconData.cbSize = sizeof(NOTIFYICONDATA_2);
}
//Call the Shell_NotifyIcon function
m_NotifyIconData.uFlags = NIF_TIP;
_tcscpy(m_NotifyIconData.szTip, pszTooltipText);
return Shell_NotifyIcon(NIM_MODIFY, (PNOTIFYICONDATA) &m_NotifyIconData);
}
void NgineSlackBrowser::OnCreate(HWND hWnd)
{
RECT rc;
GetClientRect(hWnd, &rc);
CefWindowInfo window_info;
window_info.SetAsChild(hWnd, rc);
const char16 *font_family = L"맑은 고딕";
const size_t font_family_size = wcslen(font_family);
CefBrowserSettings browser_settings;
cef_string_utf16_set(font_family, font_family_size, &browser_settings.standard_font_family, TRUE);
cef_string_utf16_set(font_family, font_family_size, &browser_settings.serif_font_family, TRUE);
cef_string_utf16_set(font_family, font_family_size, &browser_settings.sans_serif_font_family, TRUE);
cef_string_utf16_set(font_family, font_family_size, &browser_settings.cursive_font_family, TRUE);
cef_string_utf16_set(font_family, font_family_size, &browser_settings.fantasy_font_family, TRUE);
browser_settings.local_storage = STATE_ENABLED;
browser_settings.databases = STATE_ENABLED;
browser_settings.application_cache = STATE_ENABLED;
CefString url = "https://slack.com/ssb";
m_handler = new NgineSlackClient(this);
CefBrowserHost::CreateBrowser(window_info, m_handler.get(), url, browser_settings, NULL);
HINSTANCE hInst = _AtlBaseModule.GetModuleInstance();
ZeroMemory(&m_nidTray, sizeof(m_nidTray));
m_nidTray.cbSize = sizeof(m_nidTray);
m_nidTray.hWnd = hWnd;
m_nidTray.uID = (UINT)hWnd;
m_nidTray.uFlags = NIF_MESSAGE | NIF_ICON;
m_nidTray.uCallbackMessage = WM_NOTIFYICON_TRAY;
m_nidTray.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICON));
Shell_NotifyIcon(NIM_ADD, &m_nidTray);
HMENU hMenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_TRAY_CONTEXTMENU));
m_hTrayMenu = GetSubMenu(hMenu, 0);
UpdateStartup();
}
void InitProgram (HINSTANCE hInst)
{
HICON hIcon, hIconSm;
hwndDlg = CreateDialog(hInst,
MAKEINTRESOURCE(IDD_DLG_ZRJ), NULL, DlgProc);
hwndEditUser = GetDlgItem (hwndDlg, IDC_EDT_USR);
hwndEditPass = GetDlgItem (hwndDlg, IDC_EDT_PAS);
hwndButtonConn = GetDlgItem (hwndDlg, IDC_BTN_CONN);
hwndButtonExit = GetDlgItem (hwndDlg, IDC_BTN_EXIT);
hwndComboList = GetDlgItem (hwndDlg, IDC_CBO_LIST);
hIcon = LoadImage(GetModuleHandle(NULL),
MAKEINTRESOURCE(IDI_ICON_RJ), IMAGE_ICON, 32, 32, 0);
hIconSm = LoadImage(GetModuleHandle(NULL),
MAKEINTRESOURCE(IDI_ICON_RJ), IMAGE_ICON, 16, 16, 0);
//set application icon
SendMessage(hwndDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
SendMessage(hwndDlg, WM_SETICON, ICON_SMALL, (LPARAM)hIconSm);
SendMessage(hwndDlg, WM_SETTEXT, NULL, (LPARAM)DIALOG_TITLE);
/* Add icon to system tray */
ZeroMemory(&niData,sizeof(NOTIFYICONDATA));
niData.cbSize = sizeof(NOTIFYICONDATA);
niData.uID = TRAYICONID;
niData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
niData.hIcon = hIconSm;
niData.hWnd = hwndDlg;
niData.uCallbackMessage = SWM_TRAYMSG;
lstrcpyn(niData.szTip, TEXT("zRuijie for GZHU"), sizeof(niData.szTip)/sizeof(TCHAR));
Shell_NotifyIcon(NIM_ADD,&niData);
}
BOOL CTrayNotifyIcon::SetBalloonDetails(LPCTSTR pszBalloonText, LPCTSTR pszBalloonCaption, BalloonStyle style, UINT nTimeout)
{
//Validate our parameters
ASSERT(_tcslen(pszBalloonText) < 256);
ASSERT(_tcslen(pszBalloonCaption) < 64);
if (!m_bCreated)
return FALSE;
//Call the Shell_NotifyIcon function
m_NotifyIconData.uFlags = NIF_INFO;
_tcscpy(m_NotifyIconData.szInfo, pszBalloonText);
_tcscpy(m_NotifyIconData.szInfoTitle, pszBalloonCaption);
m_NotifyIconData.uTimeout = nTimeout;
switch (style)
{
case Warning:
{
m_NotifyIconData.dwInfoFlags = NIIF_WARNING;
break;
}
case Error:
{
m_NotifyIconData.dwInfoFlags = NIIF_ERROR;
break;
}
case Info:
{
m_NotifyIconData.dwInfoFlags = NIIF_INFO;
break;
}
default:
{
ASSERT(FALSE);
break;
}
}
return Shell_NotifyIcon(NIM_MODIFY, (PNOTIFYICONDATA) &m_NotifyIconData);
}
/*********************************************************************
* Function: LRESULT CALLBACK MenuCommandHookProc(int nCode, WPARAM wParam, LPARAM lParam)
* Author: Chau Nguyen
* Created On: 2003/10/24
* --------------------------------------------------------------------
* Purpose: Intercept all command message to process my own menu command.
* --------------------------------------------------------------------
* Input Parameters: No
*
* Output Parameters: No
*
* Return Value: No
*
* --------------------------------------------------------------------
* NOTE:
* -
*
* --------------------------------------------------------------------
* REVISION HISTORY:
* Version Date Author Description
*
*********************************************************************/
LRESULT CALLBACK MenuCommandHookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
// return immediately if system required
if (nCode < 0){
return CallNextHookEx(g_hMenuCommandHook, nCode, wParam, lParam);
}
// process the arrival message
MSG *msg = (MSG*)lParam;
switch (msg->message) {
case WM_SYSCOMMAND:
if(LOWORD(msg->wParam) == SC_TRAYME ){
// iterate to determine the arrival command belongs to which window
for(UINT i = 0; i < g_iLastIndex; i++){
if(g_listWnd[i].m_hWnd == (HWND)msg->hwnd){
// check if it was not minimized yet
if(!g_listWnd[i].m_bMinimized){
// Add icon to tray
Shell_NotifyIcon(NIM_ADD, &g_listWnd[i].m_niData);
// free icon handle
// hide window
ShowWindow(g_listWnd[i].m_hWnd, SW_HIDE);
// set the flag
g_listWnd[i].m_bMinimized = TRUE;
}
break; // exit the for loop
}
}
}
break;
}
// call next hook
return CallNextHookEx(g_hMenuCommandHook, nCode, wParam, lParam);
}
static void addTaskBarIcons(HINSTANCE hInstance, HWND hWnd, BOOL& bInTaskBar)
{
if (!service_flag)
{
HICON hIcon = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_IBGUARD),
IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
NOTIFYICONDATA nid;
nid.cbSize = sizeof(NOTIFYICONDATA);
nid.hWnd = hWnd;
nid.uID = IDI_IBGUARD;
nid.uFlags = NIF_TIP | NIF_ICON | NIF_MESSAGE;
nid.uCallbackMessage = ON_NOTIFYICON;
nid.hIcon = hIcon;
lstrcpy(nid.szTip, GUARDIAN_APP_LABEL);
// This will be true if we are using the explorer interface
bInTaskBar = Shell_NotifyIcon(NIM_ADD, &nid);
if (hIcon)
DestroyIcon(hIcon);
// This will be true if we are using the program manager interface
if (!bInTaskBar)
{
char szMsgString[256];
HMENU hSysMenu = GetSystemMenu(hWnd, FALSE);
DeleteMenu(hSysMenu, SC_RESTORE, MF_BYCOMMAND);
AppendMenu(hSysMenu, MF_SEPARATOR, 0, NULL);
LoadString(hInstance, IDS_SVRPROPERTIES, szMsgString, 256);
AppendMenu(hSysMenu, MF_STRING, IDM_SVRPROPERTIES, szMsgString);
LoadString(hInstance, IDS_SHUTDOWN, szMsgString, 256);
AppendMenu(hSysMenu, MF_STRING, IDM_SHUTDOWN, szMsgString);
LoadString(hInstance, IDS_PROPERTIES, szMsgString, 256);
AppendMenu(hSysMenu, MF_STRING, IDM_PROPERTIES, szMsgString);
DestroyMenu(hSysMenu);
}
}
}
static void OnSize(HWND hwnd, UINT state, int cx, int cy)
{
NOTIFYICONDATA dta;
if( state == SIZE_MINIMIZED ) {
dta.cbSize = sizeof(NOTIFYICONDATA);
dta.hWnd = hwnd;
dta.uID = ID_TRAY;
dta.uFlags = NIF_ICON|NIF_MESSAGE|NIF_TIP;
dta.uCallbackMessage = WM_SHELLNOTIFY;
dta.hIcon = LoadIcon(GetWindowInstance(hwnd), MAKEINTRESOURCE(ID_ICON1));
strcpy(dta.szTip, "D2CS Version");
strcat(dta.szTip, " ");
strcat(dta.szTip, D2CS_VERSION_STRING);
Shell_NotifyIcon(NIM_ADD, &dta);
ShowWindow(hwnd, SW_HIDE);
return;
}
MoveWindow(ghwndConsole, 0, 0, cx, cy, TRUE);
}
BOOL TrayMessage(HWND hDlg,DWORD dwMessage,UINT uID,HICON hIcon,LPCTSTR lpszTip)
{
NOTIFYICONDATA tnd;
tnd.cbSize = sizeof(NOTIFYICONDATA);
tnd.hWnd = hDlg;
tnd.uID = uID;
tnd.uFlags = NIF_MESSAGE|NIF_ICON|NIF_TIP;
tnd.uCallbackMessage = MYWM_ICON;
tnd.hIcon = hIcon;
if(lpszTip)
{
//tnd.szTip大小为64，如果lpszTip大于该值则截断
memset(tnd.szTip,0,sizeof(tnd.szTip));
lstrcpyn(tnd.szTip,lpszTip,sizeof(tnd.szTip));
}
else
*tnd.szTip = '\0';
return Shell_NotifyIcon(dwMessage, &tnd);
}
