base/shell/explorer/taskbar/taskbar.cpp

   1 /*
   2  * Copyright 2003, 2004, 2005 Martin Fuchs
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19
  20  //
  21  // Explorer clone
  22  //
  23  // taskbar.cpp
  24  //
  25  // Martin Fuchs, 16.08.2003
  26  //
  27
  28
  29 #include <precomp.h>
  30
  31 #include "taskbar.h"
  32 #include "traynotify.h" // for NOTIFYAREA_WIDTH_DEF
  33
  34
  35 DynamicFct<BOOL (WINAPI*)(HWND hwnd)> g_SetTaskmanWindow(TEXT("user32"), "SetTaskmanWindow");
  36 DynamicFct<BOOL (WINAPI*)(HWND hwnd)> g_RegisterShellHookWindow(TEXT("user32"), "RegisterShellHookWindow");
  37 DynamicFct<BOOL (WINAPI*)(HWND hwnd)> g_DeregisterShellHookWindow(TEXT("user32"), "DeregisterShellHookWindow");
  38
  39 /*
  40 DynamicFct<BOOL (WINAPI*)(HWND hWnd, DWORD dwType)> g_RegisterShellHook(TEXT("shell32"), (LPCSTR)0xb5);
  41
  42  // constants for RegisterShellHook()
  43 #define RSH_UNREGISTER                  0
  44 #define RSH_REGISTER                    1
  45 #define RSH_REGISTER_PROGMAN    2
  46 #define RSH_REGISTER_TASKMAN    3
  47 */
  48
  49
  50 TaskBarEntry::TaskBarEntry()
  51 {
  52         _id = 0;
  53         _hbmp = 0;
  54         _bmp_idx = 0;
  55         _used = 0;
  56         _btn_idx = 0;
  57         _fsState = 0;
  58 }
  59
  60 TaskBarMap::~TaskBarMap()
  61 {
  62         while(!empty()) {
  63                 iterator it = begin();
  64                 DeleteBitmap(it->second._hbmp);
  65                 erase(it);
  66         }
  67 }
  68
  69
  70 TaskBar::TaskBar(HWND hwnd)
  71  :      super(hwnd),
  72         WM_SHELLHOOK(RegisterWindowMessage(WINMSG_SHELLHOOK))
  73 {
  74         _last_btn_width = 0;
  75
  76         _mmMetrics_org.cbSize = sizeof(MINIMIZEDMETRICS);
  77
  78         SystemParametersInfo(SPI_GETMINIMIZEDMETRICS, sizeof(_mmMetrics_org), &_mmMetrics_org, 0);
  79
  80          // configure the window manager to hide windows when they are minimized
  81          // This is neccessary to enable shell hook messages.
  82         if (!(_mmMetrics_org.iArrange & ARW_HIDE)) {
  83                 MINIMIZEDMETRICS _mmMetrics_new = _mmMetrics_org;
  84
  85                 _mmMetrics_new.iArrange |= ARW_HIDE;
  86
  87                 SystemParametersInfo(SPI_SETMINIMIZEDMETRICS, sizeof(_mmMetrics_new), &_mmMetrics_new, 0);
  88         }
  89 }
  90
  91 TaskBar::~TaskBar()
  92 {
  93 //      if (g_RegisterShellHook)
  94 //              (*g_RegisterShellHook)(_hwnd, RSH_UNREGISTER);
  95
  96         if (g_DeregisterShellHookWindow)
  97                 (*g_DeregisterShellHookWindow)(_hwnd);
  98         else
  99                 KillTimer(_hwnd, 0);
 100
 101         if (g_SetTaskmanWindow)
 102                 (*g_SetTaskmanWindow)(0);
 103
 104         SystemParametersInfo(SPI_GETMINIMIZEDMETRICS, sizeof(_mmMetrics_org), &_mmMetrics_org, 0);
 105 }
 106
 107 HWND TaskBar::Create(HWND hwndParent)
 108 {
 109         ClientRect clnt(hwndParent);
 110
 111         int taskbar_pos = 80;   // This start position will be adjusted in DesktopBar::Resize().
 112
 113         return Window::Create(WINDOW_CREATOR(TaskBar), 0,
 114                                                         BtnWindowClass(CLASSNAME_TASKBAR), TITLE_TASKBAR,
 115                                                         WS_CHILD|WS_VISIBLE | CCS_TOP|CCS_NODIVIDER|CCS_NORESIZE,
 116                                                         taskbar_pos, 0, clnt.right-taskbar_pos-(NOTIFYAREA_WIDTH_DEF+1), clnt.bottom, hwndParent);
 117 }
 118
 119 LRESULT TaskBar::Init(LPCREATESTRUCT pcs)
 120 {
 121         if (super::Init(pcs))
 122                 return 1;
 123
 124         /* FIXME: There's an internal padding for non-flat toolbar. Get rid of it somehow. */
 125         _htoolbar = CreateToolbarEx(_hwnd,
 126                                                                 WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|
 127                                                                 CCS_TOP|CCS_NODIVIDER|TBSTYLE_LIST|TBSTYLE_TOOLTIPS|TBSTYLE_WRAPABLE,//|TBSTYLE_AUTOSIZE
 128                                                                 IDW_TASKTOOLBAR, 0, 0, 0, NULL, 0, 0, 0, 16, 16, sizeof(TBBUTTON));
 129
 130         SendMessage(_htoolbar, TB_SETBUTTONWIDTH, 0, MAKELONG(TASKBUTTONWIDTH_MAX,TASKBUTTONWIDTH_MAX));
 131         //SendMessage(_htoolbar, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_MIXEDBUTTONS);
 132         //SendMessage(_htoolbar, TB_SETDRAWTEXTFLAGS, DT_CENTER|DT_VCENTER, DT_CENTER|DT_VCENTER);
 133         //SetWindowFont(_htoolbar, GetStockFont(ANSI_VAR_FONT), FALSE);
 134         //SendMessage(_htoolbar, TB_SETPADDING, 0, MAKELPARAM(8,8));
 135
 136 #ifndef __MINGW32__     // TBMETRICS missing in MinGW (as of 20.09.2005)
 137          // set metrics for the Taskbar toolbar to enable button spacing
 138         TBMETRICS metrics;
 139
 140         metrics.cbSize = sizeof(TBMETRICS);
 141         metrics.dwMask = TBMF_BARPAD | TBMF_BUTTONSPACING;
 142         metrics.cxBarPad = 0;
 143         metrics.cyBarPad = 0;
 144         metrics.cxButtonSpacing = 3;
 145         metrics.cyButtonSpacing = 3;
 146
 147         SendMessage(_htoolbar, TB_SETMETRICS, 0, (LPARAM)&metrics);
 148 #endif
 149
 150         _next_id = IDC_FIRST_APP;
 151
 152          // register the taskbar window as task manager window to make the following call to RegisterShellHookWindow working
 153         if (g_SetTaskmanWindow)
 154                 (*g_SetTaskmanWindow)(_hwnd);
 155
 156         if (g_RegisterShellHookWindow) {
 157                 LOG(TEXT("Using shell hooks for notification of shell events."));
 158
 159                 (*g_RegisterShellHookWindow)(_hwnd);
 160         } else {
 161                 LOG(TEXT("Shell hooks not available."));
 162
 163                 SetTimer(_hwnd, 0, 200, NULL);
 164         }
 165
 166 /* Alternatively we could use the RegisterShellHook() function in SHELL32, but this is not yet implemented in the WINE code.
 167         if (g_RegisterShellHook) {
 168                 (*g_RegisterShellHook)(0, RSH_REGISTER);
 169
 170                 if ((HIWORD(GetVersion())>>14) == W_VER_NT)
 171                         (*g_RegisterShellHook)(_hwnd, RSH_REGISTER_TASKMAN);
 172                 else
 173                         (*g_RegisterShellHook)(_hwnd, RSH_REGISTER);
 174         }
 175 */
 176         Refresh();
 177
 178         return 0;
 179 }
 180
 181 LRESULT TaskBar::WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
 182 {
 183         switch(nmsg) {
 184           case WM_SIZE:
 185                 SendMessage(_htoolbar, WM_SIZE, 0, 0);
 186                 ResizeButtons();
 187                 break;
 188
 189           case WM_TIMER:
 190                 Refresh();
 191                 return 0;
 192
 193           case WM_CONTEXTMENU: {
 194                 Point pt(lparam);
 195                 ScreenToClient(_htoolbar, &pt);
 196
 197                 if ((HWND)wparam==_htoolbar && SendMessage(_htoolbar, TB_HITTEST, 0, (LPARAM)&pt)>=0)
 198                         break;  // avoid displaying context menu for application button _and_ desktop bar at the same time
 199
 200                 goto def;}
 201
 202           case PM_GET_LAST_ACTIVE:
 203                 return (LRESULT)(HWND)_last_foreground_wnd;
 204
 205           case WM_SYSCOLORCHANGE:
 206                 SendMessage(_htoolbar, WM_SYSCOLORCHANGE, 0, 0);
 207                 break;
 208
 209           default: def:
 210                 if (nmsg == WM_SHELLHOOK) {
 211                         switch(wparam) {
 212                           case HSHELL_WINDOWCREATED:
 213                           case HSHELL_WINDOWDESTROYED:
 214                           case HSHELL_WINDOWACTIVATED:
 215                           case HSHELL_REDRAW:
 216 #ifdef HSHELL_FLASH
 217                           case HSHELL_FLASH:
 218 #endif
 219 #ifdef HSHELL_RUDEAPPACTIVATED
 220                           case HSHELL_RUDEAPPACTIVATED:
 221 #endif
 222                                 Refresh();
 223                                 break;
 224                         }
 225                 } else {
 226                         return super::WndProc(nmsg, wparam, lparam);
 227                 }
 228         }
 229
 230         return 0;
 231 }
 232
 233 int TaskBar::Command(int id, int code)
 234 {
 235         TaskBarMap::iterator found = _map.find_id(id);
 236
 237         if (found != _map.end()) {
 238                 ActivateApp(found);
 239                 return 0;
 240         }
 241
 242         return super::Command(id, code);
 243 }
 244
 245 int TaskBar::Notify(int id, NMHDR* pnmh)
 246 {
 247         if (pnmh->hwndFrom == _htoolbar)
 248                 switch(pnmh->code) {
 249                   case NM_RCLICK: {
 250                         TBBUTTONINFO btninfo;
 251                         TaskBarMap::iterator it;
 252                         Point pt(GetMessagePos());
 253                         ScreenToClient(_htoolbar, &pt);
 254
 255                         btninfo.cbSize = sizeof(TBBUTTONINFO);
 256                         btninfo.dwMask = TBIF_BYINDEX|TBIF_COMMAND;
 257
 258                         int idx = SendMessage(_htoolbar, TB_HITTEST, 0, (LPARAM)&pt);
 259
 260                         if (idx>=0 &&
 261                                 SendMessage(_htoolbar, TB_GETBUTTONINFO, idx, (LPARAM)&btninfo)!=-1 &&
 262                                 (it=_map.find_id(btninfo.idCommand))!=_map.end()) {
 263                                 //TaskBarEntry& entry = it->second;
 264
 265                                 ActivateApp(it, false, false);  // don't restore minimized windows on right button click
 266
 267 #ifndef __MINGW32__     // SHRestricted() missing in MinGW (as of 29.10.2003)
 268                                 static DynamicFct<DWORD(STDAPICALLTYPE*)(RESTRICTIONS)> pSHRestricted(TEXT("SHELL32"), "SHRestricted");
 269
 270                                 if (pSHRestricted && !(*pSHRestricted)(REST_NOTRAYCONTEXTMENU))
 271 #endif
 272                                         ShowAppSystemMenu(it);
 273                         }
 274                         break;}
 275
 276                   default:
 277                         return super::Notify(id, pnmh);
 278                 }
 279
 280         return 0;
 281 }
 282
 283
 284 void TaskBar::ActivateApp(TaskBarMap::iterator it, bool can_minimize, bool can_restore)
 285 {
 286         HWND hwnd = it->first;
 287
 288         bool minimize_it = can_minimize && !IsIconic(hwnd) &&
 289                                                 (hwnd==GetForegroundWindow() || hwnd==_last_foreground_wnd);
 290
 291          // switch to selected application window
 292         if (can_restore && !minimize_it)
 293                 if (IsIconic(hwnd))
 294                         PostMessage(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
 295
 296          // In case minimize_it is true, we _have_ to switch to the app before
 297          // posting SW_MINIMIZE to be compatible with some applications (e.g. "Sleipnir")
 298         SetForegroundWindow(hwnd);
 299
 300         if (minimize_it) {
 301                 PostMessage(hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0);
 302                 _last_foreground_wnd = 0;
 303         } else
 304                 _last_foreground_wnd = hwnd;
 305
 306         Refresh();
 307 }
 308
 309 void TaskBar::ShowAppSystemMenu(TaskBarMap::iterator it)
 310 {
 311         HMENU hmenu = GetSystemMenu(it->first, FALSE);
 312
 313         if (hmenu) {
 314                 POINT pt;
 315
 316                 GetCursorPos(&pt);
 317                 int cmd = TrackPopupMenu(hmenu, TPM_LEFTBUTTON|TPM_RIGHTBUTTON|TPM_RETURNCMD, pt.x, pt.y, 0, _hwnd, NULL);
 318
 319                 if (cmd) {
 320                         ActivateApp(it, false, false);  // reactivate window after the context menu has closed
 321                         PostMessage(it->first, WM_SYSCOMMAND, cmd, 0);
 322                 }
 323         }
 324 }
 325
 326
 327 HICON get_window_icon_small(HWND hwnd)
 328 {
 329         HICON hIcon = 0;
 330
 331         SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL2, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 332
 333         if (!hIcon)
 334                 SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 335
 336         if (!hIcon)
 337                 SendMessageTimeout(hwnd, WM_GETICON, ICON_BIG, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 338
 339         if (!hIcon)
 340                 hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICONSM);
 341
 342         if (!hIcon)
 343                 hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICON);
 344
 345         if (!hIcon)
 346                 SendMessageTimeout(hwnd, WM_QUERYDRAGICON, 0, 0, 0, 1000, (LPDWORD)&hIcon);
 347
 348         return hIcon;
 349 }
 350
 351 HICON get_window_icon_big(HWND hwnd, bool allow_from_class)
 352 {
 353         HICON hIcon = 0;
 354
 355         SendMessageTimeout(hwnd, WM_GETICON, ICON_BIG, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 356
 357         if (!hIcon)
 358                 SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL2, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 359
 360         if (!hIcon)
 361                 SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 362
 363         if (allow_from_class) {
 364                 if (!hIcon)
 365                         hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICON);
 366
 367                 if (!hIcon)
 368                         hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICONSM);
 369         }
 370
 371         if (!hIcon)
 372                 SendMessageTimeout(hwnd, WM_QUERYDRAGICON, 0, 0, 0, 1000, (LPDWORD)&hIcon);
 373
 374         return hIcon;
 375 }
 376
 377  // fill task bar with buttons for enumerated top level windows
 378 BOOL CALLBACK TaskBar::EnumWndProc(HWND hwnd, LPARAM lparam)
 379 {
 380         TaskBar* pThis = (TaskBar*)lparam;
 381
 382         DWORD style = GetWindowStyle(hwnd);
 383         DWORD ex_style = GetWindowExStyle(hwnd);
 384
 385         if ((style&WS_VISIBLE) && !(ex_style&WS_EX_TOOLWINDOW) &&
 386                 !GetParent(hwnd) && !GetWindow(hwnd,GW_OWNER)) {
 387                 TCHAR title[BUFFER_LEN];
 388
 389                 if (!GetWindowText(hwnd, title, BUFFER_LEN))
 390                         title[0] = '\0';
 391
 392                 TaskBarMap::iterator found = pThis->_map.find(hwnd);
 393                 int last_id = 0;
 394
 395                 if (found != pThis->_map.end()) {
 396                         last_id = found->second._id;
 397
 398                         if (!last_id)
 399                                 found->second._id = pThis->_next_id++;
 400                 } else {
 401                         HBITMAP hbmp;
 402                         HICON hIcon = get_window_icon_small(hwnd);
 403                         BOOL delete_icon = FALSE;
 404
 405                         if (!hIcon) {
 406                                 hIcon = LoadIcon(0, IDI_APPLICATION);
 407                                 delete_icon = TRUE;
 408                         }
 409
 410                         if (hIcon) {
 411                                 hbmp = create_bitmap_from_icon(hIcon, GetSysColorBrush(COLOR_BTNFACE), WindowCanvas(pThis->_htoolbar));
 412                                 if (delete_icon)
 413                                         DestroyIcon(hIcon); // some icons can be freed, some not - so ignore any error return of DestroyIcon()
 414                         } else
 415                                 hbmp = 0;
 416
 417                         TBADDBITMAP ab = {0, (UINT_PTR)hbmp};
 418                         int bmp_idx = SendMessage(pThis->_htoolbar, TB_ADDBITMAP, 1, (LPARAM)&ab);
 419
 420                         TaskBarEntry entry;
 421
 422                         entry._id = pThis->_next_id++;
 423                         entry._hbmp = hbmp;
 424                         entry._bmp_idx = bmp_idx;
 425                         entry._title = title;
 426
 427                         pThis->_map[hwnd] = entry;
 428                         found = pThis->_map.find(hwnd);
 429                 }
 430
 431                 TBBUTTON btn = {-2/*I_IMAGENONE*/, 0, TBSTATE_ENABLED/*|TBSTATE_ELLIPSES*/, BTNS_BUTTON, {0, 0}, 0, 0};
 432                 TaskBarEntry& entry = found->second;
 433
 434                 ++entry._used;
 435                 btn.idCommand = entry._id;
 436
 437                 HWND foreground = GetForegroundWindow();
 438                 HWND foreground_owner = GetWindow(foreground, GW_OWNER);
 439
 440                 if (hwnd==foreground || hwnd==foreground_owner) {
 441                         btn.fsState |= TBSTATE_PRESSED|TBSTATE_CHECKED;
 442                         pThis->_last_foreground_wnd = hwnd;
 443                 }
 444
 445                 if (!last_id) {
 446                          // create new toolbar buttons for new windows
 447                         if (title[0])
 448                                 btn.iString = (INT_PTR)title;
 449
 450                         btn.iBitmap = entry._bmp_idx;
 451                         entry._btn_idx = SendMessage(pThis->_htoolbar, TB_BUTTONCOUNT, 0, 0);
 452
 453                         SendMessage(pThis->_htoolbar, TB_INSERTBUTTON, entry._btn_idx, (LPARAM)&btn);
 454
 455                         pThis->ResizeButtons();
 456                 } else {
 457                          // refresh attributes of existing buttons
 458                         if (btn.fsState != entry._fsState)
 459                                 SendMessage(pThis->_htoolbar, TB_SETSTATE, entry._id, MAKELONG(btn.fsState,0));
 460
 461                         if (entry._title != title) {
 462                                 TBBUTTONINFO info;
 463
 464                                 info.cbSize = sizeof(TBBUTTONINFO);
 465                                 info.dwMask = TBIF_TEXT;
 466                                 info.pszText = title;
 467
 468                                 SendMessage(pThis->_htoolbar, TB_SETBUTTONINFO, entry._id, (LPARAM)&info);
 469
 470                                 entry._title = title;
 471                         }
 472                 }
 473
 474                 entry._fsState = btn.fsState;
 475
 476 #ifdef __REACTOS__      // now handled by activating the ARW_HIDE flag with SystemParametersInfo(SPI_SETMINIMIZEDMETRICS)
 477                  // move minimized windows out of sight
 478                 if (IsIconic(hwnd)) {
 479                         RECT rect;
 480
 481                         GetWindowRect(hwnd, &rect);
 482
 483                         if (rect.bottom > 0)
 484                                 SetWindowPos(hwnd, 0, -32000, -32000, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
 485                 }
 486 #endif
 487         }
 488
 489         return TRUE;
 490 }
 491
 492 void TaskBar::Refresh()
 493 {
 494         for(TaskBarMap::iterator it=_map.begin(); it!=_map.end(); ++it)
 495                 it->second._used = 0;
 496
 497         EnumWindows(EnumWndProc, (LPARAM)this);
 498         //EnumDesktopWindows(GetThreadDesktop(GetCurrentThreadId()), EnumWndProc, (LPARAM)_htoolbar);
 499
 500         set<int> btn_idx_to_delete;
 501         set<HBITMAP> hbmp_to_delete;
 502
 503         for(TaskBarMap::iterator it=_map.begin(); it!=_map.end(); ++it) {
 504                 TaskBarEntry& entry = it->second;
 505
 506                 if (!entry._used && entry._id) {
 507                          // store button indexes to remove
 508                         btn_idx_to_delete.insert(entry._btn_idx);
 509                         hbmp_to_delete.insert(entry._hbmp);
 510                         entry._id = 0;
 511                 }
 512         }
 513
 514         if (!btn_idx_to_delete.empty()) {
 515                  // remove buttons from right to left
 516                 for(set<int>::reverse_iterator it=btn_idx_to_delete.rbegin(); it!=btn_idx_to_delete.rend(); ++it) {
 517                         int idx = *it;
 518
 519                         SendMessage(_htoolbar, TB_DELETEBUTTON, idx, 0);
 520
 521                         for(TaskBarMap::iterator it=_map.begin(); it!=_map.end(); ++it) {
 522                                 TaskBarEntry& entry = it->second;
 523
 524                                  // adjust button indexes
 525                                 if (entry._btn_idx > idx) {
 526                                         --entry._btn_idx;
 527                                         --entry._bmp_idx;
 528
 529                                         TBBUTTONINFO info;
 530
 531                                         info.cbSize = sizeof(TBBUTTONINFO);
 532                                         info.dwMask = TBIF_IMAGE;
 533                                         info.iImage = entry._bmp_idx;
 534
 535                                         SendMessage(_htoolbar, TB_SETBUTTONINFO, entry._id, (LPARAM)&info);
 536                                 }
 537                         }
 538                 }
 539
 540                 for(set<HBITMAP>::iterator it=hbmp_to_delete.begin(); it!=hbmp_to_delete.end(); ++it) {
 541                         HBITMAP hbmp = *it;
 542
 543                         TBREPLACEBITMAP tbrepl = {0, (UINT_PTR)hbmp, 0, 0};
 544                         SendMessage(_htoolbar, TB_REPLACEBITMAP, 0, (LPARAM)&tbrepl);
 545
 546                         DeleteObject(hbmp);
 547
 548                         for(TaskBarMap::iterator it=_map.begin(); it!=_map.end(); ++it)
 549                                 if (it->second._hbmp == hbmp) {
 550                                         _map.erase(it);
 551                                         break;
 552                                 }
 553                 }
 554
 555                 ResizeButtons();
 556         }
 557 }
 558
 559 TaskBarMap::iterator TaskBarMap::find_id(int id)
 560 {
 561         for(iterator it=begin(); it!=end(); ++it)
 562                 if (it->second._id == id)
 563                         return it;
 564
 565         return end();
 566 }
 567
 568 void TaskBar::ResizeButtons()
 569 {
 570         int btns = _map.size();
 571
 572         if (btns > 0) {
 573                 int bar_width = ClientRect(_hwnd).right;
 574                 int btn_width = (bar_width / btns) - 3;
 575
 576                 if (btn_width < TASKBUTTONWIDTH_MIN)
 577                         btn_width = TASKBUTTONWIDTH_MIN;
 578                 else if (btn_width > TASKBUTTONWIDTH_MAX)
 579                         btn_width = TASKBUTTONWIDTH_MAX;
 580
 581                 if (btn_width != _last_btn_width) {
 582                         _last_btn_width = btn_width;
 583
 584                         SendMessage(_htoolbar, TB_SETBUTTONWIDTH, 0, MAKELONG(btn_width,btn_width));
 585                         SendMessage(_htoolbar, TB_AUTOSIZE, 0, 0);
 586                 }
 587         }
 588 }