Source/WebKit2/UIProcess/API/efl/tizen/ClipboardHelper.cpp

   1 /*
   2  * Copyright (C) 2012 Samsung Electronics
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27
  28 #if ENABLE(TIZEN_WEBKIT2_CLIPBOARD_HELPER)
  29 #include "ClipboardHelper.h"
  30
  31 #include "PageClientImpl.h"
  32 #include <Evas.h>
  33 #include <Ecore_Evas.h>
  34 #include <Ecore_X.h>
  35 #include <Elementary.h>
  36 #include <X11/Xatom.h>
  37 #include <X11/Xlib.h>
  38
  39 namespace WebKit {
  40
  41 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
  42 enum ClipType
  43 {
  44     CLIP_TYPE_PRIMARY,
  45     CLIP_TYPE_SECONDARY,
  46     CLIP_TYPE_CLIPBOARD,
  47     CLIP_TYPE_XDND,
  48     CLIP_TYPE_MAX,
  49 };
  50
  51 struct ClipData
  52 {
  53     Ecore_X_Selection selection;
  54     void (* request)(Ecore_X_Window window, const char* pTarget);
  55
  56     Elm_Sel_Format format;
  57
  58     Elm_Sel_Format requestedFormat;
  59     int bufferLength;
  60
  61     ClipboardHelper* clipboardHelper;
  62 };
  63
  64 typedef int (*ClipNotifyHandler)(ClipData* clipData, Ecore_X_Event_Selection_Notify* notifyData);
  65
  66 enum
  67 {
  68     ATOM_TARGETS = 0,
  69     ATOM_ATOM,
  70     ATOM_LISTING_ATOMS = ATOM_ATOM,
  71     ATOM_TEXT_URI,
  72     ATOM_TEXT_URILIST,
  73     ATOM_TEXT_X_VCARD,
  74     ATOM_IMAGE_PNG,
  75     ATOM_IMAGE_JPEG,
  76     ATOM_IMAGE_BMP,
  77     ATOM_IMAGE_GIF,
  78     ATOM_IMAGE_TIFF,
  79     ATOM_IMAGE_SVG,
  80     ATOM_IMAGE_XPM,
  81     ATOM_IMAGE_TGA,
  82     ATOM_IMAGE_PPM,
  83     ATOM_XELM,
  84     ATOM_TEXT_HTML_UTF8,
  85     ATOM_TEXT_HTML,
  86     ATOM_STRING_UTF8,
  87     ATOM_STRING,
  88     ATOM_TEXT,
  89     ATOM_TEXT_PLAIN_UTF8,
  90     ATOM_TEXT_PLAIN,
  91     ATOM_MAX,
  92 };
  93 struct AtomData
  94 {
  95     const char* pName;
  96     Elm_Sel_Format formats;
  97     ClipNotifyHandler notify;
  98     Ecore_X_Atom atom;
  99 };
 100
 101 AtomData atomList[ATOM_MAX];
 102 ClipData clipList[CLIP_TYPE_MAX];
 103
 104 static Eina_Bool cbhmPropertyChangeCallback(void* data, int type, void* event);
 105 static Eina_Bool clientMessageCallback(void* data, int type, void* event);
 106 #endif
 107
 108 ClipboardHelper::ClipboardHelper(EwkViewImpl* viewImpl)
 109     : m_viewImpl(viewImpl)
 110 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
 111     , m_clipboardWindowOpened(false)
 112     , m_cbhmPropertyChangeHandler(0)
 113     , m_selectionClearHandler(0)
 114     , m_selectionNotifyHandler(0)
 115     , m_clientMessageHandler(0)
 116 #endif
 117 {
 118 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
 119     m_clientMessageHandler = ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE, clientMessageCallback, this);
 120 #endif
 121 }
 122
 123 ClipboardHelper::~ClipboardHelper()
 124 {
 125 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
 126     ecore_event_handler_del(m_clientMessageHandler);
 127     m_clientMessageHandler = 0;
 128     clearClipboardSelectionHandler();
 129 #endif
 130 }
 131
 132 // This function references from elementary's cbhm_helper.c
 133 int ClipboardHelper::numberOfItems()
 134 {
 135     // 1. Get CBHM Ecore_X_Window.
 136     Ecore_X_Atom xAtom;
 137     xAtom = ecore_x_atom_get("CBHM_XWIN");
 138     if (!xAtom)
 139         return 0;
 140
 141     unsigned char* data = 0;
 142     int numberOfWindow = 0;
 143     int result = ecore_x_window_prop_property_get(0, xAtom, XA_WINDOW, 0, &data, &numberOfWindow);
 144
 145     Ecore_X_Window xWindow = 0;
 146     if (result && numberOfWindow)
 147         memcpy(&xWindow, data, sizeof(Ecore_X_Window));
 148
 149     if (data)
 150         free(data);
 151
 152     if (!xWindow)
 153         return 0;
 154
 155     ecore_x_sync();
 156
 157     // 2. Get number of clipboard items.
 158     xAtom = ecore_x_atom_get("CBHM_cCOUNT");
 159     if (!xAtom)
 160         return 0;
 161
 162     Display* display = static_cast<Display*>(ecore_x_display_get());
 163
 164     Ecore_X_Atom type;
 165     int format;
 166     long unsigned numberOfItems = 0;
 167     long unsigned bytes = 0;
 168     unsigned char* dataInFormat = 0;
 169     result = XGetWindowProperty(display, xWindow, xAtom, 0, LONG_MAX, False, ecore_x_window_prop_any_type(),
 170                                 reinterpret_cast<Atom*>(&type), &format, &numberOfItems, &bytes, &dataInFormat);
 171     if (result != Success)
 172         return 0;
 173
 174     if (!numberOfItems) {
 175         XFree(dataInFormat);
 176         return 0;
 177     }
 178
 179     if (!(data = static_cast<unsigned char*>(malloc(numberOfItems * format / 8)))) {
 180         XFree(dataInFormat);
 181         return 0;
 182     }
 183
 184     switch (format) {
 185     case 8:
 186         for (long unsigned i = 0; i < numberOfItems; i++)
 187             (data)[i] = dataInFormat[i];
 188         break;
 189     case 16:
 190         for (long unsigned i = 0; i < numberOfItems; i++)
 191             (reinterpret_cast<unsigned short*>(data))[i] = (reinterpret_cast<unsigned short*>(dataInFormat))[i];
 192         break;
 193     case 32:
 194         for (long unsigned i = 0; i < numberOfItems; i++)
 195             (reinterpret_cast<unsigned int*>(data))[i] = (reinterpret_cast<unsigned long*>(dataInFormat))[i];
 196         break;
 197     }
 198
 199     XFree(dataInFormat);
 200
 201     if (data) {
 202         char count = atoi(reinterpret_cast<const char*>(data));
 203         free(data);
 204         return count;
 205     }
 206
 207     return 0;
 208 }
 209
 210 void ClipboardHelper::setData(const String& data, const String& type)
 211 {
 212     Ecore_X_Atom dataType = 0;
 213
 214     if (type == "PlainText" || type == "URIList" || type == "URL")
 215         dataType = ecore_x_atom_get("UTF8_STRING");
 216     else if (type == "Markup")
 217         dataType = ecore_x_atom_get("text/html;charset=utf-8");
 218     else if (type == "Image") {
 219         elm_cnp_selection_set(elm_object_parent_widget_get(m_viewImpl->view()), ELM_SEL_TYPE_CLIPBOARD,
 220                               ELM_SEL_FORMAT_IMAGE, data.utf8().data(), data.length() + 1);
 221         return;
 222     }
 223
 224     setClipboardItem(dataType, data);
 225 }
 226
 227 void ClipboardHelper::clear()
 228 {
 229     elm_object_cnp_selection_clear(elm_object_parent_widget_get(m_viewImpl->view()), ELM_SEL_TYPE_CLIPBOARD);
 230 }
 231
 232 void ClipboardHelper::processResult(const String& data, const String& type)
 233 {
 234     MutexLocker locker(m_callbackQueueLock);
 235     while(!m_callbackQueue.isEmpty()) {
 236         RefPtr<ClipboardCallback> callback = m_callbackQueue.takeFirst();
 237         callback->performCallback(data, type);
 238     }
 239 }
 240
 241 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
 242 Eina_Bool cbhmPropertyChangeCallback(void* data, int type, void* event)
 243 {
 244     ClipboardHelper *clipboardHelper = static_cast<ClipboardHelper*>(data);
 245     Ecore_X_Event_Window_Property *ev = (Ecore_X_Event_Window_Property*) event;
 246
 247     if (ev->atom != ECORE_X_ATOM_E_ILLUME_CLIPBOARD_STATE)
 248         return ECORE_CALLBACK_PASS_ON;
 249
 250     clipboardHelper->updateClipboardWindowState(ev);
 251
 252     return ECORE_CALLBACK_PASS_ON;
 253 }
 254
 255 Eina_Bool clientMessageCallback(void* data, int type, void* event)
 256 {
 257     //This callback function is support for open CBHM window from IME clipboard button
 258     ClipboardHelper *clipboardHelper = static_cast<ClipboardHelper*>(data);
 259     Ecore_X_Event_Client_Message *ev = (Ecore_X_Event_Client_Message*) event;
 260
 261     if (ev->message_type != ecore_x_atom_get("CBHM_MSG"))
 262         return ECORE_CALLBACK_PASS_ON;
 263
 264     if (!strcmp("SET_OWNER", ev->data.b)) {
 265         clipboardHelper->openClipboardWindow(clipboardHelper->page()->editorState().isContentRichlyEditable);
 266     }
 267
 268     return ECORE_CALLBACK_PASS_ON;
 269 }
 270
 271 static void pasteSelectedClipboardItem(const String& data, const String& type, ClipboardHelper* clipboardHelper)
 272 {
 273     clipboardHelper->page()->executePasteFromClipboardItem(data, type);
 274
 275     clipboardHelper->connectClipboardWindow();
 276 }
 277
 278 static Eina_Bool clearClip(void* data, int type, void* event)
 279 {
 280     Ecore_X_Event_Selection_Clear* clearEvent = (Ecore_X_Event_Selection_Clear*) event;
 281     Ecore_X_Window window = clearEvent->win;
 282
 283     ClipType clipType = CLIP_TYPE_SECONDARY;
 284     clipList[clipType].requestedFormat = static_cast<Elm_Sel_Format>(ELM_SEL_FORMAT_TEXT | ELM_SEL_FORMAT_IMAGE);
 285
 286     ecore_x_selection_secondary_request(window, ECORE_X_SELECTION_TARGET_TARGETS);
 287
 288     return ECORE_CALLBACK_PASS_ON;
 289 }
 290
 291 static Eina_Bool notifyClip(void* data , int type, void* event)
 292 {
 293     Ecore_X_Event_Selection_Notify* notifytEvent = (Ecore_X_Event_Selection_Notify*) event;
 294
 295     int i = 0;
 296     for (i = 0; i < CLIP_TYPE_MAX; i++) {
 297         if (clipList[i].selection == notifytEvent->selection) {
 298             break;
 299         }
 300     }
 301
 302     ClipData* clipData = clipList + i;
 303
 304     clipData->clipboardHelper= static_cast<ClipboardHelper*>(data);
 305
 306     for (i = 0; i < ATOM_MAX; i++) {
 307         if (!strcmp(notifytEvent->target, atomList[i].pName)) {
 308             if (atomList[i].notify) {
 309                 atomList[i].notify(clipData, notifytEvent);
 310             }
 311         }
 312     }
 313
 314     return ECORE_CALLBACK_PASS_ON;
 315 }
 316
 317 static int notifyTarget(ClipData* clipData, Ecore_X_Event_Selection_Notify* notifyData)
 318 {
 319     Ecore_X_Atom dataType = 0;
 320
 321     if (clipData->clipboardHelper->getSelectedCbhmItem(&dataType)) {
 322         const char* pHtmlAtomName = "text/html;charset=utf-8";
 323         Ecore_X_Atom htmlType = ecore_x_atom_get(pHtmlAtomName);
 324
 325         if (dataType == htmlType) {
 326             clipData->request(notifyData->win, pHtmlAtomName);
 327             return ECORE_CALLBACK_PASS_ON;
 328         }
 329     }
 330
 331     Ecore_X_Selection_Data_Targets* pTargets = (Ecore_X_Selection_Data_Targets*) (notifyData->data);
 332     Ecore_X_Atom* pAtomList = (Ecore_X_Atom*) (pTargets->data.data);
 333
 334     int i, j = 0;
 335     for (j = (ATOM_LISTING_ATOMS+1); j < ATOM_MAX; j++) {
 336
 337         if (!(atomList[j].formats & clipData->requestedFormat))
 338             continue;
 339
 340         for (i = 0; i < pTargets->data.length; i++) {
 341             if ((atomList[j].atom == pAtomList[i]) && (atomList[j].notify)) {
 342                 if ((j == ATOM_XELM) && (!(clipData->requestedFormat & ELM_SEL_FORMAT_MARKUP)))
 343                     continue;
 344
 345                 goto FOUND;
 346             }
 347         }
 348     }
 349
 350     return ECORE_CALLBACK_PASS_ON;
 351
 352     FOUND:
 353     clipData->request(notifyData->win, atomList[j].pName);
 354     return ECORE_CALLBACK_PASS_ON;
 355 }
 356
 357 static int notifyText(ClipData* clipData, Ecore_X_Event_Selection_Notify* notifyData)
 358 {
 359     Ecore_X_Selection_Data* pData = (Ecore_X_Selection_Data*) notifyData->data;
 360     pasteSelectedClipboardItem(String::fromUTF8(pData->data, (int)pData->length), String("PlainText"), clipData->clipboardHelper);
 361
 362     return 0;
 363 }
 364
 365 static int notifyImage(ClipData* clipData, Ecore_X_Event_Selection_Notify* notifyData)
 366 {
 367     Ecore_X_Selection_Data* pData = (Ecore_X_Selection_Data*) notifyData->data;
 368     pasteSelectedClipboardItem(String::fromUTF8(pData->data, (int)pData->length), String("Image"), clipData->clipboardHelper);
 369
 370     return 0;
 371 }
 372
 373 static int notifyUri(ClipData* clipData, Ecore_X_Event_Selection_Notify* notifyData)
 374 {
 375     Ecore_X_Selection_Data* pData = (Ecore_X_Selection_Data*) notifyData->data;
 376     pasteSelectedClipboardItem(String::fromUTF8(pData->data, (int)pData->length), String("Image"), clipData->clipboardHelper);
 377
 378     return 0;
 379 }
 380
 381 static int notifyEdje(ClipData* clipData, Ecore_X_Event_Selection_Notify* notifyData)
 382 {
 383     Ecore_X_Selection_Data* pData = (Ecore_X_Selection_Data*) notifyData->data;
 384     pasteSelectedClipboardItem(String::fromUTF8(pData->data, (int)pData->length), String("PlainText"), clipData->clipboardHelper);
 385
 386     return 0;
 387 }
 388
 389 static int notifyHtml(ClipData* clipData, Ecore_X_Event_Selection_Notify* notifyData)
 390 {
 391     Ecore_X_Selection_Data* pData = (Ecore_X_Selection_Data*) notifyData->data;
 392     pasteSelectedClipboardItem(String::fromUTF8(pData->data, (int)pData->length), String("Markup"), clipData->clipboardHelper);
 393
 394     return 0;
 395 }
 396
 397 void ClipboardHelper::initializeAtomList()
 398 {
 399     atomList[ATOM_TARGETS].pName = "TARGETS";
 400     atomList[ATOM_TARGETS].formats = ELM_SEL_FORMAT_TARGETS;
 401     atomList[ATOM_TARGETS].notify = notifyTarget;
 402     atomList[ATOM_TARGETS].atom = 0;
 403
 404     atomList[ATOM_ATOM].pName = "ATOM";
 405     atomList[ATOM_ATOM].formats = ELM_SEL_FORMAT_TARGETS;
 406     atomList[ATOM_ATOM].notify = notifyTarget;
 407     atomList[ATOM_ATOM].atom = 0;
 408
 409     atomList[ATOM_XELM].pName = "application/x-elementary-markup";
 410     atomList[ATOM_XELM].formats = ELM_SEL_FORMAT_MARKUP;
 411     atomList[ATOM_XELM].notify = notifyEdje;
 412     atomList[ATOM_XELM].atom = 0;
 413
 414     atomList[ATOM_TEXT_URI].pName = "text/uri";
 415     atomList[ATOM_TEXT_URI].formats = ELM_SEL_FORMAT_IMAGE;
 416     atomList[ATOM_TEXT_URI].notify = notifyUri;
 417     atomList[ATOM_TEXT_URI].atom = 0;
 418
 419     atomList[ATOM_TEXT_URILIST].pName = "text/uri-list";
 420     atomList[ATOM_TEXT_URILIST].formats = ELM_SEL_FORMAT_IMAGE;
 421     atomList[ATOM_TEXT_URILIST].notify = notifyUri;
 422     atomList[ATOM_TEXT_URILIST].atom = 0;
 423
 424     atomList[ATOM_TEXT_X_VCARD].pName = "text/x-vcard";
 425     atomList[ATOM_TEXT_X_VCARD].formats = ELM_SEL_FORMAT_VCARD;
 426     atomList[ATOM_TEXT_X_VCARD].notify = 0;
 427     atomList[ATOM_TEXT_X_VCARD].atom = 0;
 428
 429     atomList[ATOM_IMAGE_PNG].pName = "image/png";
 430     atomList[ATOM_IMAGE_PNG].formats = ELM_SEL_FORMAT_IMAGE;
 431     atomList[ATOM_IMAGE_PNG].notify = notifyImage;
 432     atomList[ATOM_IMAGE_PNG].atom = 0;
 433
 434     atomList[ATOM_IMAGE_JPEG].pName = "image/jpeg";
 435     atomList[ATOM_IMAGE_JPEG].formats = ELM_SEL_FORMAT_IMAGE;
 436     atomList[ATOM_IMAGE_JPEG].notify = notifyImage;
 437     atomList[ATOM_IMAGE_JPEG].atom = 0;
 438
 439     atomList[ATOM_IMAGE_BMP].pName = "image/x-ms-bmp";
 440     atomList[ATOM_IMAGE_BMP].formats = ELM_SEL_FORMAT_IMAGE;
 441     atomList[ATOM_IMAGE_BMP].notify = notifyImage;
 442     atomList[ATOM_IMAGE_BMP].atom = 0;
 443
 444     atomList[ATOM_IMAGE_GIF].pName = "image/gif";
 445     atomList[ATOM_IMAGE_GIF].formats = ELM_SEL_FORMAT_IMAGE;
 446     atomList[ATOM_IMAGE_GIF].notify = notifyImage;
 447     atomList[ATOM_IMAGE_GIF].atom = 0;
 448
 449     atomList[ATOM_IMAGE_TIFF].pName = "image/tiff";
 450     atomList[ATOM_IMAGE_TIFF].formats = ELM_SEL_FORMAT_IMAGE;
 451     atomList[ATOM_IMAGE_TIFF].notify = notifyImage;
 452     atomList[ATOM_IMAGE_TIFF].atom = 0;
 453
 454     atomList[ATOM_IMAGE_SVG].pName = "image/svg+xml";
 455     atomList[ATOM_IMAGE_SVG].formats = ELM_SEL_FORMAT_IMAGE;
 456     atomList[ATOM_IMAGE_SVG].notify = notifyImage;
 457     atomList[ATOM_IMAGE_SVG].atom = 0;
 458
 459     atomList[ATOM_IMAGE_XPM].pName = "image/x-xpixmap";
 460     atomList[ATOM_IMAGE_XPM].formats = ELM_SEL_FORMAT_IMAGE;
 461     atomList[ATOM_IMAGE_XPM].notify = notifyImage;
 462     atomList[ATOM_IMAGE_XPM].atom = 0;
 463
 464     atomList[ATOM_IMAGE_TGA].pName = "image/x-tga";
 465     atomList[ATOM_IMAGE_TGA].formats = ELM_SEL_FORMAT_IMAGE;
 466     atomList[ATOM_IMAGE_TGA].notify = notifyImage;
 467     atomList[ATOM_IMAGE_TGA].atom = 0;
 468
 469     atomList[ATOM_IMAGE_PPM].pName = "image/x-portable-pixmap";
 470     atomList[ATOM_IMAGE_PPM].formats = ELM_SEL_FORMAT_IMAGE;
 471     atomList[ATOM_IMAGE_PPM].notify = notifyImage;
 472     atomList[ATOM_IMAGE_PPM].atom = 0;
 473
 474     atomList[ATOM_TEXT_HTML_UTF8].pName = "text/html;charset=utf-8";
 475     atomList[ATOM_TEXT_HTML_UTF8].formats = ELM_SEL_FORMAT_HTML;
 476     atomList[ATOM_TEXT_HTML_UTF8].notify = notifyHtml;
 477     atomList[ATOM_TEXT_HTML_UTF8].atom = 0;
 478
 479     atomList[ATOM_TEXT_HTML].pName = "text/html";
 480     atomList[ATOM_TEXT_HTML].formats = ELM_SEL_FORMAT_HTML;
 481     atomList[ATOM_TEXT_HTML].notify = notifyHtml;
 482     atomList[ATOM_TEXT_HTML].atom = 0;
 483
 484     atomList[ATOM_STRING_UTF8].pName = "UTF8_STRING";
 485     atomList[ATOM_STRING_UTF8].formats = static_cast<Elm_Sel_Format> (ELM_SEL_FORMAT_TEXT| ELM_SEL_FORMAT_MARKUP| ELM_SEL_FORMAT_HTML);
 486     atomList[ATOM_STRING_UTF8].notify = notifyText;
 487     atomList[ATOM_STRING_UTF8].atom = 0;
 488
 489     atomList[ATOM_STRING].pName = "STRING";
 490     atomList[ATOM_STRING].formats = static_cast<Elm_Sel_Format> (ELM_SEL_FORMAT_TEXT| ELM_SEL_FORMAT_MARKUP| ELM_SEL_FORMAT_HTML);
 491     atomList[ATOM_STRING].notify = notifyText;
 492     atomList[ATOM_STRING].atom = 0;
 493
 494     atomList[ATOM_TEXT].pName = "TEXT";
 495     atomList[ATOM_TEXT].formats = static_cast<Elm_Sel_Format> (ELM_SEL_FORMAT_TEXT| ELM_SEL_FORMAT_MARKUP| ELM_SEL_FORMAT_HTML);
 496     atomList[ATOM_TEXT].notify = 0;
 497     atomList[ATOM_TEXT].atom = 0;
 498
 499     atomList[ATOM_TEXT_PLAIN_UTF8].pName = "text/plain;charset=utf-8";
 500     atomList[ATOM_TEXT_PLAIN_UTF8].formats = static_cast<Elm_Sel_Format> (ELM_SEL_FORMAT_TEXT| ELM_SEL_FORMAT_MARKUP| ELM_SEL_FORMAT_HTML);
 501     atomList[ATOM_TEXT_PLAIN_UTF8].notify = 0;
 502     atomList[ATOM_TEXT_PLAIN_UTF8].atom = 0;
 503
 504     atomList[ATOM_TEXT_PLAIN].pName = "text/plain";
 505     atomList[ATOM_TEXT_PLAIN].formats = static_cast<Elm_Sel_Format> (ELM_SEL_FORMAT_TEXT| ELM_SEL_FORMAT_MARKUP| ELM_SEL_FORMAT_HTML);
 506     atomList[ATOM_TEXT_PLAIN].notify = 0;
 507     atomList[ATOM_TEXT_PLAIN].atom = 0;
 508
 509     clipList[CLIP_TYPE_PRIMARY].selection = ECORE_X_SELECTION_PRIMARY;
 510     clipList[CLIP_TYPE_PRIMARY].request = ecore_x_selection_primary_request;
 511     clipList[CLIP_TYPE_PRIMARY].bufferLength = 0;
 512
 513     clipList[CLIP_TYPE_SECONDARY].selection = ECORE_X_SELECTION_SECONDARY;
 514     clipList[CLIP_TYPE_SECONDARY].request = ecore_x_selection_secondary_request;
 515     clipList[CLIP_TYPE_SECONDARY].bufferLength = 0;
 516
 517     clipList[CLIP_TYPE_CLIPBOARD].selection = ECORE_X_SELECTION_CLIPBOARD;
 518     clipList[CLIP_TYPE_CLIPBOARD].request = ecore_x_selection_clipboard_request;
 519     clipList[CLIP_TYPE_CLIPBOARD].bufferLength = 0;
 520
 521     clipList[CLIP_TYPE_XDND].selection = ECORE_X_SELECTION_XDND;
 522     clipList[CLIP_TYPE_XDND].request = ecore_x_selection_xdnd_request;
 523     clipList[CLIP_TYPE_XDND].bufferLength = 0;
 524
 525     for (int i = 0; i < ATOM_MAX; i++)
 526         atomList[i].atom = ecore_x_atom_get(atomList[i].pName);
 527
 528     m_cbhmPropertyChangeHandler = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_PROPERTY, cbhmPropertyChangeCallback, this);
 529     m_selectionClearHandler = ecore_event_handler_add(ECORE_X_EVENT_SELECTION_CLEAR, clearClip, this);
 530     m_selectionNotifyHandler = ecore_event_handler_add(ECORE_X_EVENT_SELECTION_NOTIFY, notifyClip, this);
 531 }
 532
 533 Ecore_X_Window ClipboardHelper::getCbhmWindow()
 534 {
 535     Ecore_X_Atom xAtomCbhm = ecore_x_atom_get("CBHM_XWIN");
 536     Ecore_X_Window xCbhmWin = 0;
 537
 538     unsigned char* buf = 0;
 539     int num = 0;
 540     int ret = ecore_x_window_prop_property_get(0, xAtomCbhm, XA_WINDOW, 0, &buf, &num);
 541
 542     if (ret && num)
 543         memcpy(&xCbhmWin, buf, sizeof(Ecore_X_Window));
 544
 545     if (buf)
 546         free(buf);
 547
 548     return xCbhmWin;
 549 }
 550
 551 bool ClipboardHelper::sendCbhmMessage(String message)
 552 {
 553     Ecore_X_Window xCbhmWin = getCbhmWindow();
 554     Ecore_X_Atom xAtomCbhmMsg = ecore_x_atom_get("CBHM_MSG");
 555
 556     if (!m_viewImpl->view())
 557         return false;
 558
 559     Evas_Object* parent = elm_object_parent_widget_get(m_viewImpl->view());
 560
 561     if (!parent)
 562         return false;
 563
 564     Ecore_X_Window xWin = ecore_evas_gl_x11_window_get(ecore_evas_ecore_evas_get(evas_object_evas_get(parent)));
 565     if (!xWin)
 566         xWin = ecore_evas_software_x11_window_get(ecore_evas_ecore_evas_get(evas_object_evas_get(parent)));
 567
 568     if (!xCbhmWin || !xAtomCbhmMsg)
 569         return false;
 570
 571     XClientMessageEvent messageEvent;
 572     memset(&messageEvent, 0, sizeof(messageEvent));
 573     messageEvent.type = ClientMessage;
 574     messageEvent.display = static_cast<Display *> (ecore_x_display_get());
 575     messageEvent.window = xWin;
 576     messageEvent.message_type = xAtomCbhmMsg;
 577     messageEvent.format = 8;
 578     snprintf(messageEvent.data.b, 20, "%s", message.utf8().data());
 579
 580     XSendEvent(static_cast<Display *> (ecore_x_display_get()), xCbhmWin, false, NoEventMask, (XEvent*)&messageEvent);
 581
 582     ecore_x_sync();
 583
 584     return true;
 585 }
 586
 587 bool ClipboardHelper::setClipboardItem(Ecore_X_Atom dataType,const String& data)
 588 {
 589     Ecore_X_Window cbhmWin = getCbhmWindow();
 590     Ecore_X_Atom atomCbhmItem = ecore_x_atom_get("CBHM_ITEM");
 591
 592     CString utfData = data.utf8();
 593
 594     ecore_x_sync();
 595     ecore_x_window_prop_property_set(cbhmWin, atomCbhmItem, dataType, 8, const_cast<char*>(utfData.data()), utfData.length() + 1);
 596     ecore_x_sync();
 597
 598     if (sendCbhmMessage(String::fromUTF8(static_cast<const char*>("SET_ITEM"))))
 599         return true;
 600
 601     return false;
 602 }
 603
 604 void ClipboardHelper::openClipboardWindow(bool isContentRichlyEditable)
 605 {
 606     if (!isClipboardWindowOpened())
 607         clearClipboardSelectionHandler();
 608
 609     initializeAtomList();
 610     if (isContentRichlyEditable)
 611         sendCbhmMessage(String::fromUTF8(static_cast<const char*>("show1")));
 612     else
 613         sendCbhmMessage(String::fromUTF8(static_cast<const char*>("show0")));
 614
 615     connectClipboardWindow();
 616
 617     evas_object_smart_callback_call(m_viewImpl->view(), "clipboard,opened", 0);
 618
 619 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 620     m_viewImpl->pageClient->updateTextSelectionHandlesAndContextMenu(false);
 621 #endif
 622 }
 623
 624 void ClipboardHelper::closeClipboardWindow()
 625 {
 626     sendCbhmMessage(String::fromUTF8(static_cast<const char*>("cbhm_hide")));
 627 }
 628
 629 bool ClipboardHelper::isClipboardWindowOpened()
 630 {
 631     return m_clipboardWindowOpened;
 632 }
 633
 634 void ClipboardHelper::connectClipboardWindow()
 635 {
 636     ecore_x_selection_secondary_set(elm_win_xwindow_get(elm_object_parent_widget_get(m_viewImpl->view())), "",1);
 637 }
 638
 639 void ClipboardHelper::clearClipboardSelectionHandler()
 640 {
 641     if (m_selectionClearHandler) {
 642         ecore_event_handler_del(m_selectionClearHandler);
 643         m_selectionClearHandler = 0;
 644     }
 645     if (m_selectionNotifyHandler) {
 646         ecore_event_handler_del(m_selectionNotifyHandler);
 647         m_selectionNotifyHandler = 0;
 648     }
 649     if (m_cbhmPropertyChangeHandler) {
 650         ecore_event_handler_del(m_cbhmPropertyChangeHandler);
 651         m_cbhmPropertyChangeHandler = 0;
 652     }
 653     m_clipboardWindowOpened = false;
 654 }
 655
 656 bool ClipboardHelper::getSelectedCbhmItem(Ecore_X_Atom* pDataType)
 657 {
 658     Ecore_X_Window cbhmWin = getCbhmWindow();
 659     Ecore_X_Atom atomCbhmItem = ecore_x_atom_get("CBHM_SELECTED_ITEM");
 660     Ecore_X_Atom atomItemType = 0;
 661
 662     String result = getCbhmReply(cbhmWin, atomCbhmItem, &atomItemType);
 663
 664     if(result.isNull())
 665         return false;
 666
 667     if (atomItemType == ecore_x_atom_get("CBHM_ERROR"))
 668         return false;
 669
 670     if (pDataType)
 671         *pDataType = atomItemType;
 672
 673     return true;
 674 }
 675
 676 String ClipboardHelper::getCbhmReply(Ecore_X_Window xwin, Ecore_X_Atom property, Ecore_X_Atom* pDataType)
 677 {
 678     if (!property)
 679         return String();
 680
 681     ecore_x_sync();
 682
 683     Ecore_X_Atom type;
 684     int dataUnitSize = 0;
 685     long unsigned int dataLength = 0;
 686     long unsigned int bytes = 0;
 687     unsigned char* pData = 0;
 688
 689     int result = XGetWindowProperty((Display*)ecore_x_display_get(), xwin, property, 0, LONG_MAX, False,
 690                                  ecore_x_window_prop_any_type(), (Atom*)&type, &dataUnitSize, &dataLength, &bytes, &pData);
 691     if (result != Success)
 692         return String();
 693
 694     if (!dataLength) {
 695         XFree(pData);
 696         return String();
 697     }
 698
 699     String chbmData;
 700
 701     switch (dataUnitSize) {
 702     case 8:
 703         chbmData = String::fromUTF8(pData, dataLength);
 704         break;
 705     case 16:
 706         chbmData = String(reinterpret_cast<UChar*>(pData), dataLength);
 707         LOG_ERROR("case 16");
 708         break;
 709     case 32:
 710         LOG_ERROR("case 32");
 711         break;
 712     default:
 713         LOG_ERROR("case %d", dataUnitSize);
 714     }
 715
 716     XFree(pData);
 717
 718     if (pDataType)
 719         *pDataType = type;
 720
 721     return chbmData;
 722 }
 723
 724 bool ClipboardHelper::retrieveClipboardItem(int index, int* format, String* pData)
 725 {
 726     if (!pData)
 727         return false;
 728
 729     Ecore_X_Window cbhmWin = getCbhmWindow();
 730
 731     Ecore_X_Atom atomCbhmItem = ecore_x_atom_get(String::format("CBHM_ITEM%d", index).utf8().data());
 732     Ecore_X_Atom atomItemType = 0;
 733
 734     String result = getCbhmReply(cbhmWin, atomCbhmItem, &atomItemType);
 735     if (result.isNull())
 736         return false;
 737
 738     *pData = result;
 739
 740     Ecore_X_Atom dataType = atomItemType;
 741
 742     if (atomItemType == ecore_x_atom_get("CBHM_ERROR"))
 743         return false;
 744
 745     if ((dataType == ecore_x_atom_get("UTF8_STRING")) || (dataType == ecore_x_atom_get("application/x-elementary-markup")))
 746         *format = ELM_SEL_FORMAT_TEXT;
 747     else if (dataType == ecore_x_atom_get("text/uri"))
 748         *format = ELM_SEL_FORMAT_IMAGE;
 749     else if (dataType == ecore_x_atom_get("text/html;charset=utf-8"))
 750         *format = ELM_SEL_FORMAT_HTML;
 751     else
 752         return false;
 753
 754     return true;
 755 }
 756
 757 void ClipboardHelper::pasteClipboardLastItem(bool isContentEditable)
 758 {
 759     int count = numberOfItems();
 760
 761     // Find the item with dataTypes.
 762     int format = ELM_SEL_FORMAT_NONE;
 763     String clipboardData;
 764
 765     for (int i = 0; i < count; i++) {
 766         // Get the clip with index.
 767         bool ret = retrieveClipboardItem(i, &format, &clipboardData);
 768
 769         if (!ret)
 770             continue;
 771
 772         if (isContentEditable)
 773             break;
 774         else {
 775             if (format == ELM_SEL_FORMAT_TEXT || format == ELM_SEL_FORMAT_MARKUP || format == ELM_SEL_FORMAT_HTML)
 776                 break;
 777         }
 778     }
 779
 780     switch(format) {
 781     case ELM_SEL_FORMAT_TEXT:
 782     case ELM_SEL_FORMAT_MARKUP:
 783         page()->didSelectPasteMenuFromContextMenu(clipboardData, String("PlainText"));
 784         break;
 785     case ELM_SEL_FORMAT_HTML:
 786         page()->didSelectPasteMenuFromContextMenu(clipboardData, String("Markup"));
 787         break;
 788     case ELM_SEL_FORMAT_IMAGE:
 789         page()->didSelectPasteMenuFromContextMenu(clipboardData, String("Image"));
 790         break;
 791     default:
 792         page()->didSelectPasteMenuFromContextMenu(String(""), String("PlainText"));
 793         break;
 794     }
 795 }
 796
 797 void ClipboardHelper::updateClipboardWindowState(Ecore_X_Event_Window_Property* ev)
 798 {
 799     Ecore_X_Illume_Clipboard_State state = ecore_x_e_illume_clipboard_state_get(ev->win);
 800
 801     if (state == ECORE_X_ILLUME_CLIPBOARD_STATE_UNKNOWN)
 802         state = ecore_x_e_illume_clipboard_state_get(ev->win);
 803
 804     if (state == ECORE_X_ILLUME_CLIPBOARD_STATE_OFF)
 805         clearClipboardSelectionHandler();
 806     else if (state == ECORE_X_ILLUME_CLIPBOARD_STATE_ON)
 807         m_clipboardWindowOpened = true;
 808 }
 809 #endif // TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD
 810 }// namespace WebKit
 811
 812 #endif // TIZEN_WEBKIT2_CLIPBOARD_HELPER