bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/dnd/HTMLTransfer.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2017 IBM Corporation and others.
   3  *
   4  * This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License 2.0
   6  * which accompanies this distribution, and is available at
   7  * https://www.eclipse.org/legal/epl-2.0/
   8  *
   9  * SPDX-License-Identifier: EPL-2.0
  10  *
  11  * Contributors:
  12  *     IBM Corporation - initial API and implementation
  13  *******************************************************************************/
  14 package org.eclipse.swt.dnd;
  15
  16 import org.eclipse.swt.internal.*;
  17 import org.eclipse.swt.internal.ole.win32.*;
  18 import org.eclipse.swt.internal.win32.*;
  19
  20 /**
  21  * The class <code>HTMLTransfer</code> provides a platform specific mechanism
  22  * for converting text in HTML format represented as a java <code>String</code>
  23  * to a platform specific representation of the data and vice versa.
  24  *
  25  * <p>An example of a java <code>String</code> containing HTML text is shown
  26  * below:</p>
  27  *
  28  * <pre><code>
  29  *     String htmlData = "&lt;p&gt;This is a paragraph of text.&lt;/p&gt;";
  30  * </code></pre>
  31  *
  32  * @see Transfer
  33  */
  34 public class HTMLTransfer extends ByteArrayTransfer {
  35
  36         static HTMLTransfer _instance = new HTMLTransfer();
  37         static final String HTML_FORMAT = "HTML Format"; //$NON-NLS-1$
  38         static final int HTML_FORMATID = registerType(HTML_FORMAT);
  39         static final String NUMBER = "00000000"; //$NON-NLS-1$
  40         static final String HEADER = "Version:0.9\r\nStartHTML:"+NUMBER+"\r\nEndHTML:"+NUMBER+"\r\nStartFragment:"+NUMBER+"\r\nEndFragment:"+NUMBER+"\r\n";
  41         static final String PREFIX = "<html><body><!--StartFragment-->"; //$NON-NLS-1$
  42         static final String SUFFIX = "<!--EndFragment--></body></html>"; //$NON-NLS-1$
  43         static final String StartFragment = "StartFragment:"; //$NON-NLS-1$
  44         static final String EndFragment = "EndFragment:"; //$NON-NLS-1$
  45
  46 private HTMLTransfer() {}
  47
  48 /**
  49  * Returns the singleton instance of the HTMLTransfer class.
  50  *
  51  * @return the singleton instance of the HTMLTransfer class
  52  */
  53 public static HTMLTransfer getInstance () {
  54         return _instance;
  55 }
  56
  57 /**
  58  * This implementation of <code>javaToNative</code> converts HTML-formatted text
  59  * represented by a java <code>String</code> to a platform specific representation.
  60  *
  61  * @param object a java <code>String</code> containing HTML text
  62  * @param transferData an empty <code>TransferData</code> object that will
  63  *      be filled in on return with the platform specific format of the data
  64  *
  65  * @see Transfer#nativeToJava
  66  */
  67 @Override
  68 public void javaToNative (Object object, TransferData transferData){
  69         if (!checkHTML(object) || !isSupportedType(transferData)) {
  70                 DND.error(DND.ERROR_INVALID_DATA);
  71         }
  72         String string = (String)object;
  73         int count = string.length();
  74         char[] chars = new char[count + 1];
  75         string.getChars(0, count, chars, 0);
  76         /* NOTE: CF_HTML uses UTF-8 encoding. */
  77         int cchMultiByte = OS.WideCharToMultiByte(OS.CP_UTF8, 0, chars, -1, null, 0, null, null);
  78         if (cchMultiByte == 0) {
  79                 transferData.stgmedium = new STGMEDIUM();
  80                 transferData.result = COM.DV_E_STGMEDIUM;
  81                 return;
  82         }
  83         int startHTML = HEADER.length();
  84         int startFragment = startHTML + PREFIX.length();
  85         int endFragment = startFragment + cchMultiByte - 1;
  86         int endHTML = endFragment + SUFFIX.length();
  87
  88         StringBuilder buffer = new StringBuilder(HEADER);
  89         int maxLength = NUMBER.length();
  90         //startHTML
  91         int start = buffer.toString().indexOf(NUMBER);
  92         String temp = Integer.toString(startHTML);
  93         buffer.replace(start + maxLength-temp.length(), start + maxLength, temp);
  94         //endHTML
  95         start = buffer.toString().indexOf(NUMBER, start);
  96         temp = Integer.toString(endHTML);
  97         buffer.replace(start + maxLength-temp.length(), start + maxLength, temp);
  98         //startFragment
  99         start = buffer.toString().indexOf(NUMBER, start);
 100         temp = Integer.toString(startFragment);
 101         buffer.replace(start + maxLength-temp.length(), start + maxLength, temp);
 102         //endFragment
 103         start = buffer.toString().indexOf(NUMBER, start);
 104         temp = Integer.toString(endFragment);
 105         buffer.replace(start + maxLength-temp.length(), start + maxLength, temp);
 106
 107         buffer.append(PREFIX);
 108         buffer.append(string);
 109         buffer.append(SUFFIX);
 110
 111         count = buffer.length();
 112         chars = new char[count + 1];
 113         buffer.getChars(0, count, chars, 0);
 114         cchMultiByte = OS.WideCharToMultiByte(OS.CP_UTF8, 0, chars, -1, null, 0, null, null);
 115         long lpMultiByteStr = OS.GlobalAlloc(OS.GMEM_FIXED | OS.GMEM_ZEROINIT, cchMultiByte);
 116         OS.WideCharToMultiByte(OS.CP_UTF8, 0, chars, -1, lpMultiByteStr, cchMultiByte, null, null);
 117         transferData.stgmedium = new STGMEDIUM();
 118         transferData.stgmedium.tymed = COM.TYMED_HGLOBAL;
 119         transferData.stgmedium.unionField = lpMultiByteStr;
 120         transferData.stgmedium.pUnkForRelease = 0;
 121         transferData.result = COM.S_OK;
 122         return;
 123 }
 124
 125 /**
 126  * This implementation of <code>nativeToJava</code> converts a platform specific
 127  * representation of HTML text to a java <code>String</code>.
 128  *
 129  * @param transferData the platform specific representation of the data to be converted
 130  * @return a java <code>String</code> containing HTML text if the conversion was successful;
 131  *              otherwise null
 132  *
 133  * @see Transfer#javaToNative
 134  */
 135 @Override
 136 public Object nativeToJava(TransferData transferData){
 137         if (!isSupportedType(transferData) || transferData.pIDataObject == 0) return null;
 138         IDataObject data = new IDataObject(transferData.pIDataObject);
 139         data.AddRef();
 140         STGMEDIUM stgmedium = new STGMEDIUM();
 141         FORMATETC formatetc = transferData.formatetc;
 142         stgmedium.tymed = COM.TYMED_HGLOBAL;
 143         transferData.result = getData(data, formatetc, stgmedium);
 144         data.Release();
 145         if (transferData.result != COM.S_OK) return null;
 146         long hMem = stgmedium.unionField;
 147
 148         try {
 149                 long lpMultiByteStr = OS.GlobalLock(hMem);
 150                 if (lpMultiByteStr == 0) return null;
 151                 try {
 152                         /* NOTE: CF_HTML uses UTF-8 encoding.
 153                          * The MSDN documentation for MultiByteToWideChar states that dwFlags must be set to 0 for UTF-8.
 154                          * Otherwise, the function fails with ERROR_INVALID_FLAGS. */
 155                         int cchWideChar  = OS.MultiByteToWideChar (OS.CP_UTF8, 0, lpMultiByteStr, -1, null, 0);
 156                         if (cchWideChar == 0) return null;
 157                         char[] lpWideCharStr = new char [cchWideChar - 1];
 158                         OS.MultiByteToWideChar (OS.CP_UTF8, 0, lpMultiByteStr, -1, lpWideCharStr, lpWideCharStr.length);
 159                         String string = new String(lpWideCharStr);
 160                         int fragmentStart = 0, fragmentEnd = 0;
 161                         int start = string.indexOf(StartFragment) + StartFragment.length();
 162                         int end = start + 1;
 163                         while (end < string.length()) {
 164                                 String s = string.substring(start, end);
 165                                 try {
 166                                         fragmentStart = Integer.parseInt(s);
 167                                         end++;
 168                                 } catch (NumberFormatException e) {
 169                                         break;
 170                                 }
 171                         }
 172                         start = string.indexOf(EndFragment) + EndFragment.length();
 173                         end = start + 1;
 174                         while (end < string.length()) {
 175                                 String s = string.substring(start, end);
 176                                 try {
 177                                         fragmentEnd = Integer.parseInt(s);
 178                                         end++;
 179                                 } catch (NumberFormatException e) {
 180                                         break;
 181                                 }
 182                         }
 183                         if (fragmentEnd <= fragmentStart || fragmentEnd > C.strlen(lpMultiByteStr)) return null;
 184                         cchWideChar = OS.MultiByteToWideChar (OS.CP_UTF8, 0, lpMultiByteStr+fragmentStart, fragmentEnd - fragmentStart, lpWideCharStr, lpWideCharStr.length);
 185                         if (cchWideChar == 0) return null;
 186                         String s = new String(lpWideCharStr, 0, cchWideChar);
 187                         /*
 188                          * Firefox includes <!--StartFragment --> in the fragment, so remove it.
 189                          */
 190                         String foxStart = "<!--StartFragment -->\r\n"; //$NON-NLS-1$
 191                         int prefix = s.indexOf(foxStart);
 192                         if (prefix != -1) {
 193                                 prefix += foxStart.length();
 194                                 s = s.substring(prefix);
 195                         }
 196                         return s;
 197                 } finally {
 198                         OS.GlobalUnlock(hMem);
 199                 }
 200         } finally {
 201                 OS.GlobalFree(hMem);
 202         }
 203 }
 204 @Override
 205 protected int[] getTypeIds(){
 206         return new int[] {HTML_FORMATID};
 207 }
 208 @Override
 209 protected String[] getTypeNames(){
 210         return new String[] {HTML_FORMAT};
 211 }
 212 boolean checkHTML(Object object) {
 213         return (object != null && object instanceof String && ((String)object).length() > 0);
 214 }
 215 @Override
 216 protected boolean validate(Object object) {
 217         return checkHTML(object);
 218 }
 219 }