dlls/localui/localui.c

   1 /*
   2  * Implementation of the Local Printmonitor User Interface
   3  *
   4  * Copyright 2007 Detlef Riekenberg
   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 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "winreg.h"
  27 #include "winuser.h"
  28
  29 #include "winspool.h"
  30 #include "ddk/winsplp.h"
  31
  32 #include "wine/debug.h"
  33 #include "localui.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(localui);
  36
  37 /*****************************************************/
  38
  39 static HINSTANCE LOCALUI_hInstance;
  40
  41 static const WCHAR cmd_AddPortW[] = {'A','d','d','P','o','r','t',0};
  42 static const WCHAR cmd_ConfigureLPTPortCommandOKW[] = {'C','o','n','f','i','g','u','r','e',
  43                                     'L','P','T','P','o','r','t',
  44                                     'C','o','m','m','a','n','d','O','K',0};
  45 static const WCHAR cmd_DeletePortW[] = {'D','e','l','e','t','e','P','o','r','t',0};
  46 static const WCHAR cmd_GetDefaultCommConfigW[] = {'G','e','t',
  47                                     'D','e','f','a','u','l','t',
  48                                     'C','o','m','m','C','o','n','f','i','g',0};
  49 static const WCHAR cmd_GetTransmissionRetryTimeoutW[] = {'G','e','t',
  50                                     'T','r','a','n','s','m','i','s','s','i','o','n',
  51                                     'R','e','t','r','y','T','i','m','e','o','u','t',0};
  52 static const WCHAR cmd_PortIsValidW[] = {'P','o','r','t','I','s','V','a','l','i','d',0};
  53 static const WCHAR cmd_SetDefaultCommConfigW[] = {'S','e','t',
  54                                     'D','e','f','a','u','l','t',
  55                                     'C','o','m','m','C','o','n','f','i','g',0};
  56
  57 static const WCHAR fmt_uW[]  = {'%','u',0};
  58 static const WCHAR portname_LPT[]  = {'L','P','T',0};
  59 static const WCHAR portname_COM[]  = {'C','O','M',0};
  60 static const WCHAR portname_FILE[] = {'F','I','L','E',':',0};
  61 static const WCHAR portname_CUPS[] = {'C','U','P','S',':',0};
  62 static const WCHAR portname_LPR[]  = {'L','P','R',':',0};
  63
  64 static const WCHAR XcvMonitorW[] = {',','X','c','v','M','o','n','i','t','o','r',' ',0};
  65 static const WCHAR XcvPortW[] = {',','X','c','v','P','o','r','t',' ',0};
  66
  67 /*****************************************************/
  68
  69 typedef struct tag_addportui_t {
  70     LPWSTR  portname;
  71     HANDLE  hXcv;
  72 } addportui_t;
  73
  74 typedef struct tag_lptconfig_t {
  75     HANDLE  hXcv;
  76     DWORD   value;
  77 } lptconfig_t;
  78
  79
  80 static INT_PTR CALLBACK dlgproc_lptconfig(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
  81
  82 /*****************************************************
  83  *   strdupWW [internal]
  84  */
  85
  86 static LPWSTR strdupWW(LPCWSTR pPrefix, LPCWSTR pSuffix)
  87 {
  88     LPWSTR  ptr;
  89     DWORD   len;
  90
  91     len = lstrlenW(pPrefix) + (pSuffix ? lstrlenW(pSuffix) : 0) + 1;
  92     ptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  93     if (ptr) {
  94         lstrcpyW(ptr, pPrefix);
  95         if (pSuffix) lstrcatW(ptr, pSuffix);
  96     }
  97     return ptr;
  98 }
  99
 100 /*****************************************************
 101  *   dlg_configure_com [internal]
 102  *
 103  */
 104
 105 static BOOL dlg_configure_com(HANDLE hXcv, HWND hWnd, PCWSTR pPortName)
 106 {
 107     COMMCONFIG cfg;
 108     LPWSTR shortname;
 109     DWORD status;
 110     DWORD dummy;
 111     DWORD len;
 112     BOOL  res;
 113
 114     /* strip the colon (pPortName is never empty here) */
 115     len = lstrlenW(pPortName);
 116     shortname = HeapAlloc(GetProcessHeap(), 0, len  * sizeof(WCHAR));
 117     if (shortname) {
 118         memcpy(shortname, pPortName, (len -1) * sizeof(WCHAR));
 119         shortname[len-1] = '\0';
 120
 121         /* get current settings */
 122         len = FIELD_OFFSET(COMMCONFIG, wcProviderData[1]);
 123         status = ERROR_SUCCESS;
 124         res = XcvDataW( hXcv, cmd_GetDefaultCommConfigW,
 125                         (PBYTE) shortname,
 126                         (lstrlenW(shortname) +1) * sizeof(WCHAR),
 127                         (PBYTE) &cfg, len, &len, &status);
 128
 129         if (res && (status == ERROR_SUCCESS)) {
 130             /* display the Dialog */
 131             res = CommConfigDialogW(pPortName, hWnd, &cfg);
 132             if (res) {
 133                 status = ERROR_SUCCESS;
 134                 /* set new settings */
 135                 res = XcvDataW(hXcv, cmd_SetDefaultCommConfigW,
 136                                (PBYTE) &cfg, len,
 137                                (PBYTE) &dummy, 0, &len, &status);
 138             }
 139         }
 140         HeapFree(GetProcessHeap(), 0, shortname);
 141         return res;
 142     }
 143     return FALSE;
 144 }
 145
 146
 147 /*****************************************************
 148  *   dlg_configure_lpt [internal]
 149  *
 150  */
 151
 152 static BOOL dlg_configure_lpt(HANDLE hXcv, HWND hWnd)
 153 {
 154     lptconfig_t data;
 155     BOOL  res;
 156
 157
 158     data.hXcv = hXcv;
 159
 160     res = DialogBoxParamW(LOCALUI_hInstance, MAKEINTRESOURCEW(LPTCONFIG_DIALOG), hWnd,
 161                                dlgproc_lptconfig, (LPARAM) &data);
 162
 163     TRACE("got %u with %u\n", res, GetLastError());
 164
 165     if (!res) SetLastError(ERROR_CANCELLED);
 166     return res;
 167 }
 168
 169 /******************************************************************
 170  *  dlg_port_already_exists [internal]
 171  */
 172
 173 static void dlg_port_already_exists(HWND hWnd, LPCWSTR portname)
 174 {
 175     WCHAR res_PortW[IDS_LOCALPORT_MAXLEN];
 176     WCHAR res_PortExistsW[IDS_PORTEXISTS_MAXLEN];
 177     LPWSTR  message;
 178     DWORD   len;
 179
 180     res_PortW[0] = '\0';
 181     res_PortExistsW[0] = '\0';
 182     LoadStringW(LOCALUI_hInstance, IDS_LOCALPORT, res_PortW, IDS_LOCALPORT_MAXLEN);
 183     LoadStringW(LOCALUI_hInstance, IDS_PORTEXISTS, res_PortExistsW, IDS_PORTEXISTS_MAXLEN);
 184
 185     len = lstrlenW(portname) + IDS_PORTEXISTS_MAXLEN + 1;
 186     message = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 187     if (message) {
 188         message[0] = '\0';
 189         swprintf(message, len, res_PortExistsW, portname);
 190         MessageBoxW(hWnd, message, res_PortW, MB_OK | MB_ICONERROR);
 191         HeapFree(GetProcessHeap(), 0, message);
 192     }
 193 }
 194
 195 /******************************************************************
 196  *  dlg_invalid_portname [internal]
 197  */
 198
 199 static void dlg_invalid_portname(HWND hWnd, LPCWSTR portname)
 200 {
 201     WCHAR res_PortW[IDS_LOCALPORT_MAXLEN];
 202     WCHAR res_InvalidNameW[IDS_INVALIDNAME_MAXLEN];
 203     LPWSTR  message;
 204     DWORD   len;
 205
 206     res_PortW[0] = '\0';
 207     res_InvalidNameW[0] = '\0';
 208     LoadStringW(LOCALUI_hInstance, IDS_LOCALPORT, res_PortW, IDS_LOCALPORT_MAXLEN);
 209     LoadStringW(LOCALUI_hInstance, IDS_INVALIDNAME, res_InvalidNameW, IDS_INVALIDNAME_MAXLEN);
 210
 211     len = lstrlenW(portname) + IDS_INVALIDNAME_MAXLEN;
 212     message = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 213     if (message) {
 214         message[0] = '\0';
 215         swprintf(message, len, res_InvalidNameW, portname);
 216         MessageBoxW(hWnd, message, res_PortW, MB_OK | MB_ICONERROR);
 217         HeapFree(GetProcessHeap(), 0, message);
 218     }
 219 }
 220
 221 /******************************************************************
 222  * display the Dialog "Nothing to configure"
 223  *
 224  */
 225
 226 static void dlg_nothingtoconfig(HWND hWnd)
 227 {
 228     WCHAR res_PortW[IDS_LOCALPORT_MAXLEN];
 229     WCHAR res_nothingW[IDS_NOTHINGTOCONFIG_MAXLEN];
 230
 231     res_PortW[0] = '\0';
 232     res_nothingW[0] = '\0';
 233     LoadStringW(LOCALUI_hInstance, IDS_LOCALPORT, res_PortW, IDS_LOCALPORT_MAXLEN);
 234     LoadStringW(LOCALUI_hInstance, IDS_NOTHINGTOCONFIG, res_nothingW, IDS_NOTHINGTOCONFIG_MAXLEN);
 235
 236     MessageBoxW(hWnd, res_nothingW, res_PortW, MB_OK | MB_ICONINFORMATION);
 237 }
 238
 239 /******************************************************************
 240  *  dlg_win32error [internal]
 241  */
 242
 243 static void dlg_win32error(HWND hWnd, DWORD lasterror)
 244 {
 245     WCHAR res_PortW[IDS_LOCALPORT_MAXLEN];
 246     LPWSTR  message = NULL;
 247     DWORD   res;
 248
 249     res_PortW[0] = '\0';
 250     LoadStringW(LOCALUI_hInstance, IDS_LOCALPORT, res_PortW, IDS_LOCALPORT_MAXLEN);
 251
 252
 253     res = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 254                         NULL, lasterror, 0, (LPWSTR) &message, 0, NULL);
 255
 256     if (res > 0) {
 257         MessageBoxW(hWnd, message, res_PortW, MB_OK | MB_ICONERROR);
 258         LocalFree(message);
 259     }
 260 }
 261
 262 /*****************************************************************************
 263  *
 264  */
 265
 266 static INT_PTR CALLBACK dlgproc_addport(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 267 {
 268     addportui_t * data;
 269     DWORD   status;
 270     DWORD   dummy;
 271     DWORD   len;
 272     DWORD   res;
 273
 274     switch(msg)
 275     {
 276     case WM_INITDIALOG:
 277         SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
 278         return TRUE;
 279
 280     case WM_COMMAND:
 281         if (wparam == MAKEWPARAM(IDOK, BN_CLICKED))
 282         {
 283             data = (addportui_t *) GetWindowLongPtrW(hwnd, DWLP_USER);
 284             /* length in WCHAR, without the '\0' */
 285             len = SendDlgItemMessageW(hwnd, ADDPORT_EDIT, WM_GETTEXTLENGTH, 0, 0);
 286             data->portname = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
 287
 288             if (!data->portname) {
 289                 EndDialog(hwnd, FALSE);
 290                 return TRUE;
 291             }
 292             /* length is in WCHAR, including the '\0' */
 293             GetDlgItemTextW(hwnd, ADDPORT_EDIT, data->portname, len + 1);
 294             status = ERROR_SUCCESS;
 295             res = XcvDataW( data->hXcv, cmd_PortIsValidW, (PBYTE) data->portname,
 296                             (lstrlenW(data->portname) + 1) * sizeof(WCHAR),
 297                             (PBYTE) &dummy, 0, &len, &status);
 298
 299             TRACE("got %u with status %u\n", res, status);
 300             if (res && (status == ERROR_SUCCESS)) {
 301                 /* The caller must free data->portname */
 302                 EndDialog(hwnd, TRUE);
 303                 return TRUE;
 304             }
 305
 306             if (res && (status == ERROR_INVALID_NAME)) {
 307                 dlg_invalid_portname(hwnd, data->portname);
 308                 HeapFree(GetProcessHeap(), 0, data->portname);
 309                 data->portname = NULL;
 310                 return TRUE;
 311             }
 312
 313             dlg_win32error(hwnd, status);
 314             HeapFree(GetProcessHeap(), 0, data->portname);
 315             data->portname = NULL;
 316             return TRUE;
 317         }
 318
 319         if (wparam == MAKEWPARAM(IDCANCEL, BN_CLICKED))
 320         {
 321             EndDialog(hwnd, FALSE);
 322             return TRUE;
 323         }
 324         return FALSE;
 325     }
 326     return FALSE;
 327 }
 328
 329 /*****************************************************************************
 330  *   dlgproc_lptconfig  [internal]
 331  *
 332  * Our message-proc is simple, as the range-check is done only during the
 333  * command "OK" and the dialog is set to the start-value at "out of range".
 334  *
 335  * Native localui.dll does the check during keyboard-input and set the dialog
 336  * to the previous value.
 337  *
 338  */
 339
 340 static INT_PTR CALLBACK dlgproc_lptconfig(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 341 {
 342     lptconfig_t * data;
 343     WCHAR   bufferW[16];
 344     DWORD   status;
 345     DWORD   dummy;
 346     DWORD   len;
 347     DWORD   res;
 348
 349
 350     switch(msg)
 351     {
 352     case WM_INITDIALOG:
 353         SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
 354         data = (lptconfig_t *) lparam;
 355
 356         /* Get current setting */
 357         data->value = 45;
 358         status = ERROR_SUCCESS;
 359         res = XcvDataW( data->hXcv, cmd_GetTransmissionRetryTimeoutW,
 360                         (PBYTE) &dummy, 0,
 361                         (PBYTE) &data->value, sizeof(data->value), &len, &status);
 362
 363         TRACE("got %u with status %u\n", res, status);
 364
 365         /* Set current setting as the initial value in the Dialog */
 366         SetDlgItemInt(hwnd, LPTCONFIG_EDIT, data->value, FALSE);
 367         return TRUE;
 368
 369     case WM_COMMAND:
 370         if (wparam == MAKEWPARAM(IDOK, BN_CLICKED))
 371         {
 372             data = (lptconfig_t *) GetWindowLongPtrW(hwnd, DWLP_USER);
 373
 374             status = FALSE;
 375             res = GetDlgItemInt(hwnd, LPTCONFIG_EDIT, (BOOL *) &status, FALSE);
 376             /* length is in WCHAR, including the '\0' */
 377             GetDlgItemTextW(hwnd, LPTCONFIG_EDIT, bufferW, ARRAY_SIZE(bufferW));
 378             TRACE("got %s and %u (translated: %u)\n", debugstr_w(bufferW), res, status);
 379
 380             /* native localui.dll use the same limits */
 381             if ((res > 0) && (res < 1000000) && status) {
 382                 swprintf(bufferW, ARRAY_SIZE(bufferW), fmt_uW, res);
 383                 res = XcvDataW( data->hXcv, cmd_ConfigureLPTPortCommandOKW,
 384                         (PBYTE) bufferW,
 385                         (lstrlenW(bufferW) +1) * sizeof(WCHAR),
 386                         (PBYTE) &dummy, 0, &len, &status);
 387
 388                 TRACE("got %u with status %u\n", res, status);
 389                 EndDialog(hwnd, TRUE);
 390                 return TRUE;
 391             }
 392
 393             /* Set initial value and rerun the Dialog */
 394             SetDlgItemInt(hwnd, LPTCONFIG_EDIT, data->value, FALSE);
 395             return TRUE;
 396         }
 397
 398         if (wparam == MAKEWPARAM(IDCANCEL, BN_CLICKED))
 399         {
 400             EndDialog(hwnd, FALSE);
 401             return TRUE;
 402         }
 403         return FALSE;
 404     }
 405     return FALSE;
 406 }
 407
 408
 409 /*****************************************************
 410  * get_type_from_name (internal)
 411  *
 412  */
 413
 414 static DWORD get_type_from_name(LPCWSTR name)
 415 {
 416     HANDLE  hfile;
 417
 418     if (!wcsnicmp(name, portname_LPT, ARRAY_SIZE(portname_LPT) -1))
 419         return PORT_IS_LPT;
 420
 421     if (!wcsnicmp(name, portname_COM, ARRAY_SIZE(portname_COM) -1))
 422         return PORT_IS_COM;
 423
 424     if (!wcsicmp(name, portname_FILE))
 425         return PORT_IS_FILE;
 426
 427     if (name[0] == '/')
 428         return PORT_IS_UNIXNAME;
 429
 430     if (name[0] == '|')
 431         return PORT_IS_PIPE;
 432
 433     if (!wcsncmp(name, portname_CUPS, ARRAY_SIZE(portname_CUPS) -1))
 434         return PORT_IS_CUPS;
 435
 436     if (!wcsncmp(name, portname_LPR, ARRAY_SIZE(portname_LPR) -1))
 437         return PORT_IS_LPR;
 438
 439     /* Must be a file or a directory. Does the file exist ? */
 440     hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 441     TRACE("%p for OPEN_EXISTING on %s\n", hfile, debugstr_w(name));
 442     if (hfile == INVALID_HANDLE_VALUE) {
 443         /* Can we create the file? */
 444         hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL);
 445         TRACE("%p for OPEN_ALWAYS\n", hfile);
 446     }
 447     if (hfile != INVALID_HANDLE_VALUE) {
 448         CloseHandle(hfile);
 449         return PORT_IS_FILENAME;
 450     }
 451     /* We can't use the name. use GetLastError() for the reason */
 452     return PORT_IS_UNKNOWN;
 453 }
 454
 455 /*****************************************************
 456  *   open_monitor_by_name [internal]
 457  *
 458  */
 459 static BOOL open_monitor_by_name(LPCWSTR pPrefix, LPCWSTR pPort, HANDLE * phandle)
 460 {
 461     PRINTER_DEFAULTSW pd;
 462     LPWSTR  fullname;
 463     BOOL    res;
 464
 465     * phandle = 0;
 466     TRACE("(%s,%s)\n", debugstr_w(pPrefix),debugstr_w(pPort) );
 467
 468     fullname = strdupWW(pPrefix, pPort);
 469     pd.pDatatype = NULL;
 470     pd.pDevMode  = NULL;
 471     pd.DesiredAccess = SERVER_ACCESS_ADMINISTER;
 472
 473     res = OpenPrinterW(fullname, phandle, &pd);
 474     HeapFree(GetProcessHeap(), 0, fullname);
 475     return res;
 476 }
 477
 478 /*****************************************************
 479  *   localui_AddPortUI [exported through MONITORUI]
 480  *
 481  * Display a Dialog to add a local Port
 482  *
 483  * PARAMS
 484  *  pName       [I] Servername or NULL (local Computer)
 485  *  hWnd        [I] Handle to parent Window for the Dialog-Box or NULL
 486  *  pMonitorName[I] Name of the Monitor, that should be used to add a Port or NULL
 487  *  ppPortName  [O] PTR to PTR of a buffer, that receive the Name of the new Port or NULL
 488  *
 489  * RETURNS
 490  *  Success: TRUE
 491  *  Failure: FALSE
 492  *
 493  * NOTES
 494  * The caller must free the buffer (returned in ppPortName) with GlobalFree().
 495  * Native localui.dll failed with ERROR_INVALID_PARAMETER, when the user tried
 496  * to add a Port, that start with "COM" or "LPT".
 497  *
 498  */
 499 static BOOL WINAPI localui_AddPortUI(PCWSTR pName, HWND hWnd, PCWSTR pMonitorName, PWSTR *ppPortName)
 500 {
 501     addportui_t data;
 502     HANDLE  hXcv;
 503     DWORD   needed;
 504     DWORD   dummy;
 505     DWORD   status;
 506     DWORD   res = FALSE;
 507
 508     TRACE(  "(%s, %p, %s, %p) (*ppPortName: %p)\n", debugstr_w(pName), hWnd,
 509             debugstr_w(pMonitorName), ppPortName, ppPortName ? *ppPortName : NULL);
 510
 511     if (open_monitor_by_name(XcvMonitorW, pMonitorName, &hXcv)) {
 512
 513         ZeroMemory(&data, sizeof(addportui_t));
 514         data.hXcv = hXcv;
 515         res = DialogBoxParamW(LOCALUI_hInstance, MAKEINTRESOURCEW(ADDPORT_DIALOG), hWnd,
 516                                dlgproc_addport, (LPARAM) &data);
 517
 518         TRACE("got %u with %u for %s\n", res, GetLastError(), debugstr_w(data.portname));
 519
 520         if (ppPortName) *ppPortName = NULL;
 521
 522         if (res) {
 523             res = XcvDataW(hXcv, cmd_AddPortW, (PBYTE) data.portname,
 524                             (lstrlenW(data.portname)+1) * sizeof(WCHAR),
 525                             (PBYTE) &dummy, 0, &needed, &status);
 526
 527             TRACE("got %u with status %u\n", res, status);
 528             if (res && (status == ERROR_SUCCESS) && ppPortName) {
 529                 /* Native localui uses GlobalAlloc also.
 530                    The caller must GlobalFree the buffer */
 531                 *ppPortName = GlobalAlloc(GPTR, (lstrlenW(data.portname)+1) * sizeof(WCHAR));
 532                 if (*ppPortName) lstrcpyW(*ppPortName, data.portname);
 533             }
 534
 535             if (res && (status == ERROR_ALREADY_EXISTS)) {
 536                 dlg_port_already_exists(hWnd, data.portname);
 537                 /* Native localui also return "TRUE" from AddPortUI in this case */
 538             }
 539
 540             HeapFree(GetProcessHeap(), 0, data.portname);
 541         }
 542         else
 543         {
 544             SetLastError(ERROR_CANCELLED);
 545         }
 546         ClosePrinter(hXcv);
 547     }
 548
 549     TRACE("=> %u with %u\n", res, GetLastError());
 550     return res;
 551 }
 552
 553
 554 /*****************************************************
 555  *   localui_ConfigurePortUI [exported through MONITORUI]
 556  *
 557  * Display the Configuration-Dialog for a specific Port
 558  *
 559  * PARAMS
 560  *  pName     [I] Servername or NULL (local Computer)
 561  *  hWnd      [I] Handle to parent Window for the Dialog-Box or NULL
 562  *  pPortName [I] Name of the Port, that should be configured
 563  *
 564  * RETURNS
 565  *  Success: TRUE
 566  *  Failure: FALSE
 567  *
 568  */
 569 static BOOL WINAPI localui_ConfigurePortUI(PCWSTR pName, HWND hWnd, PCWSTR pPortName)
 570 {
 571     HANDLE  hXcv;
 572     DWORD   res;
 573
 574     TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
 575     if (open_monitor_by_name(XcvPortW, pPortName, &hXcv)) {
 576
 577         res = get_type_from_name(pPortName);
 578         switch(res)
 579         {
 580
 581         case PORT_IS_COM:
 582             res = dlg_configure_com(hXcv, hWnd, pPortName);
 583             break;
 584
 585         case PORT_IS_LPT:
 586             res = dlg_configure_lpt(hXcv, hWnd);
 587             break;
 588
 589         default:
 590             dlg_nothingtoconfig(hWnd);
 591             SetLastError(ERROR_CANCELLED);
 592             res = FALSE;
 593         }
 594
 595         ClosePrinter(hXcv);
 596         return res;
 597     }
 598     return FALSE;
 599
 600 }
 601
 602 /*****************************************************
 603  *   localui_DeletePortUI [exported through MONITORUI]
 604  *
 605  * Delete a specific Port
 606  *
 607  * PARAMS
 608  *  pName     [I] Servername or NULL (local Computer)
 609  *  hWnd      [I] Handle to parent Window
 610  *  pPortName [I] Name of the Port, that should be deleted
 611  *
 612  * RETURNS
 613  *  Success: TRUE
 614  *  Failure: FALSE
 615  *
 616  * NOTES
 617  *  Native localui does not allow deleting a COM/LPT port (ERROR_NOT_SUPPORTED)
 618  *
 619  */
 620 static BOOL WINAPI localui_DeletePortUI(PCWSTR pName, HWND hWnd, PCWSTR pPortName)
 621 {
 622     HANDLE  hXcv;
 623     DWORD   dummy;
 624     DWORD   needed;
 625     DWORD   status;
 626
 627     TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
 628
 629     if ((!pPortName) || (!pPortName[0])) {
 630         SetLastError(ERROR_INVALID_PARAMETER);
 631         return FALSE;
 632     }
 633
 634     if (open_monitor_by_name(XcvPortW, pPortName, &hXcv)) {
 635         /* native localui tests here for LPT / COM - Ports and failed with
 636            ERROR_NOT_SUPPORTED. */
 637         if (XcvDataW(hXcv, cmd_DeletePortW, (LPBYTE) pPortName,
 638             (lstrlenW(pPortName)+1) * sizeof(WCHAR), (LPBYTE) &dummy, 0, &needed, &status)) {
 639
 640             ClosePrinter(hXcv);
 641             if (status != ERROR_SUCCESS) SetLastError(status);
 642             return (status == ERROR_SUCCESS);
 643         }
 644         ClosePrinter(hXcv);
 645         return FALSE;
 646     }
 647     SetLastError(ERROR_UNKNOWN_PORT);
 648     return FALSE;
 649 }
 650
 651 /*****************************************************
 652  *      InitializePrintMonitorUI  (LOCALUI.@)
 653  *
 654  * Initialize the User-Interface for the Local Ports
 655  *
 656  * RETURNS
 657  *  Success: Pointer to a MONITORUI Structure
 658  *  Failure: NULL
 659  *
 660  */
 661
 662 PMONITORUI WINAPI InitializePrintMonitorUI(void)
 663 {
 664     static MONITORUI mymonitorui =
 665     {
 666         sizeof(MONITORUI),
 667         localui_AddPortUI,
 668         localui_ConfigurePortUI,
 669         localui_DeletePortUI
 670     };
 671
 672     TRACE("=> %p\n", &mymonitorui);
 673     return &mymonitorui;
 674 }
 675
 676 /*****************************************************
 677  *      DllMain
 678  */
 679 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 680 {
 681     TRACE("(%p, %d, %p)\n",hinstDLL, fdwReason, lpvReserved);
 682
 683     switch(fdwReason)
 684     {
 685         case DLL_PROCESS_ATTACH:
 686             DisableThreadLibraryCalls( hinstDLL );
 687             LOCALUI_hInstance = hinstDLL;
 688             break;
 689     }
 690     return TRUE;
 691 }