dlls/oledb32/dslocator.c

   1 /* Data Links
   2  *
   3  * Copyright 2013 Alistair Leslie-Hughes
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #include <stdarg.h>
  20 #include <string.h>
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28 #include "oleauto.h"
  29 #include "winerror.h"
  30 #include "oledb.h"
  31 #include "oledberr.h"
  32 #include "msdasc.h"
  33 #include "prsht.h"
  34 #include "commctrl.h"
  35
  36 #include "oledb_private.h"
  37 #include "resource.h"
  38
  39 #include "wine/debug.h"
  40 #include "wine/heap.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  43
  44 struct datasource
  45 {
  46     CLSID clsid;
  47     IDBProperties *provider;
  48     DBPROPINFOSET *propinfoset;
  49     WCHAR *description;
  50 };
  51
  52 static struct datasource *create_datasource(WCHAR *guid)
  53 {
  54     struct datasource *data = heap_alloc_zero(sizeof(struct datasource));
  55     if (data)
  56     {
  57         CLSIDFromString(guid, &data->clsid);
  58     }
  59
  60     return data;
  61 }
  62
  63 static void destroy_datasource(struct datasource *data)
  64 {
  65     if (data->propinfoset)
  66     {
  67         ULONG i;
  68
  69         for (i = 0; i < data->propinfoset->cPropertyInfos; i++)
  70             VariantClear(&data->propinfoset->rgPropertyInfos[i].vValues);
  71
  72         CoTaskMemFree(data->propinfoset->rgPropertyInfos);
  73         CoTaskMemFree(data->propinfoset);
  74     }
  75     CoTaskMemFree(data->description);
  76
  77     if (data->provider)
  78         IDBProperties_Release(data->provider);
  79
  80     heap_free(data);
  81 }
  82
  83 static BOOL initialize_datasource(struct datasource *data)
  84 {
  85     HRESULT hr;
  86     DBPROPIDSET propidset;
  87     ULONG infocount;
  88
  89     hr = CoCreateInstance(&data->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IDBProperties, (void**)&data->provider);
  90     if (FAILED(hr))
  91     {
  92         WARN("Datasource cannot be created (0x%08x)\n", hr);
  93         return FALSE;
  94     }
  95
  96     propidset.rgPropertyIDs = NULL;
  97     propidset.cPropertyIDs  = 0;
  98     propidset.guidPropertySet = DBPROPSET_DBINITALL;
  99
 100     hr = IDBProperties_GetPropertyInfo(data->provider, 1, &propidset, &infocount, &data->propinfoset, &data->description);
 101     if (FAILED(hr))
 102     {
 103         WARN("Failed to get DB Properties (0x%08x)\n", hr);
 104
 105         IDBProperties_Release(data->provider);
 106         data->provider = NULL;
 107         return FALSE;
 108     }
 109
 110     return TRUE;
 111 }
 112
 113 typedef struct DSLocatorImpl
 114 {
 115     IDataSourceLocator IDataSourceLocator_iface;
 116     IDataInitialize IDataInitialize_iface;
 117     LONG ref;
 118
 119     HWND hwnd;
 120 } DSLocatorImpl;
 121
 122 static inline DSLocatorImpl *impl_from_IDataSourceLocator( IDataSourceLocator *iface )
 123 {
 124     return CONTAINING_RECORD(iface, DSLocatorImpl, IDataSourceLocator_iface);
 125 }
 126
 127 static inline DSLocatorImpl *impl_from_IDataInitialize(IDataInitialize *iface)
 128 {
 129     return CONTAINING_RECORD(iface, DSLocatorImpl, IDataInitialize_iface);
 130 }
 131
 132 static HRESULT WINAPI dslocator_QueryInterface(IDataSourceLocator *iface, REFIID riid, void **ppvoid)
 133 {
 134     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 135     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid),ppvoid);
 136
 137     *ppvoid = NULL;
 138
 139     if (IsEqualIID(riid, &IID_IUnknown) ||
 140         IsEqualIID(riid, &IID_IDispatch) ||
 141         IsEqualIID(riid, &IID_IDataSourceLocator))
 142     {
 143       *ppvoid = &This->IDataSourceLocator_iface;
 144     }
 145     else if (IsEqualIID(riid, &IID_IDataInitialize))
 146     {
 147       *ppvoid = &This->IDataInitialize_iface;
 148     }
 149     else if (IsEqualIID(riid, &IID_IRunnableObject))
 150     {
 151       TRACE("IID_IRunnableObject returning NULL\n");
 152       return E_NOINTERFACE;
 153     }
 154     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
 155     {
 156       TRACE("IID_IProvideClassInfo returning NULL\n");
 157       return E_NOINTERFACE;
 158     }
 159     else if (IsEqualIID(riid, &IID_IMarshal))
 160     {
 161       TRACE("IID_IMarshal returning NULL\n");
 162       return E_NOINTERFACE;
 163     }
 164     else if (IsEqualIID(riid, &IID_IRpcOptions))
 165     {
 166       TRACE("IID_IRpcOptions returning NULL\n");
 167       return E_NOINTERFACE;
 168     }
 169
 170     if(*ppvoid)
 171     {
 172       IUnknown_AddRef( (IUnknown*)*ppvoid );
 173       return S_OK;
 174     }
 175
 176     FIXME("interface %s not implemented\n", debugstr_guid(riid));
 177     return E_NOINTERFACE;
 178 }
 179
 180 static ULONG WINAPI dslocator_AddRef(IDataSourceLocator *iface)
 181 {
 182     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 183     TRACE("(%p)->%u\n",This,This->ref);
 184     return InterlockedIncrement(&This->ref);
 185 }
 186
 187 static ULONG WINAPI dslocator_Release(IDataSourceLocator *iface)
 188 {
 189     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 190     ULONG ref = InterlockedDecrement(&This->ref);
 191
 192     TRACE("(%p)->%u\n",This,ref+1);
 193
 194     if (!ref)
 195     {
 196         heap_free(This);
 197     }
 198
 199     return ref;
 200 }
 201
 202 static HRESULT WINAPI dslocator_GetTypeInfoCount(IDataSourceLocator *iface, UINT *pctinfo)
 203 {
 204     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 205
 206     FIXME("(%p)->()\n", This);
 207
 208     return E_NOTIMPL;
 209 }
 210
 211 static HRESULT WINAPI dslocator_GetTypeInfo(IDataSourceLocator *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 212 {
 213     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 214
 215     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 216
 217     return E_NOTIMPL;
 218 }
 219
 220 static HRESULT WINAPI dslocator_GetIDsOfNames(IDataSourceLocator *iface, REFIID riid, LPOLESTR *rgszNames,
 221     UINT cNames, LCID lcid, DISPID *rgDispId)
 222 {
 223     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 224
 225     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 226
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI dslocator_Invoke(IDataSourceLocator *iface, DISPID dispIdMember, REFIID riid,
 231     LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 232 {
 233     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 234
 235     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 236            lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 237
 238     return E_NOTIMPL;
 239 }
 240
 241 static HRESULT WINAPI dslocator_get_hWnd(IDataSourceLocator *iface, COMPATIBLE_LONG *phwndParent)
 242 {
 243     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 244
 245     TRACE("(%p)->(%p)\n",This, phwndParent);
 246
 247     *phwndParent = (COMPATIBLE_LONG)This->hwnd;
 248
 249     return S_OK;
 250 }
 251
 252 static HRESULT WINAPI dslocator_put_hWnd(IDataSourceLocator *iface, COMPATIBLE_LONG hwndParent)
 253 {
 254     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 255
 256     TRACE("(%p)->(%p)\n",This, (HWND)hwndParent);
 257
 258     This->hwnd = (HWND)hwndParent;
 259
 260     return S_OK;
 261 }
 262
 263 static void create_connections_columns(HWND lv)
 264 {
 265     RECT rc;
 266     WCHAR buf[256];
 267     LVCOLUMNW column;
 268
 269     SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
 270     GetWindowRect(lv, &rc);
 271     LoadStringW(instance, IDS_COL_PROVIDER, buf, ARRAY_SIZE(buf));
 272     column.mask = LVCF_WIDTH | LVCF_TEXT;
 273     column.cx = (rc.right - rc.left) - 5;
 274     column.pszText = buf;
 275     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
 276 }
 277
 278 static void add_connections_providers(HWND lv)
 279 {
 280     static const WCHAR oledbprov[] = {'\\','O','L','E',' ','D','B',' ','P','r','o','v','i','d','e','r',0};
 281     LONG res;
 282     HKEY key = NULL, subkey;
 283     DWORD index = 0;
 284     LONG next_key;
 285     WCHAR provider[MAX_PATH];
 286     WCHAR guidkey[MAX_PATH];
 287     LONG size;
 288
 289     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_READ, &key);
 290     if (res == ERROR_FILE_NOT_FOUND)
 291         return;
 292
 293     next_key = RegEnumKeyW(key, index, provider, MAX_PATH);
 294     while (next_key == ERROR_SUCCESS)
 295     {
 296         WCHAR description[MAX_PATH];
 297
 298         lstrcpyW(guidkey, provider);
 299         lstrcatW(guidkey, oledbprov);
 300
 301         res = RegOpenKeyW(key, guidkey, &subkey);
 302         if (res == ERROR_SUCCESS)
 303         {
 304             TRACE("Found %s\n", debugstr_w(guidkey));
 305
 306             size = MAX_PATH;
 307             res = RegQueryValueW(subkey, NULL, description, &size);
 308             if (res == ERROR_SUCCESS)
 309             {
 310                 LVITEMW item;
 311                 struct datasource *data;
 312
 313                 data = create_datasource(guidkey);
 314
 315                 item.mask = LVIF_TEXT | LVIF_PARAM;
 316                 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
 317                 item.iSubItem = 0;
 318                 item.pszText = description;
 319                 item.lParam = (LPARAM)data;
 320
 321                 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
 322             }
 323             RegCloseKey(subkey);
 324         }
 325
 326         index++;
 327         next_key = RegEnumKeyW(key, index, provider, MAX_PATH);
 328     }
 329
 330     RegCloseKey(key);
 331 }
 332
 333 static LRESULT CALLBACK data_link_properties_dlg_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
 334 {
 335     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
 336
 337     switch (msg)
 338     {
 339         case WM_INITDIALOG:
 340         {
 341             HWND btn, lv = GetDlgItem(hwnd, IDC_LST_CONNECTIONS);
 342             create_connections_columns(lv);
 343             add_connections_providers(lv);
 344
 345             btn = GetDlgItem(GetParent(hwnd), IDOK);
 346             EnableWindow(btn, FALSE);
 347
 348             break;
 349         }
 350         case WM_DESTROY:
 351         {
 352             HWND lv = GetDlgItem(hwnd, IDC_LST_CONNECTIONS);
 353             LVITEMA item;
 354
 355             item.iItem = 0;
 356             item.iSubItem = 0;
 357             item.mask = LVIF_PARAM;
 358
 359             while(ListView_GetItemA(lv, &item))
 360             {
 361                 destroy_datasource( (struct datasource *)item.lParam);
 362                 item.iItem++;
 363             }
 364             break;
 365         }
 366         case WM_NOTIFY:
 367         {
 368             NMHDR *hdr = ((LPNMHDR)lp);
 369             switch(hdr->code)
 370             {
 371                 case PSN_KILLACTIVE:
 372                 {
 373                     LVITEMA item;
 374                     /*
 375                      * FIXME: This needs to replace the connection page based off the selection.
 376                      *   We only care about the ODBC for now which is the default.
 377                      */
 378
 379                     HWND lv = GetDlgItem(hwnd, IDC_LST_CONNECTIONS);
 380                     if (!SendMessageW(lv, LVM_GETSELECTEDCOUNT, 0, 0))
 381                     {
 382                         WCHAR title[256], msg[256];
 383
 384                         LoadStringW(instance, IDS_PROVIDER_TITLE, title, ARRAY_SIZE(title));
 385                         LoadStringW(instance, IDS_PROVIDER_ERROR, msg, ARRAY_SIZE(msg));
 386                         MessageBoxW(hwnd, msg, title, MB_OK | MB_ICONEXCLAMATION);
 387                         SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, TRUE);
 388                         return TRUE;
 389                     }
 390
 391                     item.iItem = 0;
 392                     item.iSubItem = 0;
 393                     item.stateMask = LVIS_SELECTED;
 394                     item.mask = LVIF_PARAM | LVIF_STATE;
 395
 396                     if(ListView_GetItemA(lv, &item))
 397                     {
 398                         if(!initialize_datasource( (struct datasource*)item.lParam))
 399                         {
 400                             WCHAR title[256], msg[256];
 401                             LoadStringW(instance, IDS_PROVIDER_TITLE, title, ARRAY_SIZE(title));
 402                             LoadStringW(instance, IDS_PROVIDER_NOT_AVAIL, msg, ARRAY_SIZE(msg));
 403                             MessageBoxW(hwnd, msg, title, MB_OK | MB_ICONEXCLAMATION);
 404                             SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, TRUE);
 405                             return TRUE;
 406                         }
 407                     }
 408                     else
 409                         ERR("Failed to get selected item\n");
 410
 411                     return FALSE;
 412                 }
 413             }
 414
 415             break;
 416         }
 417         case WM_COMMAND:
 418         {
 419             if (LOWORD(wp) == IDC_BTN_NEXT)
 420                 SendMessageW(GetParent(hwnd), PSM_SETCURSEL, 1, 0);
 421             break;
 422         }
 423         default:
 424             break;
 425     }
 426     return 0;
 427 }
 428
 429 static void connection_fill_odbc_list(HWND parent)
 430 {
 431     LONG res;
 432     HKEY key;
 433     DWORD index = 0;
 434     WCHAR name[MAX_PATH];
 435     DWORD nameLen;
 436
 437     HWND combo = GetDlgItem(parent, IDC_CBO_NAMES);
 438     if (!combo)
 439         return;
 440
 441     res = RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\ODBC\\ODBC.INI\\ODBC Data Sources", 0, KEY_READ, &key);
 442     if (res == ERROR_FILE_NOT_FOUND)
 443         return;
 444
 445     SendMessageW (combo, CB_RESETCONTENT, 0, 0);
 446
 447     for(;; index++)
 448     {
 449         nameLen = MAX_PATH;
 450         if (RegEnumValueW(key, index, name, &nameLen, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
 451             break;
 452
 453         SendMessageW(combo, CB_ADDSTRING, 0, (LPARAM)name);
 454     }
 455
 456     RegCloseKey(key);
 457 }
 458
 459 static void connection_initialize_controls(HWND parent)
 460 {
 461     HWND hwnd = GetDlgItem(parent, IDC_RDO_SRC_NAME);
 462     if (hwnd)
 463         SendMessageA(hwnd, BM_SETCHECK, BST_CHECKED, 0);
 464 }
 465
 466 static void connection_toggle_controls(HWND parent)
 467 {
 468     BOOL checked = TRUE;
 469     HWND hwnd = GetDlgItem(parent, IDC_RDO_SRC_NAME);
 470     if (hwnd)
 471         checked = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
 472
 473     EnableWindow(GetDlgItem(parent, IDC_CBO_NAMES), checked);
 474     EnableWindow(GetDlgItem(parent, IDC_BTN_REFRESH), checked);
 475
 476     EnableWindow(GetDlgItem(parent, IDC_LBL_CONNECTION), !checked);
 477     EnableWindow(GetDlgItem(parent, IDC_EDT_CONNECTION), !checked);
 478     EnableWindow(GetDlgItem(parent, IDC_BTN_BUILD), !checked);
 479 }
 480
 481 static LRESULT CALLBACK data_link_connection_dlg_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
 482 {
 483     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
 484
 485     switch (msg)
 486     {
 487         case WM_INITDIALOG:
 488         {
 489             connection_initialize_controls(hwnd);
 490             connection_fill_odbc_list(hwnd);
 491             connection_toggle_controls(hwnd);
 492             break;
 493         }
 494         case WM_COMMAND:
 495         {
 496             switch LOWORD(wp)
 497             {
 498                 case IDC_RDO_SRC_NAME:
 499                 case IDC_BTN_CONNECTION:
 500                     connection_toggle_controls(hwnd);
 501                     break;
 502                 case IDC_BTN_REFRESH:
 503                     connection_fill_odbc_list(hwnd);
 504                     break;
 505                 case IDC_BTN_BUILD:
 506                 case IDC_BTN_TEST:
 507                     /* TODO: Implement dialogs */
 508                     MessageBoxA(hwnd, "Not implemented yet.", "Error", MB_OK | MB_ICONEXCLAMATION);
 509                     break;
 510             }
 511
 512             break;
 513         }
 514         default:
 515             break;
 516     }
 517     return 0;
 518 }
 519
 520 static void advanced_fill_permission_list(HWND parent)
 521 {
 522     LVITEMW item;
 523     LVCOLUMNW column;
 524     RECT rc;
 525     int resources[] = {IDS_PERM_READ, IDS_PERM_READWRITE, IDS_PERM_SHAREDENYNONE,
 526                         IDS_PERM_SHAREDENYREAD, IDS_PERM_SHAREDENYWRITE, IDS_PERM_SHAREEXCLUSIVE,
 527                         IDS_PERM_WRITE};
 528     int i;
 529     WCHAR buf[256];
 530     HWND lv = GetDlgItem(parent, IDC_LST_PERMISSIONS);
 531     if (!lv)
 532         return;
 533
 534     SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_CHECKBOXES);
 535     GetWindowRect(lv, &rc);
 536     column.mask = LVCF_WIDTH | LVCF_FMT;
 537     column.fmt = LVCFMT_FIXED_WIDTH;
 538     column.cx = (rc.right - rc.left) - 25;
 539     column.pszText = buf;
 540     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
 541
 542     for(i =0; i < ARRAY_SIZE(resources); i++)
 543     {
 544         item.mask = LVIF_TEXT;
 545         item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
 546         item.iSubItem = 0;
 547         LoadStringW(instance, resources[i], buf, ARRAY_SIZE(buf));
 548         item.pszText = buf;
 549         SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
 550     }
 551 }
 552
 553 static LRESULT CALLBACK data_link_advanced_dlg_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
 554 {
 555     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
 556
 557     switch (msg)
 558     {
 559         case WM_INITDIALOG:
 560         {
 561             EnableWindow(GetDlgItem(hwnd, IDC_LBL_LEVEL), FALSE);
 562             EnableWindow(GetDlgItem(hwnd, IDC_CBO_LEVEL), FALSE);
 563             EnableWindow(GetDlgItem(hwnd, IDC_LBL_PROTECTION), FALSE);
 564             EnableWindow(GetDlgItem(hwnd, IDC_CBO_PROTECTION), FALSE);
 565
 566             advanced_fill_permission_list(hwnd);
 567
 568             break;
 569         }
 570         default:
 571             break;
 572     }
 573     return 0;
 574 }
 575
 576 static void create_page_all_columns(HWND lv)
 577 {
 578     RECT rc;
 579     WCHAR buf[256];
 580     LVCOLUMNW column;
 581
 582     SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
 583     GetWindowRect(lv, &rc);
 584     LoadStringW(instance, IDS_COL_NAME, buf, ARRAY_SIZE(buf));
 585     column.mask = LVCF_WIDTH | LVCF_TEXT;
 586     column.cx = (rc.right / 2);
 587     column.pszText = buf;
 588     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
 589
 590     LoadStringW(instance, IDS_COL_VALUE, buf, ARRAY_SIZE(buf));
 591     column.mask = LVCF_WIDTH | LVCF_TEXT;
 592     column.cx = (rc.right / 2);
 593     column.pszText = buf;
 594     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
 595 }
 596
 597 static LRESULT CALLBACK data_link_all_dlg_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
 598 {
 599     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
 600
 601     switch (msg)
 602     {
 603         case WM_INITDIALOG:
 604         {
 605             HWND lv = GetDlgItem(hwnd, IDC_LST_PROPERTIES);
 606             create_page_all_columns(lv);
 607             break;
 608         }
 609         case WM_COMMAND:
 610         {
 611             if (LOWORD(wp) == IDC_BTN_EDIT)
 612             {
 613                  /* TODO: Implement Connection dialog */
 614                  MessageBoxA(hwnd, "Not implemented yet.", "Error", MB_OK | MB_ICONEXCLAMATION);
 615             }
 616          }
 617      }
 618
 619      return 0;
 620  }
 621
 622 static HRESULT WINAPI dslocator_PromptNew(IDataSourceLocator *iface, IDispatch **connection)
 623 {
 624     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 625     PROPSHEETHEADERW hdr;
 626     PROPSHEETPAGEW pages[4];
 627     INT_PTR ret;
 628
 629     FIXME("(%p, %p) Semi-stub\n", iface, connection);
 630
 631     if(!connection)
 632         return E_INVALIDARG;
 633
 634     *connection = NULL;
 635
 636     memset(&pages, 0, sizeof(pages));
 637
 638     pages[0].dwSize = sizeof(PROPSHEETPAGEW);
 639     pages[0].hInstance = instance;
 640     pages[0].u.pszTemplate = MAKEINTRESOURCEW(IDD_PROVIDER);
 641     pages[0].pfnDlgProc = data_link_properties_dlg_proc;
 642
 643     pages[1].dwSize = sizeof(PROPSHEETPAGEW);
 644     pages[1].hInstance = instance;
 645     pages[1].u.pszTemplate = MAKEINTRESOURCEW(IDD_CONNECTION);
 646     pages[1].pfnDlgProc = data_link_connection_dlg_proc;
 647
 648     pages[2].dwSize = sizeof(PROPSHEETPAGEW);
 649     pages[2].hInstance = instance;
 650     pages[2].u.pszTemplate = MAKEINTRESOURCEW(IDD_ADVANCED);
 651     pages[2].pfnDlgProc = data_link_advanced_dlg_proc;
 652
 653     pages[3].dwSize = sizeof(pages[0]);
 654     pages[3].hInstance = instance;
 655     pages[3].u.pszTemplate = MAKEINTRESOURCEW(IDD_ALL);
 656     pages[3].pfnDlgProc = data_link_all_dlg_proc;
 657
 658     memset(&hdr, 0, sizeof(hdr));
 659     hdr.dwSize = sizeof(hdr);
 660     hdr.hwndParent = This->hwnd;
 661     hdr.dwFlags = PSH_NOAPPLYNOW | PSH_PROPSHEETPAGE;
 662     hdr.hInstance = instance;
 663     hdr.pszCaption = MAKEINTRESOURCEW(IDS_PROPSHEET_TITLE);
 664     hdr.u3.ppsp = pages;
 665     hdr.nPages = ARRAY_SIZE(pages);
 666     ret = PropertySheetW(&hdr);
 667
 668     return ret ? S_OK : S_FALSE;
 669 }
 670
 671 static HRESULT WINAPI dslocator_PromptEdit(IDataSourceLocator *iface, IDispatch **ppADOConnection, VARIANT_BOOL *success)
 672 {
 673     DSLocatorImpl *This = impl_from_IDataSourceLocator(iface);
 674
 675     FIXME("(%p)->(%p %p)\n",This, ppADOConnection, success);
 676
 677     return E_NOTIMPL;
 678 }
 679
 680 static const IDataSourceLocatorVtbl DSLocatorVtbl =
 681 {
 682     dslocator_QueryInterface,
 683     dslocator_AddRef,
 684     dslocator_Release,
 685     dslocator_GetTypeInfoCount,
 686     dslocator_GetTypeInfo,
 687     dslocator_GetIDsOfNames,
 688     dslocator_Invoke,
 689     dslocator_get_hWnd,
 690     dslocator_put_hWnd,
 691     dslocator_PromptNew,
 692     dslocator_PromptEdit
 693 };
 694
 695 static HRESULT WINAPI datainitialize_QueryInterface(IDataInitialize *iface, REFIID riid, void **obj)
 696 {
 697     DSLocatorImpl *This = impl_from_IDataInitialize(iface);
 698     return IDataSourceLocator_QueryInterface(&This->IDataSourceLocator_iface, riid, obj);
 699 }
 700
 701 static ULONG WINAPI datainitialize_AddRef(IDataInitialize *iface)
 702 {
 703     DSLocatorImpl *This = impl_from_IDataInitialize(iface);
 704     return IDataSourceLocator_AddRef(&This->IDataSourceLocator_iface);
 705 }
 706
 707 static ULONG WINAPI datainitialize_Release(IDataInitialize *iface)
 708 {
 709     DSLocatorImpl *This = impl_from_IDataInitialize(iface);
 710     return IDataSourceLocator_Release(&This->IDataSourceLocator_iface);
 711 }
 712
 713 static HRESULT WINAPI datainitialize_GetDataSource(IDataInitialize *iface,
 714     IUnknown *outer, DWORD context, LPWSTR initstring, REFIID riid, IUnknown **datasource)
 715 {
 716     TRACE("(%p)->(%p %#x %s %s %p)\n", iface, outer, context, debugstr_w(initstring), debugstr_guid(riid),
 717         datasource);
 718
 719     return get_data_source(outer, context, initstring, riid, datasource);
 720 }
 721
 722 static HRESULT WINAPI datainitialize_GetInitializationString(IDataInitialize *iface, IUnknown *datasource,
 723     boolean include_password, LPWSTR *initstring)
 724 {
 725     FIXME("(%p)->(%d %p): stub\n", iface, include_password, initstring);
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI datainitialize_CreateDBInstance(IDataInitialize *iface, REFCLSID prov, IUnknown *outer,
 730     DWORD clsctx, LPWSTR reserved, REFIID riid, IUnknown **datasource)
 731 {
 732     FIXME("(%p)->(%s %p %#x %p %s %p): stub\n", iface, debugstr_guid(prov), outer, clsctx, reserved,
 733         debugstr_guid(riid), datasource);
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI datainitialize_CreateDBInstanceEx(IDataInitialize *iface, REFCLSID prov, IUnknown *outer,
 738     DWORD clsctx, LPWSTR reserved, COSERVERINFO *server_info, DWORD cmq, MULTI_QI *results)
 739 {
 740     FIXME("(%p)->(%s %p %#x %p %p %u %p): stub\n", iface, debugstr_guid(prov), outer, clsctx, reserved,
 741         server_info, cmq, results);
 742     return E_NOTIMPL;
 743 }
 744
 745 static HRESULT WINAPI datainitialize_LoadStringFromStorage(IDataInitialize *iface, LPWSTR filename, LPWSTR *initstring)
 746 {
 747     FIXME("(%p)->(%s %p): stub\n", iface, debugstr_w(filename), initstring);
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI datainitialize_WriteStringToStorage(IDataInitialize *iface, LPWSTR filename, LPWSTR initstring,
 752     DWORD disposition)
 753 {
 754     FIXME("(%p)->(%s %s %#x): stub\n", iface, debugstr_w(filename), debugstr_w(initstring), disposition);
 755     return E_NOTIMPL;
 756 }
 757
 758 static const IDataInitializeVtbl ds_datainitialize_vtbl =
 759 {
 760     datainitialize_QueryInterface,
 761     datainitialize_AddRef,
 762     datainitialize_Release,
 763     datainitialize_GetDataSource,
 764     datainitialize_GetInitializationString,
 765     datainitialize_CreateDBInstance,
 766     datainitialize_CreateDBInstanceEx,
 767     datainitialize_LoadStringFromStorage,
 768     datainitialize_WriteStringToStorage,
 769 };
 770
 771 HRESULT create_dslocator(IUnknown *outer, void **obj)
 772 {
 773     DSLocatorImpl *This;
 774
 775     TRACE("(%p, %p)\n", outer, obj);
 776
 777     *obj = NULL;
 778
 779     if(outer) return CLASS_E_NOAGGREGATION;
 780
 781     This = heap_alloc(sizeof(*This));
 782     if(!This) return E_OUTOFMEMORY;
 783
 784     This->IDataSourceLocator_iface.lpVtbl = &DSLocatorVtbl;
 785     This->IDataInitialize_iface.lpVtbl = &ds_datainitialize_vtbl;
 786     This->ref = 1;
 787     This->hwnd = 0;
 788
 789     *obj = &This->IDataSourceLocator_iface;
 790
 791     return S_OK;
 792 }