| /* |
| * OleUIPasteSpecial implementation |
| * |
| * Copyright 2006 Huw Davies |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #define COBJMACROS |
| #define NONAMELESSUNION |
| |
| #include <stdarg.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winerror.h" |
| #include "wingdi.h" |
| #include "winuser.h" |
| #include "winnls.h" |
| #include "oledlg.h" |
| |
| #include "oledlg_private.h" |
| #include "resource.h" |
| |
| #include "wine/debug.h" |
| #include "wine/unicode.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(ole); |
| |
| typedef struct |
| { |
| OLEUIPASTESPECIALW *ps; |
| DWORD flags; |
| WCHAR *source_name; |
| WCHAR *link_source_name; |
| WCHAR *type_name; |
| WCHAR *link_type_name; |
| LPOLESTR app_name; |
| } ps_struct_t; |
| |
| static const struct ps_flag |
| { |
| DWORD flag; |
| const char *name; |
| } ps_flags[] = { |
| #define PS_FLAG_ENTRY(p) {p, #p} |
| PS_FLAG_ENTRY(PSF_SHOWHELP), |
| PS_FLAG_ENTRY(PSF_SELECTPASTE), |
| PS_FLAG_ENTRY(PSF_SELECTPASTELINK), |
| PS_FLAG_ENTRY(PSF_CHECKDISPLAYASICON), |
| PS_FLAG_ENTRY(PSF_DISABLEDISPLAYASICON), |
| PS_FLAG_ENTRY(PSF_HIDECHANGEICON), |
| PS_FLAG_ENTRY(PSF_STAYONCLIPBOARDCHANGE), |
| PS_FLAG_ENTRY(PSF_NOREFRESHDATAOBJECT), |
| {-1, NULL} |
| #undef PS_FLAG_ENTRY |
| }; |
| |
| static void dump_ps_flags(DWORD flags) |
| { |
| char flagstr[1000] = ""; |
| |
| const struct ps_flag *flag = ps_flags; |
| for( ; flag->name; flag++) { |
| if(flags & flag->flag) { |
| strcat(flagstr, flag->name); |
| strcat(flagstr, "|"); |
| } |
| } |
| TRACE("flags %08x %s\n", flags, flagstr); |
| } |
| |
| static void dump_pastespecial(const OLEUIPASTESPECIALW *ps) |
| { |
| INT i; |
| UINT j; |
| |
| dump_ps_flags(ps->dwFlags); |
| TRACE("hwnd %p caption %s hook %p custdata %lx\n", |
| ps->hWndOwner, debugstr_w(ps->lpszCaption), ps->lpfnHook, ps->lCustData); |
| if(IS_INTRESOURCE(ps->lpszTemplate)) |
| TRACE("hinst %p template %04x hresource %p\n", ps->hInstance, (WORD)(ULONG_PTR)ps->lpszTemplate, ps->hResource); |
| else |
| TRACE("hinst %p template %s hresource %p\n", ps->hInstance, debugstr_w(ps->lpszTemplate), ps->hResource); |
| TRACE("dataobj %p arrpasteent %p cpasteent %d arrlinktype %p clinktype %d\n", |
| ps->lpSrcDataObj, ps->arrPasteEntries, ps->cPasteEntries, |
| ps->arrLinkTypes, ps->cLinkTypes); |
| TRACE("cclsidex %d lpclsidex %p nselect %d flink %d hmetapict %p size(%d,%d)\n", |
| ps->cClsidExclude, ps->lpClsidExclude, ps->nSelectedIndex, ps->fLink, |
| ps->hMetaPict, ps->sizel.cx, ps->sizel.cy); |
| for(i = 0; i < ps->cPasteEntries; i++) |
| { |
| TRACE("arrPasteEntries[%d]: cFormat %08x pTargetDevice %p dwAspect %d lindex %d tymed %d\n", |
| i, ps->arrPasteEntries[i].fmtetc.cfFormat, ps->arrPasteEntries[i].fmtetc.ptd, |
| ps->arrPasteEntries[i].fmtetc.dwAspect, ps->arrPasteEntries[i].fmtetc.lindex, |
| ps->arrPasteEntries[i].fmtetc.tymed); |
| TRACE("\tformat name %s result text %s flags %04x\n", debugstr_w(ps->arrPasteEntries[i].lpstrFormatName), |
| debugstr_w(ps->arrPasteEntries[i].lpstrResultText), ps->arrPasteEntries[i].dwFlags); |
| } |
| for(i = 0; i < ps->cLinkTypes; i++) |
| TRACE("arrLinkTypes[%d] %08x\n", i, ps->arrLinkTypes[i]); |
| for(j = 0; j < ps->cClsidExclude; j++) |
| TRACE("lpClsidExclude[%u] %s\n", j, debugstr_guid(&ps->lpClsidExclude[j])); |
| |
| } |
| |
| static inline WCHAR *strdupAtoW(const char *str) |
| { |
| DWORD len; |
| WCHAR *ret; |
| if(!str) return NULL; |
| len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0); |
| ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); |
| MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len); |
| return ret; |
| } |
| |
| static inline WCHAR *strdupW(const WCHAR *str) |
| { |
| DWORD len; |
| WCHAR *ret; |
| if(!str) return NULL; |
| len = lstrlenW(str) + 1; |
| ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); |
| memcpy(ret, str, len * sizeof(WCHAR)); |
| return ret; |
| } |
| |
| static void get_descriptors(HWND hdlg, ps_struct_t *ps_struct) |
| { |
| FORMATETC fmtetc; |
| STGMEDIUM stg; |
| |
| fmtetc.tymed = TYMED_HGLOBAL; |
| fmtetc.dwAspect = DVASPECT_CONTENT; |
| fmtetc.ptd = NULL; |
| fmtetc.lindex = -1; |
| |
| fmtetc.cfFormat = cf_object_descriptor; |
| if(IDataObject_GetData(ps_struct->ps->lpSrcDataObj, &fmtetc, &stg) == S_OK) |
| { |
| OBJECTDESCRIPTOR *obj_desc = GlobalLock(stg.u.hGlobal); |
| if(obj_desc->dwSrcOfCopy) |
| ps_struct->source_name = strdupW((WCHAR*)((char*)obj_desc + obj_desc->dwSrcOfCopy)); |
| if(obj_desc->dwFullUserTypeName) |
| ps_struct->type_name = strdupW((WCHAR*)((char*)obj_desc + obj_desc->dwFullUserTypeName)); |
| OleRegGetUserType(&obj_desc->clsid, USERCLASSTYPE_APPNAME, &ps_struct->app_name); |
| /* Get the icon here. If dwDrawAspect & DVASCPECT_ICON call GetData(CF_METAFILEPICT), otherwise |
| native calls OleGetIconFromClass(obj_desc->clsid) */ |
| GlobalUnlock(stg.u.hGlobal); |
| GlobalFree(stg.u.hGlobal); |
| } |
| else |
| { |
| /* Try to get some data using some of the other clipboard formats */ |
| } |
| |
| fmtetc.cfFormat = cf_link_src_descriptor; |
| if(IDataObject_GetData(ps_struct->ps->lpSrcDataObj, &fmtetc, &stg) == S_OK) |
| { |
| OBJECTDESCRIPTOR *obj_desc = GlobalLock(stg.u.hGlobal); |
| if(obj_desc->dwSrcOfCopy) |
| ps_struct->link_source_name = strdupW((WCHAR*)((char*)obj_desc + obj_desc->dwSrcOfCopy)); |
| if(obj_desc->dwFullUserTypeName) |
| ps_struct->link_type_name = strdupW((WCHAR*)((char*)obj_desc + obj_desc->dwFullUserTypeName)); |
| GlobalUnlock(stg.u.hGlobal); |
| GlobalFree(stg.u.hGlobal); |
| } |
| |
| if(ps_struct->source_name == NULL && ps_struct->link_source_name == NULL) |
| { |
| WCHAR buf[200]; |
| LoadStringW(OLEDLG_hInstance, IDS_PS_UNKNOWN_SRC, buf, sizeof(buf)/sizeof(WCHAR)); |
| ps_struct->source_name = strdupW(buf); |
| } |
| |
| if(ps_struct->type_name == NULL && ps_struct->link_type_name == NULL) |
| { |
| WCHAR buf[200]; |
| LoadStringW(OLEDLG_hInstance, IDS_PS_UNKNOWN_TYPE, buf, sizeof(buf)/sizeof(WCHAR)); |
| ps_struct->type_name = strdupW(buf); |
| } |
| } |
| |
| static BOOL add_entry_to_lb(HWND hdlg, UINT id, OLEUIPASTEENTRYW *pe) |
| { |
| HWND hwnd = GetDlgItem(hdlg, id); |
| BOOL ret = FALSE; |
| |
| /* FIXME %s handling */ |
| |
| /* Note that this suffers from the same bug as native, in that if a new string |
| is a substring of an already added string, then the FINDSTRING will succeed |
| this is probably not what we want */ |
| if(SendMessageW(hwnd, LB_FINDSTRING, 0, (LPARAM)pe->lpstrFormatName) == -1) |
| { |
| LRESULT pos = SendMessageW(hwnd, LB_ADDSTRING, 0, (LPARAM)pe->lpstrFormatName); |
| SendMessageW(hwnd, LB_SETITEMDATA, pos, (LPARAM)pe); |
| ret = TRUE; |
| } |
| return ret; |
| } |
| |
| static DWORD init_pastelist(HWND hdlg, OLEUIPASTESPECIALW *ps) |
| { |
| IEnumFORMATETC *penum; |
| HRESULT hr; |
| FORMATETC fmts[20]; |
| DWORD fetched, items_added = 0; |
| |
| hr = IDataObject_EnumFormatEtc(ps->lpSrcDataObj, DATADIR_GET, &penum); |
| if(FAILED(hr)) |
| { |
| WARN("Unable to create IEnumFORMATETC\n"); |
| return 0; |
| } |
| |
| /* The native version grabs only the first 20 fmts and we do the same */ |
| hr = IEnumFORMATETC_Next(penum, sizeof(fmts)/sizeof(fmts[0]), fmts, &fetched); |
| TRACE("got %d formats hr %08x\n", fetched, hr); |
| |
| if(SUCCEEDED(hr)) |
| { |
| DWORD src_fmt, req_fmt; |
| for(req_fmt = 0; req_fmt < ps->cPasteEntries; req_fmt++) |
| { |
| /* This is used by update_structure() to set nSelectedIndex on exit */ |
| ps->arrPasteEntries[req_fmt].dwScratchSpace = req_fmt; |
| TRACE("req_fmt %x\n", ps->arrPasteEntries[req_fmt].fmtetc.cfFormat); |
| for(src_fmt = 0; src_fmt < fetched; src_fmt++) |
| { |
| TRACE("\tenum'ed fmt %x\n", fmts[src_fmt].cfFormat); |
| if(ps->arrPasteEntries[req_fmt].fmtetc.cfFormat == fmts[src_fmt].cfFormat) |
| { |
| add_entry_to_lb(hdlg, IDC_PS_PASTELIST, ps->arrPasteEntries + req_fmt); |
| items_added++; |
| break; |
| } |
| } |
| } |
| } |
| |
| IEnumFORMATETC_Release(penum); |
| EnableWindow(GetDlgItem(hdlg, IDC_PS_PASTE), items_added != 0); |
| return items_added; |
| } |
| |
| static DWORD init_linklist(HWND hdlg, OLEUIPASTESPECIALW *ps) |
| { |
| HRESULT hr; |
| DWORD supported_mask = 0; |
| DWORD items_added = 0; |
| int link, req_fmt; |
| FORMATETC fmt = {0, NULL, DVASPECT_CONTENT, -1, -1}; |
| |
| for(link = 0; link < ps->cLinkTypes && link < PS_MAXLINKTYPES; link++) |
| { |
| fmt.cfFormat = ps->arrLinkTypes[link]; |
| hr = IDataObject_QueryGetData(ps->lpSrcDataObj, &fmt); |
| if(hr == S_OK) |
| supported_mask |= 1 << link; |
| } |
| TRACE("supported_mask %02x\n", supported_mask); |
| for(req_fmt = 0; req_fmt < ps->cPasteEntries; req_fmt++) |
| { |
| DWORD linktypes; |
| if(ps->arrPasteEntries[req_fmt].dwFlags & OLEUIPASTE_LINKANYTYPE) |
| linktypes = 0xff; |
| else |
| linktypes = ps->arrPasteEntries[req_fmt].dwFlags & 0xff; |
| |
| if(linktypes & supported_mask) |
| { |
| add_entry_to_lb(hdlg, IDC_PS_PASTELINKLIST, ps->arrPasteEntries + req_fmt); |
| items_added++; |
| } |
| } |
| |
| EnableWindow(GetDlgItem(hdlg, IDC_PS_PASTELINK), items_added != 0); |
| return items_added; |
| } |
| |
| /* copies src_list_id into the display list */ |
| static void update_display_list(HWND hdlg, UINT src_list_id) |
| { |
| LONG count, i, old_pos; |
| WCHAR txt[256]; |
| LONG item_data; |
| HWND display_list = GetDlgItem(hdlg, IDC_PS_DISPLAYLIST); |
| HWND list = GetDlgItem(hdlg, src_list_id); |
| |
| old_pos = SendMessageW(display_list, LB_GETCURSEL, 0, 0); |
| if(old_pos == -1) old_pos = 0; |
| |
| SendMessageW(display_list, WM_SETREDRAW, 0, 0); |
| SendMessageW(display_list, LB_RESETCONTENT, 0, 0); |
| count = SendMessageW(list, LB_GETCOUNT, 0, 0); |
| for(i = 0; i < count; i++) |
| { |
| SendMessageW(list, LB_GETTEXT, i, (LPARAM)txt); |
| item_data = SendMessageW(list, LB_GETITEMDATA, i, 0); |
| SendMessageW(display_list, LB_INSERTSTRING, i, (LPARAM)txt); |
| SendMessageW(display_list, LB_SETITEMDATA, i, item_data); |
| } |
| SendMessageW(display_list, LB_SETCURSEL, 0, 0); |
| SendMessageW(display_list, WM_SETREDRAW, 1, 0); |
| if(GetForegroundWindow() == hdlg) |
| SetFocus(display_list); |
| } |
| |
| static void init_lists(HWND hdlg, ps_struct_t *ps_struct) |
| { |
| DWORD pastes_added = init_pastelist(hdlg, ps_struct->ps); |
| DWORD links_added = init_linklist(hdlg, ps_struct->ps); |
| UINT check_id, list_id; |
| |
| if((ps_struct->flags & (PSF_SELECTPASTE | PSF_SELECTPASTELINK)) == 0) |
| ps_struct->flags |= PSF_SELECTPASTE; |
| |
| if(!pastes_added && !links_added) |
| ps_struct->flags &= ~(PSF_SELECTPASTE | PSF_SELECTPASTELINK); |
| else if(!pastes_added && (ps_struct->flags & PSF_SELECTPASTE)) |
| { |
| ps_struct->flags &= ~PSF_SELECTPASTE; |
| ps_struct->flags |= PSF_SELECTPASTELINK; |
| } |
| else if(!links_added && (ps_struct->flags & PSF_SELECTPASTELINK)) |
| { |
| ps_struct->flags &= ~PSF_SELECTPASTELINK; |
| ps_struct->flags |= PSF_SELECTPASTE; |
| } |
| |
| check_id = 0; |
| list_id = 0; |
| if(ps_struct->flags & PSF_SELECTPASTE) |
| { |
| check_id = IDC_PS_PASTE; |
| list_id = IDC_PS_PASTELIST; |
| } |
| else if(ps_struct->flags & PSF_SELECTPASTELINK) |
| { |
| check_id = IDC_PS_PASTELINK; |
| list_id = IDC_PS_PASTELINKLIST; |
| } |
| |
| CheckRadioButton(hdlg, IDC_PS_PASTE, IDC_PS_PASTELINK, check_id); |
| |
| if(list_id) |
| update_display_list(hdlg, list_id); |
| else |
| EnableWindow(GetDlgItem(hdlg, IDOK), 0); |
| } |
| |
| static void update_src_text(HWND hdlg, const ps_struct_t *ps_struct) |
| { |
| WCHAR *str; |
| |
| if(ps_struct->flags & PSF_SELECTPASTE) |
| { |
| if(ps_struct->source_name) |
| str = ps_struct->source_name; |
| else |
| str = ps_struct->link_source_name; |
| |
| } |
| else |
| { |
| if(ps_struct->link_source_name) |
| str = ps_struct->link_source_name; |
| else |
| str = ps_struct->source_name; |
| |
| } |
| SetDlgItemTextW(hdlg, IDC_PS_SOURCETEXT, str); |
| } |
| |
| static void update_as_icon(HWND hdlg, ps_struct_t *ps_struct) |
| { |
| HWND icon_display = GetDlgItem(hdlg, IDC_PS_ICONDISPLAY); |
| HWND display_as_icon = GetDlgItem(hdlg, IDC_PS_DISPLAYASICON); |
| HWND change_icon = GetDlgItem(hdlg, IDC_PS_CHANGEICON); |
| |
| /* FIXME. No as icon handling */ |
| ps_struct->flags &= ~PSF_CHECKDISPLAYASICON; |
| |
| CheckDlgButton(hdlg, IDC_PS_DISPLAYASICON, ps_struct->flags & PSF_CHECKDISPLAYASICON); |
| EnableWindow(display_as_icon, 0); |
| ShowWindow(icon_display, SW_HIDE); |
| EnableWindow(icon_display, 0); |
| ShowWindow(change_icon, SW_HIDE); |
| EnableWindow(change_icon, 0); |
| } |
| |
| static void update_result_text(HWND hdlg, const ps_struct_t *ps_struct) |
| { |
| WCHAR resource_txt[200]; |
| UINT res_id; |
| OLEUIPASTEENTRYW *pent; |
| LONG cur_sel; |
| static const WCHAR percent_s[] = {'%','s',0}; |
| WCHAR *result_txt, *ptr; |
| |
| cur_sel = SendMessageW(GetDlgItem(hdlg, IDC_PS_DISPLAYLIST), LB_GETCURSEL, 0, 0); |
| if(cur_sel == -1) return; |
| pent = (OLEUIPASTEENTRYW*)SendMessageW(GetDlgItem(hdlg, IDC_PS_DISPLAYLIST), LB_GETITEMDATA, cur_sel, 0); |
| |
| if(ps_struct->flags & PSF_SELECTPASTE) |
| { |
| if(ps_struct->flags & PSF_CHECKDISPLAYASICON) |
| res_id = IDS_PS_PASTE_OBJECT_AS_ICON; |
| else |
| res_id = IDS_PS_PASTE_DATA; |
| } |
| else |
| { |
| if(ps_struct->flags & PSF_CHECKDISPLAYASICON) |
| res_id = IDS_PS_PASTE_LINK_OBJECT_AS_ICON; |
| else |
| res_id = IDS_PS_PASTE_LINK_DATA; |
| } |
| |
| LoadStringW(OLEDLG_hInstance, res_id, resource_txt, sizeof(resource_txt)/sizeof(WCHAR)); |
| if((ptr = strstrW(resource_txt, percent_s))) |
| { |
| /* FIXME handle %s in ResultText. Sub appname if IDS_PS_PASTE_OBJECT{_AS_ICON}. Else sub appropriate type name */ |
| size_t result_txt_len = strlenW(pent->lpstrResultText); |
| ptrdiff_t offs = (char*)ptr - (char*)resource_txt; |
| result_txt = HeapAlloc(GetProcessHeap(), 0, (strlenW(resource_txt) + result_txt_len - 1) * sizeof(WCHAR)); |
| memcpy(result_txt, resource_txt, offs); |
| memcpy((char*)result_txt + offs, pent->lpstrResultText, result_txt_len * sizeof(WCHAR)); |
| memcpy((char*)result_txt + offs + result_txt_len * sizeof(WCHAR), ptr + 2, (strlenW(ptr + 2) + 1) * sizeof(WCHAR)); |
| } |
| else |
| result_txt = resource_txt; |
| |
| SetDlgItemTextW(hdlg, IDC_PS_RESULTTEXT, result_txt); |
| |
| if(result_txt != resource_txt) |
| HeapFree(GetProcessHeap(), 0, result_txt); |
| |
| } |
| |
| static void selection_change(HWND hdlg, ps_struct_t *ps_struct) |
| { |
| update_as_icon(hdlg, ps_struct); |
| update_result_text(hdlg, ps_struct); |
| } |
| |
| static void mode_change(HWND hdlg, ps_struct_t *ps_struct, UINT id) |
| { |
| if(id == IDC_PS_PASTE) |
| { |
| ps_struct->flags &= ~PSF_SELECTPASTELINK; |
| ps_struct->flags |= PSF_SELECTPASTE; |
| } |
| else |
| { |
| ps_struct->flags &= ~PSF_SELECTPASTE; |
| ps_struct->flags |= PSF_SELECTPASTELINK; |
| } |
| |
| update_src_text(hdlg, ps_struct); |
| update_display_list(hdlg, id == IDC_PS_PASTE ? IDC_PS_PASTELIST : IDC_PS_PASTELINKLIST); |
| selection_change(hdlg, ps_struct); |
| } |
| |
| static void post_help_msg(HWND hdlg, ps_struct_t *ps_struct) |
| { |
| PostMessageW(ps_struct->ps->hWndOwner, oleui_msg_help, (WPARAM)hdlg, IDD_PASTESPECIAL); |
| } |
| |
| static void send_end_dialog_msg(HWND hdlg, ps_struct_t *ps_struct, UINT id) |
| { |
| SendMessageW(hdlg, oleui_msg_enddialog, id, 0); |
| } |
| |
| static void update_structure(HWND hdlg, ps_struct_t *ps_struct) |
| { |
| LONG cur_sel = SendMessageW(GetDlgItem(hdlg, IDC_PS_DISPLAYLIST), LB_GETCURSEL, 0, 0); |
| if(cur_sel != -1) |
| { |
| OLEUIPASTEENTRYW *pent; |
| pent = (OLEUIPASTEENTRYW *)SendMessageW(GetDlgItem(hdlg, IDC_PS_DISPLAYLIST), LB_GETITEMDATA, cur_sel, 0); |
| ps_struct->ps->nSelectedIndex = pent->dwScratchSpace; |
| } |
| ps_struct->ps->dwFlags = ps_struct->flags; |
| ps_struct->ps->fLink = (ps_struct->flags & PSF_SELECTPASTELINK) != 0; |
| } |
| |
| static void free_structure(ps_struct_t *ps_struct) |
| { |
| HeapFree(GetProcessHeap(), 0, ps_struct->type_name); |
| HeapFree(GetProcessHeap(), 0, ps_struct->source_name); |
| HeapFree(GetProcessHeap(), 0, ps_struct->link_type_name); |
| HeapFree(GetProcessHeap(), 0, ps_struct->link_source_name); |
| CoTaskMemFree(ps_struct->app_name); |
| HeapFree(GetProcessHeap(), 0, ps_struct); |
| } |
| |
| static INT_PTR CALLBACK ps_dlg_proc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp) |
| { |
| /* native uses prop name "Structure", but we're not compatible |
| with that so we'll prepend "Wine_". */ |
| static const WCHAR prop_name[] = {'W','i','n','e','_','S','t','r','u','c','t','u','r','e',0}; |
| ps_struct_t *ps_struct; |
| |
| TRACE("(%p, %04x, %08lx, %08lx)\n", hdlg, msg, wp, lp); |
| |
| ps_struct = GetPropW(hdlg, prop_name); |
| |
| if(msg != WM_INITDIALOG) |
| { |
| if(!ps_struct) |
| return 0; |
| |
| if(ps_struct->ps->lpfnHook) |
| { |
| INT_PTR ret = ps_struct->ps->lpfnHook(hdlg, msg, wp, lp); |
| if(ret) return ret; |
| } |
| } |
| |
| switch(msg) |
| { |
| case WM_INITDIALOG: |
| { |
| ps_struct = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps_struct)); |
| ps_struct->ps = (OLEUIPASTESPECIALW*)lp; |
| ps_struct->type_name = NULL; |
| ps_struct->source_name = NULL; |
| ps_struct->link_type_name = NULL; |
| ps_struct->link_source_name = NULL; |
| ps_struct->app_name = NULL; |
| ps_struct->flags = ps_struct->ps->dwFlags; |
| |
| SetPropW(hdlg, prop_name, ps_struct); |
| |
| if(!(ps_struct->ps->dwFlags & PSF_SHOWHELP)) |
| { |
| ShowWindow(GetDlgItem(hdlg, IDC_OLEUIHELP), SW_HIDE); |
| EnableWindow(GetDlgItem(hdlg, IDC_OLEUIHELP), 0); |
| } |
| |
| if(ps_struct->ps->lpszCaption) |
| SetWindowTextW(hdlg, ps_struct->ps->lpszCaption); |
| |
| get_descriptors(hdlg, ps_struct); |
| |
| init_lists(hdlg, ps_struct); |
| |
| update_src_text(hdlg, ps_struct); |
| |
| selection_change(hdlg, ps_struct); |
| |
| SetFocus(GetDlgItem(hdlg, IDC_PS_DISPLAYLIST)); |
| |
| if(ps_struct->ps->lpfnHook) |
| ps_struct->ps->lpfnHook(hdlg, msg, 0, 0); |
| return FALSE; /* use new focus */ |
| } |
| case WM_COMMAND: |
| switch(LOWORD(wp)) |
| { |
| case IDC_PS_DISPLAYLIST: |
| switch(HIWORD(wp)) |
| { |
| case LBN_SELCHANGE: |
| selection_change(hdlg, ps_struct); |
| return FALSE; |
| default: |
| return FALSE; |
| } |
| case IDC_PS_PASTE: |
| case IDC_PS_PASTELINK: |
| switch(HIWORD(wp)) |
| { |
| case BN_CLICKED: |
| mode_change(hdlg, ps_struct, LOWORD(wp)); |
| return FALSE; |
| |
| default: |
| return FALSE; |
| } |
| case IDC_OLEUIHELP: |
| switch(HIWORD(wp)) |
| { |
| case BN_CLICKED: |
| post_help_msg(hdlg, ps_struct); |
| return FALSE; |
| default: |
| return FALSE; |
| } |
| case IDOK: |
| case IDCANCEL: |
| switch(HIWORD(wp)) |
| { |
| case BN_CLICKED: |
| send_end_dialog_msg(hdlg, ps_struct, LOWORD(wp)); |
| return FALSE; |
| default: |
| return FALSE; |
| } |
| } |
| return FALSE; |
| default: |
| if(msg == oleui_msg_enddialog) |
| { |
| if(wp == IDOK) |
| update_structure(hdlg, ps_struct); |
| EndDialog(hdlg, wp); |
| /* native does its cleanup in WM_DESTROY */ |
| RemovePropW(hdlg, prop_name); |
| free_structure(ps_struct); |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| } |
| |
| /*********************************************************************** |
| * OleUIPasteSpecialA (OLEDLG.4) |
| */ |
| UINT WINAPI OleUIPasteSpecialA(LPOLEUIPASTESPECIALA psA) |
| { |
| OLEUIPASTESPECIALW ps; |
| UINT ret; |
| TRACE("(%p)\n", psA); |
| |
| memcpy(&ps, psA, psA->cbStruct); |
| |
| ps.lpszCaption = strdupAtoW(psA->lpszCaption); |
| if(!IS_INTRESOURCE(ps.lpszTemplate)) |
| ps.lpszTemplate = strdupAtoW(psA->lpszTemplate); |
| |
| if(psA->cPasteEntries > 0) |
| { |
| DWORD size = psA->cPasteEntries * sizeof(ps.arrPasteEntries[0]); |
| INT i; |
| |
| ps.arrPasteEntries = HeapAlloc(GetProcessHeap(), 0, size); |
| memcpy(ps.arrPasteEntries, psA->arrPasteEntries, size); |
| for(i = 0; i < psA->cPasteEntries; i++) |
| { |
| ps.arrPasteEntries[i].lpstrFormatName = |
| strdupAtoW(psA->arrPasteEntries[i].lpstrFormatName); |
| ps.arrPasteEntries[i].lpstrResultText = |
| strdupAtoW(psA->arrPasteEntries[i].lpstrResultText); |
| } |
| } |
| |
| ret = OleUIPasteSpecialW(&ps); |
| |
| if(psA->cPasteEntries > 0) |
| { |
| INT i; |
| for(i = 0; i < psA->cPasteEntries; i++) |
| { |
| HeapFree(GetProcessHeap(), 0, (WCHAR*)ps.arrPasteEntries[i].lpstrFormatName); |
| HeapFree(GetProcessHeap(), 0, (WCHAR*)ps.arrPasteEntries[i].lpstrResultText); |
| } |
| HeapFree(GetProcessHeap(), 0, ps.arrPasteEntries); |
| } |
| if(!IS_INTRESOURCE(ps.lpszTemplate)) |
| HeapFree(GetProcessHeap(), 0, (WCHAR*)ps.lpszTemplate); |
| HeapFree(GetProcessHeap(), 0, (WCHAR*)ps.lpszCaption); |
| |
| /* Copy back the output fields */ |
| psA->dwFlags = ps.dwFlags; |
| psA->lpSrcDataObj = ps.lpSrcDataObj; |
| psA->nSelectedIndex = ps.nSelectedIndex; |
| psA->fLink = ps.fLink; |
| psA->hMetaPict = ps.hMetaPict; |
| psA->sizel = ps.sizel; |
| |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * OleUIPasteSpecialW (OLEDLG.22) |
| */ |
| UINT WINAPI OleUIPasteSpecialW(LPOLEUIPASTESPECIALW ps) |
| { |
| LPCDLGTEMPLATEW dlg_templ = (LPCDLGTEMPLATEW)ps->hResource; |
| UINT ret; |
| |
| TRACE("(%p)\n", ps); |
| |
| if(TRACE_ON(ole)) dump_pastespecial(ps); |
| |
| if(!ps->lpSrcDataObj) |
| OleGetClipboard(&ps->lpSrcDataObj); |
| |
| if(ps->hInstance || !ps->hResource) |
| { |
| HINSTANCE hInst = ps->hInstance ? ps->hInstance : OLEDLG_hInstance; |
| const WCHAR *name = ps->hInstance ? ps->lpszTemplate : MAKEINTRESOURCEW(IDD_PASTESPECIAL4); |
| HRSRC hrsrc; |
| |
| if(name == NULL) return OLEUI_ERR_LPSZTEMPLATEINVALID; |
| hrsrc = FindResourceW(hInst, name, (LPWSTR)RT_DIALOG); |
| if(!hrsrc) return OLEUI_ERR_FINDTEMPLATEFAILURE; |
| dlg_templ = LoadResource(hInst, hrsrc); |
| if(!dlg_templ) return OLEUI_ERR_LOADTEMPLATEFAILURE; |
| } |
| |
| ret = DialogBoxIndirectParamW(OLEDLG_hInstance, dlg_templ, ps->hWndOwner, ps_dlg_proc, (LPARAM)ps); |
| |
| return ret; |
| } |
