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