programs/winecfg/audio.c

   1 /*
   2  * Audio management UI code
   3  *
   4  * Copyright 2004 Chris Morgan
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #define WIN32_LEAN_AND_MEAN
  23 #define NONAMELESSSTRUCT
  24 #define NONAMELESSUNION
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <assert.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33
  34 #include <windows.h>
  35 #include <wine/debug.h>
  36 #include <shellapi.h>
  37 #include <objbase.h>
  38 #include <shlguid.h>
  39 #include <shlwapi.h>
  40 #include <shlobj.h>
  41 #include <mmsystem.h>
  42 #include <mmreg.h>
  43 #include <mmddk.h>
  44
  45 #include "winecfg.h"
  46 #include "resource.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
  49
  50 #define DRIVER_MASK 0x80000000
  51 #define DEVICE_MASK 0x40000000
  52 #define MAX_NAME_LENGTH 64
  53
  54 typedef DWORD (WINAPI * MessagePtr)(UINT, UINT, DWORD, DWORD, DWORD);
  55
  56 static struct DSOUNDACCEL
  57 {
  58   UINT displayID;
  59   UINT visible;
  60   const char* settingStr;
  61 } DSound_HW_Accels[] = {
  62   {IDS_ACCEL_FULL,      1, "Full"},
  63   {IDS_ACCEL_STANDARD,  0, "Standard"},
  64   {IDS_ACCEL_BASIC,     0, "Basic"},
  65   {IDS_ACCEL_EMULATION, 1, "Emulation"},
  66   {0, 0, 0}
  67 };
  68
  69 static const char* DSound_Rates[] = {
  70   "48000",
  71   "44100",
  72   "22050",
  73   "16000",
  74   "11025",
  75   "8000",
  76   NULL
  77 };
  78
  79 static const char* DSound_Bits[] = {
  80   "8",
  81   "16",
  82   NULL
  83 };
  84
  85 typedef struct
  86 {
  87   UINT nameID;
  88   const char *szDriver;
  89 } AUDIO_DRIVER;
  90
  91 static const AUDIO_DRIVER sAudioDrivers[] = {
  92   {IDS_DRIVER_PULSE,     "pulse"},
  93   {IDS_DRIVER_ALSA,      "alsa"},
  94   {IDS_DRIVER_OSS,       "oss"},
  95   {IDS_DRIVER_COREAUDIO, "coreaudio"},
  96   {IDS_DRIVER_JACK,      "jack"},
  97 #if 0
  98   {IDS_DRIVER_NAS,       "nas"},
  99 #endif
 100   {IDS_DRIVER_ESOUND,    "esd"},
 101   {IDS_DRIVER_AUDIOIO,   "audioio"},
 102   {0, ""}
 103 };
 104
 105 /* list of available drivers */
 106 static AUDIO_DRIVER * loadedAudioDrv;
 107
 108 /* local copy of registry setting */
 109 static char curAudioDriver[1024];
 110
 111 /* driver index to configure */
 112 static int toConfigure;
 113
 114 /* display a driver specific configuration dialog */
 115 static void configureAudioDriver(HWND hDlg)
 116 {
 117     const AUDIO_DRIVER *pAudioDrv = &loadedAudioDrv[toConfigure];
 118
 119     if (strlen(pAudioDrv->szDriver) != 0)
 120     {
 121         HDRVR hdrvr;
 122         char wine_driver[MAX_NAME_LENGTH + 9];
 123         sprintf(wine_driver, "wine%s.drv", pAudioDrv->szDriver);
 124         hdrvr = OpenDriverA(wine_driver, 0, 0);
 125         if (hdrvr != 0)
 126         {
 127             if (SendDriverMessage(hdrvr, DRV_QUERYCONFIGURE, 0, 0) != 0)
 128             {
 129                 DRVCONFIGINFO dci;
 130                 LONG lRes;
 131                 dci.dwDCISize = sizeof (dci);
 132                 dci.lpszDCISectionName = NULL;
 133                 dci.lpszDCIAliasName = NULL;
 134                 lRes = SendDriverMessage(hdrvr, DRV_CONFIGURE, 0, (LONG_PTR)&dci);
 135             }
 136             CloseDriver(hdrvr, 0, 0);
 137         }
 138         else
 139         {
 140             WCHAR wine_driverW[MAX_NAME_LENGTH+9];
 141             WCHAR messageStr[256];
 142             WCHAR str[1024];
 143
 144             MultiByteToWideChar (CP_ACP, 0, wine_driver, -1, wine_driverW,
 145                 sizeof (wine_driverW)/sizeof(wine_driverW[0]));
 146
 147             LoadStringW (GetModuleHandle (NULL), IDS_OPEN_DRIVER_ERROR, messageStr,
 148                 sizeof(messageStr)/sizeof(messageStr[0]));
 149             wsprintfW (str, messageStr, wine_driverW);
 150             MessageBoxW (hDlg, str, NULL, MB_OK | MB_ICONERROR);
 151         }
 152     }
 153 }
 154
 155 /* is driver in local copy of driver registry string */
 156 static BOOL isDriverSet(const char * driver)
 157 {
 158     WINE_TRACE("driver = %s, curAudioDriver = %s\n", driver, curAudioDriver);
 159
 160     if (strstr(curAudioDriver, driver))
 161         return TRUE;
 162
 163     return FALSE;
 164 }
 165
 166 /* add driver to local copy of driver registry string */
 167 static void addDriver(const char * driver)
 168 {
 169     if (!isDriverSet(driver))
 170     {
 171         if (strlen(curAudioDriver))
 172             strcat(curAudioDriver, ",");
 173         strcat(curAudioDriver, driver);
 174     }
 175 }
 176
 177 /* remove driver from local copy of driver registry string */
 178 static void removeDriver(const char * driver)
 179 {
 180     char pattern[32], *p;
 181     int drvlen, listlen;
 182
 183     strcpy(pattern, ",");
 184     strcat(pattern, driver);
 185     strcat(pattern, ",");
 186     drvlen = strlen(driver);
 187     listlen = strlen(curAudioDriver);
 188
 189     p = strstr(curAudioDriver, pattern);
 190     if (p) /* somewhere in the middle */
 191         memmove(p, p+drvlen+1, strlen(p+drvlen+1)+1);
 192     else if (!strncmp(curAudioDriver, pattern+1, drvlen+1)) /* the head */
 193         memmove(curAudioDriver, curAudioDriver+drvlen+1, listlen-drvlen);
 194     else if (!strncmp(curAudioDriver+listlen-drvlen-1, pattern, drvlen+1)) /* the tail */
 195         curAudioDriver[listlen-drvlen-1] = 0;
 196     else if (!strcmp(curAudioDriver, driver)) /* only one entry (head&tail) */
 197         curAudioDriver[0] = 0;
 198     else
 199         WINE_FIXME("driver '%s' is not in the list, please report!\n", driver);
 200 }
 201
 202 static void initAudioDeviceTree(HWND hDlg)
 203 {
 204     const AUDIO_DRIVER *pAudioDrv = NULL;
 205     int i, j;
 206     TVINSERTSTRUCTW insert;
 207     HTREEITEM root, driver[10];
 208     HWND tree = NULL;
 209     HIMAGELIST hImageList;
 210     HBITMAP hBitMap;
 211     HCURSOR old_cursor;
 212     WCHAR driver_type[64], dev_type[64];
 213
 214     tree = GetDlgItem(hDlg, IDC_AUDIO_TREE);
 215
 216     if (!tree)
 217         return;
 218
 219     /* set tree view style */
 220     SetWindowLong(tree, GWL_STYLE, GetWindowLong(tree, GWL_STYLE) | TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT);
 221
 222     /* state checkbox */
 223     hImageList = ImageList_Create(16, 16, FALSE, 3, 0);
 224     hBitMap = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_CHECKBOX));
 225     ImageList_Add(hImageList, hBitMap, NULL);
 226     DeleteObject(hBitMap);
 227     SendMessageW( tree, TVM_SETIMAGELIST, TVSIL_STATE, (LPARAM)hImageList );
 228
 229     /* root item */
 230     LoadStringW (GetModuleHandle (NULL), IDS_SOUNDDRIVERS, driver_type,
 231         sizeof(driver_type)/sizeof(driver_type[0]));
 232     insert.hParent = TVI_ROOT;
 233     insert.hInsertAfter = TVI_LAST;
 234     insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 235     insert.u.item.pszText = driver_type;
 236     insert.u.item.cChildren = 1;
 237     root = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 238
 239     /* change to the wait cursor because this can take a while if there is a
 240      * misbehaving driver that takes a long time to open
 241      */
 242     old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));
 243
 244     /* iterate over list of loaded drivers */
 245     for (pAudioDrv = loadedAudioDrv, i = 0; pAudioDrv->nameID; i++, pAudioDrv++) {
 246         HDRVR hdrv;
 247         char name[MAX_PATH];
 248         WCHAR text[MAX_PATH];
 249
 250         sprintf(name, "wine%s.drv", pAudioDrv->szDriver);
 251         LoadStringW (GetModuleHandle (NULL), pAudioDrv->nameID, text,
 252             sizeof(text)/sizeof(text[0]));
 253
 254         if ((hdrv = OpenDriverA(name, 0, 0)))
 255         {
 256             HMODULE lib;
 257             if ((lib = GetDriverModuleHandle(hdrv)))
 258             {
 259                 int num_wod = 0, num_wid = 0, num_mod = 0, num_mid = 0, num_aux = 0, num_mxd = 0;
 260                 MessagePtr wodMessagePtr = (MessagePtr)GetProcAddress(lib, "wodMessage");
 261                 MessagePtr widMessagePtr = (MessagePtr)GetProcAddress(lib, "widMessage");
 262                 MessagePtr modMessagePtr = (MessagePtr)GetProcAddress(lib, "modMessage");
 263                 MessagePtr midMessagePtr = (MessagePtr)GetProcAddress(lib, "midMessage");
 264                 MessagePtr auxMessagePtr = (MessagePtr)GetProcAddress(lib, "auxMessage");
 265                 MessagePtr mxdMessagePtr = (MessagePtr)GetProcAddress(lib, "mxdMessage");
 266
 267                 if (wodMessagePtr)
 268                     num_wod = wodMessagePtr(0, WODM_GETNUMDEVS, 0, 0, 0);
 269
 270                 if (widMessagePtr)
 271                     num_wid = widMessagePtr(0, WIDM_GETNUMDEVS, 0, 0, 0);
 272
 273                 if (modMessagePtr)
 274                     num_mod = modMessagePtr(0, MODM_GETNUMDEVS, 0, 0, 0);
 275
 276                 if (midMessagePtr)
 277                     num_mid = midMessagePtr(0, MIDM_GETNUMDEVS, 0, 0, 0);
 278
 279                 if (auxMessagePtr)
 280                     num_aux = auxMessagePtr(0, AUXDM_GETNUMDEVS, 0, 0, 0);
 281
 282                 if (mxdMessagePtr)
 283                     num_mxd = mxdMessagePtr(0, MXDM_GETNUMDEVS, 0, 0, 0);
 284
 285                 if (num_wod == 0 && num_wid == 0 && num_mod == 0 && num_mid == 0 && num_aux == 0 && num_mxd == 0)
 286                 {
 287                     insert.hParent = root;
 288                     insert.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM;
 289                     insert.u.item.pszText = text;
 290                     insert.u.item.stateMask = TVIS_STATEIMAGEMASK;
 291                     insert.u.item.lParam =  i + DRIVER_MASK;
 292                     if (isDriverSet(pAudioDrv->szDriver))
 293                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(2);
 294                     else
 295                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(1);
 296
 297                     driver[i] = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 298                 }
 299                 else
 300                 {
 301                     HTREEITEM type;
 302
 303                     insert.hParent = root;
 304                     insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN | TVIF_STATE | TVIF_PARAM;
 305                     insert.u.item.pszText = text;
 306                     insert.u.item.cChildren = 1;
 307                     insert.u.item.stateMask = TVIS_STATEIMAGEMASK;
 308                     insert.u.item.lParam =  i + DRIVER_MASK;
 309
 310                     if (isDriverSet(pAudioDrv->szDriver))
 311                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(2);
 312                     else
 313                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(1);
 314
 315                     driver[i] = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 316
 317                     if (num_wod)
 318                     {
 319                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_WAVEOUT, dev_type,
 320                             sizeof(dev_type)/sizeof(dev_type[0]));
 321
 322                         insert.hParent = driver[i];
 323                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 324                         insert.u.item.pszText = dev_type;
 325                         insert.u.item.cChildren = 1;
 326
 327                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 328
 329                         for (j = 0; j < num_wod; j++)
 330                         {
 331                             WAVEOUTCAPSW caps;
 332
 333                             wodMessagePtr(j, WODM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 334
 335                             insert.hParent = type;
 336                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 337                             insert.u.item.pszText = caps.szPname;
 338                             insert.u.item.lParam = j + DEVICE_MASK;
 339
 340                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 341                         }
 342                     }
 343
 344                     if (num_wid)
 345                     {
 346                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_WAVEIN, dev_type,
 347                             sizeof(dev_type)/sizeof(dev_type[0]));
 348
 349                         insert.hParent = driver[i];
 350                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 351                         insert.u.item.pszText = dev_type;
 352                         insert.u.item.cChildren = 1;
 353
 354                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 355
 356                         for (j = 0; j < num_wid; j++)
 357                         {
 358                             WAVEINCAPSW caps;
 359
 360                             widMessagePtr(j, WIDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 361
 362                             insert.hParent = type;
 363                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 364                             insert.u.item.pszText = caps.szPname;
 365                             insert.u.item.lParam = j + DEVICE_MASK;
 366
 367                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 368                         }
 369                     }
 370
 371                     if (num_mod)
 372                     {
 373                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIDIOUT, dev_type,
 374                             sizeof(dev_type)/sizeof(dev_type[0]));
 375
 376                         insert.hParent = driver[i];
 377                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 378                         insert.u.item.pszText = dev_type;
 379                         insert.u.item.cChildren = 1;
 380
 381                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 382
 383                         for (j = 0; j < num_mod; j++)
 384                         {
 385                             MIDIOUTCAPSW caps;
 386
 387                             modMessagePtr(j, MODM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 388
 389                             insert.hParent = type;
 390                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 391                             insert.u.item.pszText = caps.szPname;
 392                             insert.u.item.lParam = j + DEVICE_MASK;
 393
 394                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 395                         }
 396                     }
 397
 398                     if (num_mid)
 399                     {
 400                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIDIIN, dev_type,
 401                             sizeof(dev_type)/sizeof(dev_type[0]));
 402
 403                         insert.hParent = driver[i];
 404                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 405                         insert.u.item.pszText = dev_type;
 406                         insert.u.item.cChildren = 1;
 407
 408                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 409
 410                         for (j = 0; j < num_mid; j++)
 411                         {
 412                             MIDIINCAPSW caps;
 413
 414                             midMessagePtr(j, MIDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 415
 416                             insert.hParent = type;
 417                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 418                             insert.u.item.pszText = caps.szPname;
 419                             insert.u.item.lParam = j + DEVICE_MASK;
 420
 421                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 422                         }
 423                     }
 424
 425                     if (num_aux)
 426                     {
 427                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_AUX, dev_type,
 428                             sizeof(dev_type)/sizeof(dev_type[0]));
 429
 430                         insert.hParent = driver[i];
 431                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 432                         insert.u.item.pszText = dev_type;
 433                         insert.u.item.cChildren = 1;
 434
 435                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 436
 437                         for (j = 0; j < num_aux; j++)
 438                         {
 439                             AUXCAPSW caps;
 440
 441                             auxMessagePtr(j, AUXDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 442
 443                             insert.hParent = type;
 444                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 445                             insert.u.item.pszText = caps.szPname;
 446                             insert.u.item.lParam = j + DEVICE_MASK;
 447
 448                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 449                         }
 450                     }
 451
 452                     if (num_mxd)
 453                     {
 454                         LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIXER, dev_type,
 455                             sizeof(dev_type)/sizeof(dev_type[0]));
 456
 457                         insert.hParent = driver[i];
 458                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 459                         insert.u.item.pszText = dev_type;
 460                         insert.u.item.cChildren = 1;
 461
 462                         type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 463
 464                         for (j = 0; j < num_mxd; j++)
 465                         {
 466                             MIXERCAPSW caps;
 467
 468                             mxdMessagePtr(j, MXDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps));
 469
 470                             insert.hParent = type;
 471                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 472                             insert.u.item.pszText = caps.szPname;
 473                             insert.u.item.lParam = j + DEVICE_MASK;
 474
 475                             SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert);
 476                         }
 477                     }
 478                 }
 479             }
 480             CloseDriver(hdrv, 0, 0);
 481         }
 482     }
 483
 484     /* restore the original cursor */
 485     SetCursor(old_cursor);
 486
 487     SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_SELECTITEM, 0, 0);
 488     SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_EXPAND, TVE_EXPAND, (LPARAM)root);
 489     for (j = 0; j < i; j++)
 490         SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_EXPAND, TVE_EXPAND, (LPARAM)driver[j]);
 491 }
 492
 493 /* find all drivers that can be loaded */
 494 static void findAudioDrivers(void)
 495 {
 496     int numFound = 0;
 497     const AUDIO_DRIVER *pAudioDrv = NULL;
 498     HCURSOR old_cursor;
 499
 500     /* delete an existing list */
 501     HeapFree(GetProcessHeap(), 0, loadedAudioDrv);
 502     loadedAudioDrv = 0;
 503
 504     /* change to the wait cursor because this can take a while if there is a
 505      * misbehaving driver that takes a long time to open
 506      */
 507     old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));
 508
 509     for (pAudioDrv = sAudioDrivers; pAudioDrv->nameID; pAudioDrv++)
 510     {
 511         if (strlen(pAudioDrv->szDriver))
 512         {
 513             HDRVR hdrv;
 514             char driver[MAX_PATH];
 515
 516             sprintf(driver, "wine%s.drv", pAudioDrv->szDriver);
 517
 518             if ((hdrv = OpenDriverA(driver, 0, 0)))
 519             {
 520                 CloseDriver(hdrv, 0, 0);
 521
 522                 if (loadedAudioDrv)
 523                     loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));
 524                 else
 525                     loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));
 526
 527                 CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));
 528                 numFound++;
 529             }
 530         }
 531     }
 532
 533     /* restore the original cursor */
 534     SetCursor(old_cursor);
 535
 536     /* terminate list with empty driver */
 537     if (numFound) {
 538         loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));
 539         CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));
 540     } else {
 541         loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));
 542         CopyMemory(&loadedAudioDrv[0], pAudioDrv, sizeof(AUDIO_DRIVER));
 543     }
 544 }
 545
 546 /* check local copy of registry string for unloadable drivers */
 547 static void checkRegistrySetting(HWND hDlg)
 548 {
 549     const AUDIO_DRIVER *pAudioDrv;
 550     char * token, * tokens;
 551
 552     tokens = HeapAlloc(GetProcessHeap(), 0, strlen(curAudioDriver)+1);
 553     strcpy(tokens, curAudioDriver);
 554
 555 start_over:
 556     token = strtok(tokens, ",");
 557     while (token != NULL)
 558     {
 559         BOOL found = FALSE;
 560         for (pAudioDrv = loadedAudioDrv; pAudioDrv->nameID; pAudioDrv++)
 561         {
 562             if (strcmp(token, pAudioDrv->szDriver) == 0)
 563             {
 564                 found = TRUE;
 565                 break;
 566             }
 567         }
 568         if (found == FALSE)
 569         {
 570             WCHAR tokenW[MAX_NAME_LENGTH+1];
 571             WCHAR messageStr[256];
 572             WCHAR str[1024];
 573             WCHAR caption[64];
 574
 575             MultiByteToWideChar (CP_ACP, 0, token, -1, tokenW, sizeof(tokenW)/sizeof(tokenW[0]));
 576
 577             LoadStringW (GetModuleHandle (NULL), IDS_UNAVAILABLE_DRIVER, messageStr,
 578                 sizeof(messageStr)/sizeof(messageStr[0]));
 579             wsprintfW (str, messageStr, tokenW);
 580             LoadStringW (GetModuleHandle (NULL), IDS_WARNING, caption,
 581                 sizeof(caption)/sizeof(caption[0]));
 582             if (MessageBoxW (hDlg, str, caption, MB_ICONWARNING | MB_YESNOCANCEL) == IDYES)
 583             {
 584                 removeDriver(token);
 585                 strcpy(tokens, curAudioDriver);
 586                 goto start_over;
 587             }
 588         }
 589         token = strtok(NULL, ",");
 590     }
 591     HeapFree(GetProcessHeap(), 0, tokens);
 592 }
 593
 594 static void selectDriver(HWND hDlg, const char * driver)
 595 {
 596     WCHAR text[1024];
 597     WCHAR caption[64];
 598
 599     strcpy(curAudioDriver, driver);
 600     set_reg_key(config_key, "Drivers", "Audio", curAudioDriver);
 601
 602     if (LoadStringW(GetModuleHandle(NULL), IDS_AUDIO_MISSING, text, sizeof(text)/sizeof(text[0])))
 603     {
 604         if (LoadStringW(GetModuleHandle(NULL), IDS_WINECFG_TITLE, caption, sizeof(caption)/sizeof(caption[0])))
 605             MessageBoxW(hDlg, text, caption, MB_OK | MB_ICONINFORMATION);
 606     }
 607
 608     SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 609 }
 610
 611 static void initAudioDlg (HWND hDlg)
 612 {
 613     int i, j, found;
 614     char* buf = NULL;
 615
 616     WINE_TRACE("\n");
 617
 618     /* make a list of all drivers that can be loaded */
 619     findAudioDrivers();
 620
 621     /* get current registry setting if available */
 622     buf = get_reg_key(config_key, "Drivers", "Audio", NULL);
 623
 624     /* check for first time install and set a default driver
 625      * select first available driver, and if that fails: none
 626      */
 627     if (buf == NULL)
 628     {
 629         /* select first available driver */
 630         if (*loadedAudioDrv->szDriver)
 631             selectDriver(hDlg, loadedAudioDrv->szDriver);
 632     }
 633     else /* make a local copy of the current registry setting */
 634         strcpy(curAudioDriver, buf);
 635
 636     WINE_TRACE("curAudioDriver = %s\n", curAudioDriver);
 637
 638     /* check for drivers that can't be loaded */
 639     checkRegistrySetting(hDlg);
 640
 641     initAudioDeviceTree(hDlg);
 642
 643     SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_RESETCONTENT, 0, 0);
 644     buf = get_reg_key(config_key, keypath("DirectSound"), "HardwareAcceleration", "Full");
 645
 646     j = found = 0;
 647     for (i = 0; 0 != DSound_HW_Accels[i].displayID; ++i) {
 648       WCHAR accelStr[64];
 649       int match;
 650
 651       match = (strcmp(buf, DSound_HW_Accels[i].settingStr) == 0);
 652       if (match)
 653       {
 654         DSound_HW_Accels[i].visible = 1;
 655         found = 1;
 656       }
 657
 658       if (DSound_HW_Accels[i].visible)
 659       {
 660         LoadStringW (GetModuleHandle (NULL), DSound_HW_Accels[i].displayID,
 661                      accelStr, sizeof(accelStr)/sizeof(accelStr[0]));
 662         SendDlgItemMessageW (hDlg, IDC_DSOUND_HW_ACCEL, CB_ADDSTRING, 0, (LPARAM)accelStr);
 663         if (match)
 664           SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_SETCURSEL, j, 0);
 665         j++;
 666       }
 667     }
 668     if (!found) {
 669       WINE_ERR("Invalid Direct Sound HW Accel read from registry (%s)\n", buf);
 670     }
 671     HeapFree(GetProcessHeap(), 0, buf);
 672
 673     SendDlgItemMessage(hDlg, IDC_DSOUND_RATES, CB_RESETCONTENT, 0, 0);
 674     for (i = 0; NULL != DSound_Rates[i]; ++i) {
 675       SendDlgItemMessage(hDlg, IDC_DSOUND_RATES, CB_ADDSTRING, 0, (LPARAM) DSound_Rates[i]);
 676     }
 677     buf = get_reg_key(config_key, keypath("DirectSound"), "DefaultSampleRate", "44100");
 678     for (i = 0; NULL != DSound_Rates[i]; ++i) {
 679       if (strcmp(buf, DSound_Rates[i]) == 0) {
 680         SendDlgItemMessage(hDlg, IDC_DSOUND_RATES, CB_SETCURSEL, i, 0);
 681         break ;
 682       }
 683     }
 684
 685     SendDlgItemMessage(hDlg, IDC_DSOUND_BITS, CB_RESETCONTENT, 0, 0);
 686     for (i = 0; NULL != DSound_Bits[i]; ++i) {
 687       SendDlgItemMessage(hDlg, IDC_DSOUND_BITS, CB_ADDSTRING, 0, (LPARAM) DSound_Bits[i]);
 688     }
 689     buf = get_reg_key(config_key, keypath("DirectSound"), "DefaultBitsPerSample", "16");
 690     for (i = 0; NULL != DSound_Bits[i]; ++i) {
 691       if (strcmp(buf, DSound_Bits[i]) == 0) {
 692         SendDlgItemMessage(hDlg, IDC_DSOUND_BITS, CB_SETCURSEL, i, 0);
 693         break ;
 694       }
 695     }
 696     HeapFree(GetProcessHeap(), 0, buf);
 697 }
 698
 699 INT_PTR CALLBACK
 700 AudioDlgProc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 701 {
 702   switch (uMsg) {
 703       case WM_COMMAND:
 704         switch (LOWORD(wParam)) {
 705           case IDC_AUDIO_CONFIGURE:
 706              configureAudioDriver(hDlg);
 707              break;
 708           case IDC_AUDIO_TEST:
 709              if(!PlaySound(MAKEINTRESOURCE(IDW_TESTSOUND), NULL, SND_RESOURCE | SND_SYNC))
 710                 MessageBox(NULL, "Audio test failed!", "Error", MB_OK | MB_ICONERROR);
 711              break;
 712           case IDC_AUDIO_CONTROL_PANEL:
 713              MessageBox(NULL, "Launching audio control panel not implemented yet!", "Fixme", MB_OK | MB_ICONERROR);
 714              break;
 715           case IDC_DSOUND_HW_ACCEL:
 716             if (HIWORD(wParam) == CBN_SELCHANGE) {
 717               int selected_dsound_accel;
 718               int i, j = 0;
 719
 720               SendMessage(GetParent(hDlg), PSM_CHANGED, 0, 0);
 721               selected_dsound_accel = SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_GETCURSEL, 0, 0);
 722               for (i = 0; DSound_HW_Accels[i].settingStr; ++i)
 723               {
 724                 if (DSound_HW_Accels[i].visible)
 725                 {
 726                   if (j == selected_dsound_accel)
 727                   {
 728                     set_reg_key(config_key, keypath("DirectSound"), "HardwareAcceleration",
 729                       DSound_HW_Accels[i].settingStr);
 730                     break;
 731                   }
 732                   j++;
 733                 }
 734               }
 735             }
 736             break;
 737           case IDC_DSOUND_RATES:
 738             if (HIWORD(wParam) == CBN_SELCHANGE) {
 739               int selected_dsound_rate;
 740               SendMessage(GetParent(hDlg), PSM_CHANGED, 0, 0);
 741               selected_dsound_rate = SendDlgItemMessage(hDlg, IDC_DSOUND_RATES, CB_GETCURSEL, 0, 0);
 742               set_reg_key(config_key, keypath("DirectSound"), "DefaultSampleRate", DSound_Rates[selected_dsound_rate]);
 743             }
 744             break;
 745           case IDC_DSOUND_BITS:
 746             if (HIWORD(wParam) == CBN_SELCHANGE) {
 747               int selected_dsound_bits;
 748               SendMessage(GetParent(hDlg), PSM_CHANGED, 0, 0);
 749               selected_dsound_bits = SendDlgItemMessage(hDlg, IDC_DSOUND_BITS, CB_GETCURSEL, 0, 0);
 750               set_reg_key(config_key, keypath("DirectSound"), "DefaultBitsPerSample", DSound_Bits[selected_dsound_bits]);
 751             }
 752             break;
 753         }
 754         break;
 755
 756       case WM_SHOWWINDOW:
 757         set_window_title(hDlg);
 758         break;
 759
 760       case WM_NOTIFY:
 761         switch(((LPNMHDR)lParam)->code) {
 762             case PSN_KILLACTIVE:
 763               SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE);
 764               break;
 765             case PSN_APPLY:
 766               set_reg_key(config_key, "Drivers", "Audio", curAudioDriver);
 767               apply();
 768               SetWindowLongPtr(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
 769               break;
 770             case PSN_SETACTIVE:
 771               break;
 772             case NM_CLICK:
 773               if (((LPNMHDR)lParam)->idFrom == IDC_AUDIO_TREE)
 774               {
 775                   TVHITTESTINFO ht;
 776                   DWORD dwPos = GetMessagePos();
 777                   HWND tree = ((LPNMHDR)lParam)->hwndFrom;
 778                   ZeroMemory(&ht, sizeof(ht));
 779                   ht.pt.x = (short)LOWORD(dwPos);
 780                   ht.pt.y = (short)HIWORD(dwPos);
 781                   MapWindowPoints(HWND_DESKTOP, tree, &ht.pt, 1);
 782                   SendMessageW( tree, TVM_HITTEST, 0, (LPARAM)&ht );
 783                   if (TVHT_ONITEMSTATEICON & ht.flags)
 784                   {
 785                       TVITEM tvItem;
 786                       int index;
 787                       ZeroMemory(&tvItem, sizeof(tvItem));
 788                       tvItem.hItem = ht.hItem;
 789                       SendMessageW( tree, TVM_GETITEMW, 0, (LPARAM) &tvItem );
 790
 791                       index = TreeView_GetItemState(tree, ht.hItem, TVIS_STATEIMAGEMASK);
 792                       if (index == INDEXTOSTATEIMAGEMASK(1))
 793                       {
 794                           TreeView_SetItemState(tree, ht.hItem, INDEXTOSTATEIMAGEMASK(2), TVIS_STATEIMAGEMASK);
 795                           addDriver(loadedAudioDrv[tvItem.lParam & 0xff].szDriver);
 796                           SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 797                       }
 798                       else if (index == INDEXTOSTATEIMAGEMASK(2))
 799                       {
 800                           TreeView_SetItemState(tree, ht.hItem, INDEXTOSTATEIMAGEMASK(1), TVIS_STATEIMAGEMASK);
 801                           removeDriver(loadedAudioDrv[tvItem.lParam & 0xff].szDriver);
 802                           SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 803                       }
 804                   }
 805               }
 806               break;
 807             case NM_RCLICK:
 808               if (((LPNMHDR)lParam)->idFrom == IDC_AUDIO_TREE)
 809               {
 810                   TVHITTESTINFO ht;
 811                   DWORD dwPos = GetMessagePos();
 812                   HWND tree = ((LPNMHDR)lParam)->hwndFrom;
 813                   POINT pt;
 814                   ZeroMemory(&ht, sizeof(ht));
 815                   pt.x = (short)LOWORD(dwPos);
 816                   pt.y = (short)HIWORD(dwPos);
 817                   ht.pt = pt;
 818                   MapWindowPoints(HWND_DESKTOP, tree, &ht.pt, 1);
 819                   SendMessageW( tree, TVM_HITTEST, 0, (LPARAM)&ht );
 820                   if (TVHT_ONITEMLABEL & ht.flags)
 821                   {
 822                       TVITEM tvItem;
 823                       ZeroMemory(&tvItem, sizeof(tvItem));
 824                       tvItem.hItem = ht.hItem;
 825                       tvItem.mask = TVIF_PARAM;
 826                       tvItem.lParam = -1;
 827                       if (TreeView_GetItem(tree, &tvItem))
 828                       {
 829                           if (tvItem.lParam & DRIVER_MASK)
 830                           {
 831                               if (hPopupMenus)
 832                               {
 833                                   TrackPopupMenu(GetSubMenu(hPopupMenus, 0), TPM_RIGHTBUTTON, pt.x, pt.y, 0, tree, NULL);
 834                                   toConfigure = tvItem.lParam & ~DRIVER_MASK;
 835                               }
 836                           }
 837                           else if (tvItem.lParam & DEVICE_MASK)
 838                           {
 839                               /* FIXME TBD */
 840                           }
 841
 842                       }
 843                   }
 844               }
 845         }
 846         break;
 847
 848   case WM_INITDIALOG:
 849     initAudioDlg(hDlg);
 850     break;
 851   }
 852
 853   return FALSE;
 854 }