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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 <windowsx.h>
  42 #include <mmsystem.h>
  43 #include <mmreg.h>
  44 #include <mmddk.h>
  45
  46 #include "winecfg.h"
  47 #include "resource.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
  50
  51 #define DRIVER_MASK 0x80000000
  52 #define DEVICE_MASK 0x40000000
  53
  54 typedef DWORD (WINAPI * MessagePtr)(UINT, UINT, DWORD, DWORD, DWORD);
  55
  56 static const char* DSound_HW_Accels[] = {
  57   "Full",
  58   "Standard",
  59   "Basic",
  60   "Emulation",
  61   NULL
  62 };
  63
  64 static const AUDIO_DRIVER sAudioDrivers[] = {
  65   {"ALSA", "alsa"},
  66   {"aRts", "arts"},
  67   {"EsounD", "esd"},
  68   {"OSS", "oss"},
  69   {"JACK", "jack"},
  70   {"NAS", "nas"},
  71   {"Audio IO(Solaris)", "audioio"},
  72   {"Disable sound", ""},
  73   {"", ""}
  74 };
  75
  76 /* list of available drivers */
  77 static AUDIO_DRIVER * loadedAudioDrv;
  78
  79 /* local copy of registry setting */
  80 static char curAudioDriver[1024];
  81
  82 /* driver index to configure */
  83 static int toConfigure;
  84
  85 /* display a driver specific configuration dialog */
  86 static void configureAudioDriver(HWND hDlg)
  87 {
  88     const AUDIO_DRIVER *pAudioDrv = &loadedAudioDrv[toConfigure];
  89
  90     if (strlen(pAudioDrv->szDriver) != 0)
  91     {
  92         HDRVR hdrvr;
  93         char wine_driver[MAX_NAME_LENGTH + 8];
  94         sprintf(wine_driver, "wine%s.drv", pAudioDrv->szDriver);
  95         hdrvr = OpenDriverA(wine_driver, 0, 0);
  96         if (hdrvr != 0)
  97         {
  98             if (SendDriverMessage(hdrvr, DRV_QUERYCONFIGURE, 0, 0) != 0)
  99             {
 100                 DRVCONFIGINFO dci;
 101                 LONG lRes;
 102                 dci.dwDCISize = sizeof (dci);
 103                 dci.lpszDCISectionName = NULL;
 104                 dci.lpszDCIAliasName = NULL;
 105                 lRes = SendDriverMessage(hdrvr, DRV_CONFIGURE, 0, (LONG)&dci);
 106             }
 107             CloseDriver(hdrvr, 0, 0);
 108         }
 109         else
 110         {
 111             char str[1024];
 112             sprintf(str, "Couldn't open %s!", wine_driver);
 113             MessageBox(hDlg, str, "Fixme", MB_OK | MB_ICONERROR);
 114         }
 115     }
 116 }
 117
 118 /* is driver in local copy of driver registry string */
 119 static BOOL isDriverSet(const char * driver)
 120 {
 121     WINE_TRACE("driver = %s, curAudioDriver = %s\n", driver, curAudioDriver);
 122
 123     if (strstr(curAudioDriver, driver))
 124         return TRUE;
 125
 126     return FALSE;
 127 }
 128
 129 /* add driver to local copy of driver registry string */
 130 static void addDriver(const char * driver)
 131 {
 132     if (!isDriverSet(driver))
 133     {
 134         if (strlen(curAudioDriver))
 135             strcat(curAudioDriver, ",");
 136         strcat(curAudioDriver, driver);
 137     }
 138 }
 139
 140 /* remove driver from local copy of driver registry string */
 141 static void removeDriver(const char * driver)
 142 {
 143     char before[32], after[32], * start;
 144
 145     strcpy(before, ",");
 146     strcat(before, driver);
 147     strcpy(after, driver);
 148     strcat(after, ",");
 149
 150     if ((start = strstr(curAudioDriver, after)))
 151     {
 152         int len = strlen(after);
 153         char * end = curAudioDriver + strlen(curAudioDriver);
 154         int i, count = end - start + len;
 155         for (i = 0; i < count; i++)
 156         {
 157             if (start + len >= end)
 158                 *start = 0;
 159             else
 160                 *start = start[len];
 161             start++;
 162         }
 163     }
 164     else if ((start = strstr(curAudioDriver, before)))
 165     {
 166         int len = strlen(before);
 167         char * end = curAudioDriver + strlen(curAudioDriver);
 168         int i, count = end - start + len;
 169         for (i = 0; i < count; i++)
 170         {
 171             if (start + len >= end)
 172                 *start = 0;
 173             else
 174                 *start = start[len];
 175             start++;
 176         }
 177     }
 178     else if (strcmp(curAudioDriver, driver) == 0)
 179     {
 180         strcpy(curAudioDriver, "");
 181     }
 182 }
 183
 184 static void initAudioDeviceTree(HWND hDlg)
 185 {
 186     const AUDIO_DRIVER *pAudioDrv = NULL;
 187     int i, j;
 188     TVINSERTSTRUCT insert;
 189     HTREEITEM root, driver[10];
 190     HWND tree = NULL;
 191     HIMAGELIST hImageList;
 192     HBITMAP hBitMap;
 193     HCURSOR old_cursor;
 194
 195     tree = GetDlgItem(hDlg, IDC_AUDIO_TREE);
 196
 197     if (!tree)
 198         return;
 199
 200     /* set tree view style */
 201     SetWindowLong(tree, GWL_STYLE, GetWindowLong(tree, GWL_STYLE) | TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT);
 202
 203     /* state checkbox */
 204     hImageList = ImageList_Create(16, 16, FALSE, 3, 0);
 205     hBitMap = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_CHECKBOX));
 206     ImageList_Add(hImageList, hBitMap, NULL);
 207     DeleteObject(hBitMap);
 208     SendMessageW( tree, TVM_SETIMAGELIST, TVSIL_STATE, (LPARAM)hImageList );
 209
 210     /* root item */
 211     insert.hParent = TVI_ROOT;
 212     insert.hInsertAfter = TVI_LAST;
 213     insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 214     insert.u.item.pszText = "Sound Drivers";
 215     insert.u.item.cChildren = 1;
 216     root = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 217
 218     /* change to the wait cursor because this can take a while if there is a
 219      * misbehaving driver that takes a long time to open
 220      */
 221     old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));
 222
 223     /* iterate over list of loaded drivers */
 224     for (pAudioDrv = loadedAudioDrv, i = 0; *pAudioDrv->szName; i++, pAudioDrv++) {
 225         HDRVR hdrv;
 226         char name[MAX_PATH];
 227         char text[MAX_PATH];
 228
 229         sprintf(name, "wine%s.drv", pAudioDrv->szDriver);
 230         sprintf(text, "%s Driver", pAudioDrv->szName);
 231
 232         if ((hdrv = OpenDriverA(name, 0, 0)))
 233         {
 234             HMODULE lib;
 235             if ((lib = GetDriverModuleHandle(hdrv)))
 236             {
 237                 int num_wod = 0, num_wid = 0, num_mod = 0, num_mid = 0, num_aux = 0, num_mxd = 0;
 238                 MessagePtr wodMessagePtr = (MessagePtr)GetProcAddress(lib, "wodMessage");
 239                 MessagePtr widMessagePtr = (MessagePtr)GetProcAddress(lib, "widMessage");
 240                 MessagePtr modMessagePtr = (MessagePtr)GetProcAddress(lib, "modMessage");
 241                 MessagePtr midMessagePtr = (MessagePtr)GetProcAddress(lib, "midMessage");
 242                 MessagePtr auxMessagePtr = (MessagePtr)GetProcAddress(lib, "auxMessage");
 243                 MessagePtr mxdMessagePtr = (MessagePtr)GetProcAddress(lib, "mxdMessage");
 244
 245                 if (wodMessagePtr)
 246                     num_wod = wodMessagePtr(0, WODM_GETNUMDEVS, 0, 0, 0);
 247
 248                 if (widMessagePtr)
 249                     num_wid = widMessagePtr(0, WIDM_GETNUMDEVS, 0, 0, 0);
 250
 251                 if (modMessagePtr)
 252                     num_mod = modMessagePtr(0, MODM_GETNUMDEVS, 0, 0, 0);
 253
 254                 if (midMessagePtr)
 255                     num_mid = midMessagePtr(0, MIDM_GETNUMDEVS, 0, 0, 0);
 256
 257                 if (auxMessagePtr)
 258                     num_aux = auxMessagePtr(0, AUXDM_GETNUMDEVS, 0, 0, 0);
 259
 260                 if (mxdMessagePtr)
 261                     num_mxd = mxdMessagePtr(0, MXDM_GETNUMDEVS, 0, 0, 0);
 262
 263                 if (num_wod == 0 && num_wid == 0 && num_mod == 0 && num_mid == 0 && num_aux == 0 && num_mxd == 0)
 264                 {
 265                     insert.hParent = root;
 266                     insert.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM;
 267                     insert.u.item.pszText = text;
 268                     insert.u.item.stateMask = TVIS_STATEIMAGEMASK;
 269                     insert.u.item.lParam =  i + DRIVER_MASK;
 270
 271                     driver[i] = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 272                 }
 273                 else
 274                 {
 275                     HTREEITEM type;
 276
 277                     insert.hParent = root;
 278                     insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN | TVIF_STATE | TVIF_PARAM;
 279                     insert.u.item.pszText = text;
 280                     insert.u.item.cChildren = 1;
 281                     insert.u.item.stateMask = TVIS_STATEIMAGEMASK;
 282                     insert.u.item.lParam =  i + DRIVER_MASK;
 283
 284                     if (isDriverSet(pAudioDrv->szDriver))
 285                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(2);
 286                     else
 287                         insert.u.item.state = INDEXTOSTATEIMAGEMASK(1);
 288
 289                     driver[i] = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 290
 291                     if (num_wod)
 292                     {
 293                         insert.hParent = driver[i];
 294                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 295                         insert.u.item.pszText = "Wave Out Devices";
 296                         insert.u.item.cChildren = 1;
 297
 298                         type = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 299
 300                         for (j = 0; j < num_wod; j++)
 301                         {
 302                             WAVEOUTCAPSW caps;
 303                             char szPname[MAXPNAMELEN];
 304
 305                             wodMessagePtr(j, WODM_GETDEVCAPS, 0, (DWORD)&caps, sizeof(caps));
 306                             WideCharToMultiByte(CP_ACP, 0, caps.szPname, -1, szPname, MAXPNAMELEN, 0, 0);
 307
 308                             insert.hParent = type;
 309                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 310                             insert.u.item.pszText = szPname;
 311                             insert.u.item.lParam = j + DEVICE_MASK;
 312
 313                             SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 314                         }
 315                     }
 316
 317                     if (num_wid)
 318                     {
 319                         insert.hParent = driver[i];
 320                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 321                         insert.u.item.pszText = "Wave In Devices";
 322                         insert.u.item.cChildren = 1;
 323
 324                         type = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 325
 326                         for (j = 0; j < num_wid; j++)
 327                         {
 328                             WAVEINCAPSW caps;
 329                             char szPname[MAXPNAMELEN];
 330
 331                             widMessagePtr(j, WIDM_GETDEVCAPS, 0, (DWORD)&caps, sizeof(caps));
 332                             WideCharToMultiByte(CP_ACP, 0, caps.szPname, -1, szPname, MAXPNAMELEN, 0, 0);
 333
 334                             insert.hParent = type;
 335                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 336                             insert.u.item.pszText = szPname;
 337                             insert.u.item.lParam = j + DEVICE_MASK;
 338
 339                             SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 340                         }
 341                     }
 342
 343                     if (num_mod)
 344                     {
 345                         insert.hParent = driver[i];
 346                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 347                         insert.u.item.pszText = "MIDI Out Devices";
 348                         insert.u.item.cChildren = 1;
 349
 350                         type = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 351
 352                         for (j = 0; j < num_mod; j++)
 353                         {
 354                             MIDIOUTCAPSW caps;
 355                             char szPname[MAXPNAMELEN];
 356
 357                             modMessagePtr(j, MODM_GETDEVCAPS, 0, (DWORD)&caps, sizeof(caps));
 358                             WideCharToMultiByte(CP_ACP, 0, caps.szPname, -1, szPname, MAXPNAMELEN, 0, 0);
 359
 360                             insert.hParent = type;
 361                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 362                             insert.u.item.pszText = szPname;
 363                             insert.u.item.lParam = j + DEVICE_MASK;
 364
 365                             SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 366                         }
 367                     }
 368
 369                     if (num_mid)
 370                     {
 371                         insert.hParent = driver[i];
 372                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 373                         insert.u.item.pszText = "MIDI In Devices";
 374                         insert.u.item.cChildren = 1;
 375
 376                         type = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 377
 378                         for (j = 0; j < num_mid; j++)
 379                         {
 380                             MIDIINCAPSW caps;
 381                             char szPname[MAXPNAMELEN];
 382
 383                             midMessagePtr(j, MIDM_GETDEVCAPS, 0, (DWORD)&caps, sizeof(caps));
 384                             WideCharToMultiByte(CP_ACP, 0, caps.szPname, -1, szPname, MAXPNAMELEN, 0, 0);
 385
 386                             insert.hParent = type;
 387                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 388                             insert.u.item.pszText = szPname;
 389                             insert.u.item.lParam = j + DEVICE_MASK;
 390
 391                             SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 392                         }
 393                     }
 394
 395                     if (num_aux)
 396                     {
 397                         insert.hParent = driver[i];
 398                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 399                         insert.u.item.pszText = "Aux Devices";
 400                         insert.u.item.cChildren = 1;
 401
 402                         type = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 403
 404                         for (j = 0; j < num_aux; j++)
 405                         {
 406                             AUXCAPSW caps;
 407                             char szPname[MAXPNAMELEN];
 408
 409                             auxMessagePtr(j, AUXDM_GETDEVCAPS, 0, (DWORD)&caps, sizeof(caps));
 410                             WideCharToMultiByte(CP_ACP, 0, caps.szPname, -1, szPname, MAXPNAMELEN, 0, 0);
 411
 412                             insert.hParent = type;
 413                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 414                             insert.u.item.pszText = szPname;
 415                             insert.u.item.lParam = j + DEVICE_MASK;
 416
 417                             SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 418                         }
 419                     }
 420
 421                     if (num_mxd)
 422                     {
 423                         insert.hParent = driver[i];
 424                         insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN;
 425                         insert.u.item.pszText = "Mixer Devices";
 426                         insert.u.item.cChildren = 1;
 427
 428                         type = (HTREEITEM)SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 429
 430                         for (j = 0; j < num_mxd; j++)
 431                         {
 432                             MIXERCAPSW caps;
 433                             char szPname[MAXPNAMELEN];
 434
 435                             mxdMessagePtr(j, MXDM_GETDEVCAPS, 0, (DWORD)&caps, sizeof(caps));
 436                             WideCharToMultiByte(CP_ACP, 0, caps.szPname, -1, szPname, MAXPNAMELEN, 0, 0);
 437
 438                             insert.hParent = type;
 439                             insert.u.item.mask = TVIF_TEXT | TVIF_PARAM;
 440                             insert.u.item.pszText = szPname;
 441                             insert.u.item.lParam = j + DEVICE_MASK;
 442
 443                             SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_INSERTITEM, 0, (LPARAM)&insert);
 444                         }
 445                     }
 446                 }
 447             }
 448         }
 449     }
 450
 451     /* restore the original cursor */
 452     SetCursor(old_cursor);
 453
 454     SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_SELECTITEM, 0, 0);
 455     SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_EXPAND, TVE_EXPAND, (LPARAM)root);
 456     for (j = 0; j < i; j++)
 457         SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_EXPAND, TVE_EXPAND, (LPARAM)driver[j]);
 458 }
 459
 460 /* find all drivers that can be loaded */
 461 static void findAudioDrivers(void)
 462 {
 463     int numFound = 0;
 464     const AUDIO_DRIVER *pAudioDrv = NULL;
 465     HCURSOR old_cursor;
 466
 467     /* delete an existing list */
 468     if (loadedAudioDrv)
 469     {
 470         HeapFree(GetProcessHeap(), 0, loadedAudioDrv);
 471         loadedAudioDrv = 0;
 472     }
 473
 474     /* change to the wait cursor because this can take a while if there is a
 475      * misbehaving driver that takes a long time to open
 476      */
 477     old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));
 478
 479     for (pAudioDrv = sAudioDrivers; *pAudioDrv->szName; pAudioDrv++)
 480     {
 481         if (strlen(pAudioDrv->szDriver))
 482         {
 483             HDRVR hdrv;
 484             char driver[MAX_PATH];
 485
 486             sprintf(driver, "wine%s.drv", pAudioDrv->szDriver);
 487
 488             if ((hdrv = OpenDriverA(driver, 0, 0)))
 489             {
 490                 CloseDriver(hdrv, 0, 0);
 491
 492                 if (loadedAudioDrv)
 493                     loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));
 494                 else
 495                     loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));
 496
 497                 CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));
 498                 numFound++;
 499             }
 500         }
 501     }
 502
 503     /* restore the original cursor */
 504     SetCursor(old_cursor);
 505
 506     /* terminate list with empty driver */
 507     loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));
 508     CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));
 509 }
 510
 511 /* check local copy of registry string for unloadable drivers */
 512 static void checkRegistrySetting(HWND hDlg)
 513 {
 514     const AUDIO_DRIVER *pAudioDrv;
 515     char * token, * tokens = strdup(curAudioDriver);
 516
 517 start_over:
 518     token = strtok(tokens, ",");
 519     while (token != NULL)
 520     {
 521         BOOL found = FALSE;
 522         for (pAudioDrv = loadedAudioDrv; *pAudioDrv->szName; pAudioDrv++)
 523         {
 524             if (strcmp(token, pAudioDrv->szDriver) == 0)
 525             {
 526                 found = TRUE;
 527                 break;
 528             }
 529         }
 530         if (found == FALSE)
 531         {
 532             char str[1024];
 533             sprintf(str, "Found driver in registry that in not available!\n\nRemove \"%s\" from registry?", token);
 534             if (MessageBox(hDlg, str, "WARNING", MB_ICONWARNING | MB_YESNOCANCEL) == IDYES)
 535             {
 536                 removeDriver(token);
 537                 strcpy(tokens, curAudioDriver);
 538                 goto start_over;
 539             }
 540         }
 541         token = strtok(NULL, ",");
 542     }
 543     free(tokens);
 544 }
 545
 546 static void selectDriver(HWND hDlg, const char * driver)
 547 {
 548     WCHAR text[1024];
 549     WCHAR caption[64];
 550
 551     strcpy(curAudioDriver, driver);
 552     set_reg_key(config_key, "Drivers", "Audio", curAudioDriver);
 553
 554     if (LoadStringW(GetModuleHandle(NULL), IDS_AUDIO_MISSING, text, sizeof(text)/sizeof(text[0])))
 555     {
 556         if (LoadStringW(GetModuleHandle(NULL), IDS_WINECFG_TITLE, caption, sizeof(caption)/sizeof(caption[0])))
 557             MessageBoxW(hDlg, text, caption, MB_OK | MB_ICONINFORMATION);
 558     }
 559
 560     SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 561 }
 562
 563 static void initAudioDlg (HWND hDlg)
 564 {
 565     int i;
 566     char* buf = NULL;
 567
 568     WINE_TRACE("\n");
 569
 570     /* make a list of all drivers that can be loaded */
 571     findAudioDrivers();
 572
 573     /* get current registry setting if available */
 574     buf = get_reg_key(config_key, "Drivers", "Audio", NULL);
 575
 576     /* check for first time install and set a default driver
 577      * select in this order: oss, alsa, first available driver, none
 578      */
 579     if (buf == NULL)
 580     {
 581         const AUDIO_DRIVER *pAudioDrv = NULL;
 582
 583         /* select oss if available */
 584         for (pAudioDrv = loadedAudioDrv; *pAudioDrv->szName; pAudioDrv++)
 585         {
 586             if (strcmp(pAudioDrv->szDriver, "oss") == 0)
 587             {
 588                 selectDriver(hDlg, "oss");
 589                 break;
 590             }
 591         }
 592
 593         if (strlen(curAudioDriver) == 0)
 594         {
 595             /* select alsa if available */
 596             for (pAudioDrv = loadedAudioDrv; *pAudioDrv->szName; pAudioDrv++)
 597             {
 598                 if (strcmp(pAudioDrv->szDriver, "alsa") == 0)
 599                 {
 600                     selectDriver(hDlg, "alsa");
 601                     break;
 602                 }
 603             }
 604         }
 605
 606         if (strlen(curAudioDriver) == 0)
 607         {
 608             /* select first available driver */
 609             if (*loadedAudioDrv->szDriver)
 610                 selectDriver(hDlg, loadedAudioDrv->szDriver);
 611         }
 612     }
 613     else /* make a local copy of the current registry setting */
 614         strcpy(curAudioDriver, buf);
 615
 616     WINE_TRACE("curAudioDriver = %s\n", curAudioDriver);
 617
 618     /* check for drivers that can't be loaded */
 619     checkRegistrySetting(hDlg);
 620
 621     initAudioDeviceTree(hDlg);
 622
 623     SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_RESETCONTENT, 0, 0);
 624     for (i = 0; NULL != DSound_HW_Accels[i]; ++i) {
 625       SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_ADDSTRING, 0, (LPARAM) DSound_HW_Accels[i]);
 626     }
 627     buf = get_reg_key(config_key, keypath("DirectSound"), "HardwareAcceleration", "Full");
 628     for (i = 0; NULL != DSound_HW_Accels[i]; ++i) {
 629       if (strcmp(buf, DSound_HW_Accels[i]) == 0) {
 630         SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_SETCURSEL, i, 0);
 631         break ;
 632       }
 633     }
 634     if (NULL == DSound_HW_Accels[i]) {
 635       WINE_ERR("Invalid Direct Sound HW Accel read from registry (%s)\n", buf);
 636     }
 637     HeapFree(GetProcessHeap(), 0, buf);
 638
 639     buf = get_reg_key(config_key, keypath("DirectSound"), "EmulDriver", "N");
 640     if (IS_OPTION_TRUE(*buf))
 641       CheckDlgButton(hDlg, IDC_DSOUND_DRV_EMUL, BST_CHECKED);
 642     else
 643       CheckDlgButton(hDlg, IDC_DSOUND_DRV_EMUL, BST_UNCHECKED);
 644     HeapFree(GetProcessHeap(), 0, buf);
 645 }
 646
 647 INT_PTR CALLBACK
 648 AudioDlgProc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 649 {
 650   switch (uMsg) {
 651       case WM_COMMAND:
 652         switch (LOWORD(wParam)) {
 653           case IDC_AUDIO_CONFIGURE:
 654              configureAudioDriver(hDlg);
 655              break;
 656           case IDC_AUDIO_CONTROL_PANEL:
 657              MessageBox(NULL, "Launching audio control panel not implemented yet!", "Fixme", MB_OK | MB_ICONERROR);
 658              break;
 659           case IDC_DSOUND_HW_ACCEL:
 660             if (HIWORD(wParam) == CBN_SELCHANGE) {
 661               int selected_dsound_accel;
 662               SendMessage(GetParent(hDlg), PSM_CHANGED, 0, 0);
 663               selected_dsound_accel = SendDlgItemMessage(hDlg, IDC_DSOUND_HW_ACCEL, CB_GETCURSEL, 0, 0);
 664               set_reg_key(config_key, keypath("DirectSound"), "HardwareAcceleration", DSound_HW_Accels[selected_dsound_accel]);
 665             }
 666             break;
 667           case IDC_DSOUND_DRV_EMUL:
 668             if (HIWORD(wParam) == BN_CLICKED) {
 669               SendMessage(GetParent(hDlg), PSM_CHANGED, 0, 0);
 670               if (IsDlgButtonChecked(hDlg, IDC_DSOUND_DRV_EMUL) == BST_CHECKED)
 671                 set_reg_key(config_key, keypath("DirectSound"), "EmulDriver", "Y");
 672               else
 673                 set_reg_key(config_key, keypath("DirectSound"), "EmulDriver", "N");
 674             }
 675             break;
 676         }
 677         break;
 678
 679       case WM_SHOWWINDOW:
 680         set_window_title(hDlg);
 681         break;
 682
 683       case WM_NOTIFY:
 684         switch(((LPNMHDR)lParam)->code) {
 685             case PSN_KILLACTIVE:
 686               SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE);
 687               break;
 688             case PSN_APPLY:
 689               set_reg_key(config_key, "Drivers", "Audio", curAudioDriver);
 690               apply();
 691               SetWindowLongPtr(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
 692               break;
 693             case PSN_SETACTIVE:
 694               break;
 695             case NM_CLICK:
 696               if (((LPNMHDR)lParam)->idFrom == IDC_AUDIO_TREE)
 697               {
 698                   TVHITTESTINFO ht;
 699                   DWORD dwPos = GetMessagePos();
 700                   HWND tree = ((LPNMHDR)lParam)->hwndFrom;
 701                   ZeroMemory(&ht, sizeof(ht));
 702                   ht.pt.x = GET_X_LPARAM(dwPos);
 703                   ht.pt.y = GET_Y_LPARAM(dwPos);
 704                   MapWindowPoints(HWND_DESKTOP, tree, &ht.pt, 1);
 705                   SendMessageW( tree, TVM_HITTEST, 0, (LPARAM)&ht );
 706                   if (TVHT_ONITEMSTATEICON & ht.flags)
 707                   {
 708                       TVITEM tvItem;
 709                       int index;
 710                       ZeroMemory(&tvItem, sizeof(tvItem));
 711                       tvItem.hItem = ht.hItem;
 712                       SendMessageW( tree, TVM_GETITEMW, 0, (LPARAM) &tvItem );
 713
 714                       index = TreeView_GetItemState(tree, ht.hItem, TVIS_STATEIMAGEMASK);
 715                       if (index == INDEXTOSTATEIMAGEMASK(1))
 716                       {
 717                           TreeView_SetItemState(tree, ht.hItem, INDEXTOSTATEIMAGEMASK(2), TVIS_STATEIMAGEMASK);
 718                           addDriver(loadedAudioDrv[tvItem.lParam & 0xff].szDriver);
 719                           SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 720                       }
 721                       else if (index == INDEXTOSTATEIMAGEMASK(2))
 722                       {
 723                           TreeView_SetItemState(tree, ht.hItem, INDEXTOSTATEIMAGEMASK(1), TVIS_STATEIMAGEMASK);
 724                           removeDriver(loadedAudioDrv[tvItem.lParam & 0xff].szDriver);
 725                           SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0); /* enable apply button */
 726                       }
 727                   }
 728               }
 729               break;
 730             case NM_RCLICK:
 731               if (((LPNMHDR)lParam)->idFrom == IDC_AUDIO_TREE)
 732               {
 733                   TVHITTESTINFO ht;
 734                   DWORD dwPos = GetMessagePos();
 735                   HWND tree = ((LPNMHDR)lParam)->hwndFrom;
 736                   POINT pt;
 737                   ZeroMemory(&ht, sizeof(ht));
 738                   pt.x = GET_X_LPARAM(dwPos);
 739                   pt.y = GET_Y_LPARAM(dwPos);
 740                   ht.pt = pt;
 741                   MapWindowPoints(HWND_DESKTOP, tree, &ht.pt, 1);
 742                   SendMessageW( tree, TVM_HITTEST, 0, (LPARAM)&ht );
 743                   if (TVHT_ONITEMLABEL & ht.flags)
 744                   {
 745                       TVITEM tvItem;
 746                       ZeroMemory(&tvItem, sizeof(tvItem));
 747                       tvItem.hItem = ht.hItem;
 748                       tvItem.mask = TVIF_PARAM;
 749                       tvItem.lParam = -1;
 750                       if (TreeView_GetItem(tree, &tvItem))
 751                       {
 752                           if (tvItem.lParam & DRIVER_MASK)
 753                           {
 754                               if (hPopupMenus)
 755                               {
 756                                   TrackPopupMenu(GetSubMenu(hPopupMenus, 0), TPM_RIGHTBUTTON, pt.x, pt.y, 0, tree, NULL);
 757                                   toConfigure = tvItem.lParam & ~DRIVER_MASK;
 758                               }
 759                           }
 760                           else if (tvItem.lParam & DEVICE_MASK)
 761                           {
 762                               /* FIXME TBD */
 763                           }
 764
 765                       }
 766                   }
 767               }
 768         }
 769         break;
 770
 771   case WM_INITDIALOG:
 772     initAudioDlg(hDlg);
 773     break;
 774   }
 775
 776   return FALSE;
 777 }