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           default: def:
 206                 if (nmsg == WM_SHELLHOOK) {
 207                         switch(wparam) {
 208                           case HSHELL_WINDOWCREATED:
 209                           case HSHELL_WINDOWDESTROYED:
 210                           case HSHELL_WINDOWACTIVATED:
 211                           case HSHELL_REDRAW:
 212 #ifdef HSHELL_FLASH
 213                           case HSHELL_FLASH:
 214 #endif
 215 #ifdef HSHELL_RUDEAPPACTIVATED
 216                           case HSHELL_RUDEAPPACTIVATED:
 217 #endif
 218                                 Refresh();
 219                                 break;
 220                         }
 221                 } else {
 222                         return super::WndProc(nmsg, wparam, lparam);
 223                 }
 224         }
 225
 226         return 0;
 227 }
 228
 229 int TaskBar::Command(int id, int code)
 230 {
 231         TaskBarMap::iterator found = _map.find_id(id);
 232
 233         if (found != _map.end()) {
 234                 ActivateApp(found);
 235                 return 0;
 236         }
 237
 238         return super::Command(id, code);
 239 }
 240
 241 int TaskBar::Notify(int id, NMHDR* pnmh)
 242 {
 243         if (pnmh->hwndFrom == _htoolbar)
 244                 switch(pnmh->code) {
 245                   case NM_RCLICK: {
 246                         TBBUTTONINFO btninfo;
 247                         TaskBarMap::iterator it;
 248                         Point pt(GetMessagePos());
 249                         ScreenToClient(_htoolbar, &pt);
 250
 251                         btninfo.cbSize = sizeof(TBBUTTONINFO);
 252                         btninfo.dwMask = TBIF_BYINDEX|TBIF_COMMAND;
 253
 254                         int idx = SendMessage(_htoolbar, TB_HITTEST, 0, (LPARAM)&pt);
 255
 256                         if (idx>=0 &&
 257                                 SendMessage(_htoolbar, TB_GETBUTTONINFO, idx, (LPARAM)&btninfo)!=-1 &&
 258                                 (it=_map.find_id(btninfo.idCommand))!=_map.end()) {
 259                                 //TaskBarEntry& entry = it->second;
 260
 261                                 ActivateApp(it, false, false);  // don't restore minimized windows on right button click
 262
 263 #ifndef __MINGW32__     // SHRestricted() missing in MinGW (as of 29.10.2003)
 264                                 static DynamicFct<DWORD(STDAPICALLTYPE*)(RESTRICTIONS)> pSHRestricted(TEXT("SHELL32"), "SHRestricted");
 265
 266                                 if (pSHRestricted && !(*pSHRestricted)(REST_NOTRAYCONTEXTMENU))
 267 #endif
 268                                         ShowAppSystemMenu(it);
 269                         }
 270                         break;}
 271
 272                   default:
 273                         return super::Notify(id, pnmh);
 274                 }
 275
 276         return 0;
 277 }
 278
 279
 280 void TaskBar::ActivateApp(TaskBarMap::iterator it, bool can_minimize, bool can_restore)
 281 {
 282         HWND hwnd = it->first;
 283
 284         bool minimize_it = can_minimize && !IsIconic(hwnd) &&
 285                                                 (hwnd==GetForegroundWindow() || hwnd==_last_foreground_wnd);
 286
 287          // switch to selected application window
 288         if (can_restore && !minimize_it)
 289                 if (IsIconic(hwnd))
 290                         PostMessage(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
 291
 292          // In case minimize_it is true, we _have_ to switch to the app before
 293          // posting SW_MINIMIZE to be compatible with some applications (e.g. "Sleipnir")
 294         SetForegroundWindow(hwnd);
 295
 296         if (minimize_it) {
 297                 PostMessage(hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0);
 298                 _last_foreground_wnd = 0;
 299         } else
 300                 _last_foreground_wnd = hwnd;
 301
 302         Refresh();
 303 }
 304
 305 void TaskBar::ShowAppSystemMenu(TaskBarMap::iterator it)
 306 {
 307         HMENU hmenu = GetSystemMenu(it->first, FALSE);
 308
 309         if (hmenu) {
 310                 POINT pt;
 311
 312                 GetCursorPos(&pt);
 313                 int cmd = TrackPopupMenu(hmenu, TPM_LEFTBUTTON|TPM_RIGHTBUTTON|TPM_RETURNCMD, pt.x, pt.y, 0, _hwnd, NULL);
 314
 315                 if (cmd) {
 316                         ActivateApp(it, false, false);  // reactivate window after the context menu has closed
 317                         PostMessage(it->first, WM_SYSCOMMAND, cmd, 0);
 318                 }
 319         }
 320 }
 321
 322
 323 HICON get_window_icon_small(HWND hwnd)
 324 {
 325         HICON hIcon = 0;
 326
 327         SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL2, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 328
 329         if (!hIcon)
 330                 SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 331
 332         if (!hIcon)
 333                 SendMessageTimeout(hwnd, WM_GETICON, ICON_BIG, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 334
 335         if (!hIcon)
 336                 hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICONSM);
 337
 338         if (!hIcon)
 339                 hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICON);
 340
 341         if (!hIcon)
 342                 SendMessageTimeout(hwnd, WM_QUERYDRAGICON, 0, 0, 0, 1000, (LPDWORD)&hIcon);
 343
 344         return hIcon;
 345 }
 346
 347 HICON get_window_icon_big(HWND hwnd, bool allow_from_class)
 348 {
 349         HICON hIcon = 0;
 350
 351         SendMessageTimeout(hwnd, WM_GETICON, ICON_BIG, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 352
 353         if (!hIcon)
 354                 SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL2, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 355
 356         if (!hIcon)
 357                 SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL, 0, SMTO_ABORTIFHUNG, 1000, (LPDWORD)&hIcon);
 358
 359         if (allow_from_class) {
 360                 if (!hIcon)
 361                         hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICON);
 362
 363                 if (!hIcon)
 364                         hIcon = (HICON)GetClassLongPtr(hwnd, GCL_HICONSM);
 365         }
 366
 367         if (!hIcon)
 368                 SendMessageTimeout(hwnd, WM_QUERYDRAGICON, 0, 0, 0, 1000, (LPDWORD)&hIcon);
 369
 370         return hIcon;
 371 }
 372
 373  // fill task bar with buttons for enumerated top level windows
 374 BOOL CALLBACK TaskBar::EnumWndProc(HWND hwnd, LPARAM lparam)
 375 {
 376         TaskBar* pThis = (TaskBar*)lparam;
 377
 378         DWORD style = GetWindowStyle(hwnd);
 379         DWORD ex_style = GetWindowExStyle(hwnd);
 380
 381         if ((style&WS_VISIBLE) && !(ex_style&WS_EX_TOOLWINDOW) &&
 382                 !GetParent(hwnd) && !GetWindow(hwnd,GW_OWNER)) {
 383                 TCHAR title[BUFFER_LEN];
 384
 385                 if (!GetWindowText(hwnd, title, BUFFER_LEN))
 386                         title[0] = '\0';
 387
 388                 TaskBarMap::iterator found = pThis->_map.find(hwnd);
 389                 int last_id = 0;
 390
 391                 if (found != pThis->_map.end()) {
 392                         last_id = found->second._id;
 393
 394                         if (!last_id)
 395                                 found->second._id = pThis->_next_id++;
 396                 } else {
 397                         HBITMAP hbmp;
 398                         HICON hIcon = get_window_icon_small(hwnd);
 399                         BOOL delete_icon = FALSE;
 400
 401                         if (!hIcon) {
 402                                 hIcon = LoadIcon(0, IDI_APPLICATION);
 403                                 delete_icon = TRUE;
 404                         }
 405
 406                         if (hIcon) {
 407                                 hbmp = create_bitmap_from_icon(hIcon, GetSysColorBrush(COLOR_BTNFACE), WindowCanvas(pThis->_htoolbar));
 408                                 if (delete_icon)
 409                                         DestroyIcon(hIcon); // some icons can be freed, some not - so ignore any error return of DestroyIcon()
 410                         } else
 411                                 hbmp = 0;
 412
 413                         TBADDBITMAP ab = {0, (UINT_PTR)hbmp};
 414                         int bmp_idx = SendMessage(pThis->_htoolbar, TB_ADDBITMAP, 1, (LPARAM)&ab);
 415
 416                         TaskBarEntry entry;
 417
 418                         entry._id = pThis->_next_id++;
 419                         entry._hbmp = hbmp;
 420                         entry._bmp_idx = bmp_idx;
 421                         entry._title = title;
 422
 423                         pThis->_map[hwnd] = entry;
 424                         found = pThis->_map.find(hwnd);
 425                 }
 426
 427                 TBBUTTON btn = {-2/*I_IMAGENONE*/, 0, TBSTATE_ENABLED/*|TBSTATE_ELLIPSES*/, BTNS_BUTTON, {0, 0}, 0, 0};
 428                 TaskBarEntry& entry = found->second;
 429
 430                 ++entry._used;
 431                 btn.idCommand = entry._id;
 432
 433                 HWND foreground = GetForegroundWindow();
 434                 HWND foreground_owner = GetWindow(foreground, GW_OWNER);
 435
 436                 if (hwnd==foreground || hwnd==foreground_owner) {
 437                         btn.fsState |= TBSTATE_PRESSED|TBSTATE_CHECKED;
 438                         pThis->_last_foreground_wnd = hwnd;
 439                 }
 440
 441                 if (!last_id) {
 442                          // create new toolbar buttons for new windows
 443                         if (title[0])
 444                                 btn.iString = (INT_PTR)title;
 445
 446                         btn.iBitmap = entry._bmp_idx;
 447                         entry._btn_idx = SendMessage(pThis->_htoolbar, TB_BUTTONCOUNT, 0, 0);
 448
 449                         SendMessage(pThis->_htoolbar, TB_INSERTBUTTON, entry._btn_idx, (LPARAM)&btn);
 450
 451                         pThis->ResizeButtons();
 452                 } else {
 453                          // refresh attributes of existing buttons
 454                         if (btn.fsState != entry._fsState)
 455                                 SendMessage(pThis->_htoolbar, TB_SETSTATE, entry._id, MAKELONG(btn.fsState,0));
 456
 457                         if (entry._title != title) {
 458                                 TBBUTTONINFO info;
 459
 460                                 info.cbSize = sizeof(TBBUTTONINFO);
 461                                 info.dwMask = TBIF_TEXT;
 462                                 info.pszText = title;
 463
 464                                 SendMessage(pThis->_htoolbar, TB_SETBUTTONINFO, entry._id, (LPARAM)&info);
 465
 466                                 entry._title = title;
 467                         }
 468                 }
 469
 470                 entry._fsState = btn.fsState;
 471
 472 #ifdef __REACTOS__      // now handled by activating the ARW_HIDE flag with SystemParametersInfo(SPI_SETMINIMIZEDMETRICS)
 473                  // move minimized windows out of sight
 474                 if (IsIconic(hwnd)) {
 475                         RECT rect;
 476
 477                         GetWindowRect(hwnd, &rect);
 478
 479                         if (rect.bottom > 0)
 480                                 SetWindowPos(hwnd, 0, -32000, -32000, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
 481                 }
 482 #endif
 483         }
 484
 485         return TRUE;
 486 }
 487
 488 void TaskBar::Refresh()
 489 {
 490         for(TaskBarMap::iterator it=_map.begin(); it!=_map.end(); ++it)
 491                 it->second._used = 0;
 492
 493         EnumWindows(EnumWndProc, (LPARAM)this);
 494         //EnumDesktopWindows(GetThreadDesktop(GetCurrentThreadId()), EnumWndProc, (LPARAM)_htoolbar);
 495
 496         set<int> btn_idx_to_delete;
 497         set<HBITMAP> hbmp_to_delete;
 498
 499         for(TaskBarMap::iterator it=_map.begin(); it!=_map.end(); ++it) {
 500                 TaskBarEntry& entry = it->second;
 501
 502                 if (!entry._used && entry._id) {
 503                          // store button indexes to remove
 504                         btn_idx_to_delete.insert(entry._btn_idx);
 505                         hbmp_to_delete.insert(entry._hbmp);
 506                         entry._id = 0;
 507                 }
 508         }
 509
 510         if (!btn_idx_to_delete.empty()) {
 511                  // remove buttons from right to left
 512                 for(set<int>::reverse_iterator it=btn_idx_to_delete.rbegin(); it!=btn_idx_to_delete.rend(); ++it) {
 513                         int idx = *it;
 514
 515                         SendMessage(_htoolbar, TB_DELETEBUTTON, idx, 0);
 516
 517                         for(TaskBarMap::iterator it=_map.begin(); it!=_map.end(); ++it) {
 518                                 TaskBarEntry& entry = it->second;
 519
 520                                  // adjust button indexes
 521                                 if (entry._btn_idx > idx) {
 522                                         --entry._btn_idx;
 523                                         --entry._bmp_idx;
 524
 525                                         TBBUTTONINFO info;
 526
 527                                         info.cbSize = sizeof(TBBUTTONINFO);
 528                                         info.dwMask = TBIF_IMAGE;
 529                                         info.iImage = entry._bmp_idx;
 530
 531                                         SendMessage(_htoolbar, TB_SETBUTTONINFO, entry._id, (LPARAM)&info);
 532                                 }
 533                         }
 534                 }
 535
 536                 for(set<HBITMAP>::iterator it=hbmp_to_delete.begin(); it!=hbmp_to_delete.end(); ++it) {
 537                         HBITMAP hbmp = *it;
 538
 539                         TBREPLACEBITMAP tbrepl = {0, (UINT_PTR)hbmp, 0, 0};
 540                         SendMessage(_htoolbar, TB_REPLACEBITMAP, 0, (LPARAM)&tbrepl);
 541
 542                         DeleteObject(hbmp);
 543
 544                         for(TaskBarMap::iterator it=_map.begin(); it!=_map.end(); ++it)
 545                                 if (it->second._hbmp == hbmp) {
 546                                         _map.erase(it);
 547                                         break;
 548                                 }
 549                 }
 550
 551                 ResizeButtons();
 552         }
 553 }
 554
 555 TaskBarMap::iterator TaskBarMap::find_id(int id)
 556 {
 557         for(iterator it=begin(); it!=end(); ++it)
 558                 if (it->second._id == id)
 559                         return it;
 560
 561         return end();
 562 }
 563
 564 void TaskBar::ResizeButtons()
 565 {
 566         int btns = _map.size();
 567
 568         if (btns > 0) {
 569                 int bar_width = ClientRect(_hwnd).right;
 570                 int btn_width = (bar_width / btns) - 3;
 571
 572                 if (btn_width < TASKBUTTONWIDTH_MIN)
 573                         btn_width = TASKBUTTONWIDTH_MIN;
 574                 else if (btn_width > TASKBUTTONWIDTH_MAX)
 575                         btn_width = TASKBUTTONWIDTH_MAX;
 576
 577                 if (btn_width != _last_btn_width) {
 578                         _last_btn_width = btn_width;
 579
 580                         SendMessage(_htoolbar, TB_SETBUTTONWIDTH, 0, MAKELONG(btn_width,btn_width));
 581                         SendMessage(_htoolbar, TB_AUTOSIZE, 0, 0);
 582                 }
 583         }
 584 }