View Background Image Feature

webkit/glue/context_menu_client_impl.cc

 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "base/compiler_specific.h"
 
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "ContextMenu.h"
 #include "Document.h"
 #include "DocumentLoader.h"
 #include "Editor.h"
 #include "EventHandler.h"
 #include "FrameLoader.h"
 #include "FrameView.h"
+#include "CSSMutableStyleDeclaration.h"
+#include "CSSPrimitiveValue.h"
+#include "CSSProperty.h"
+#include "CSSStyleSelector.h"
+#include "CSSValue.h"
+#include "CSSValueKeywords.h"
+#include "CSSImageValue.h"
 #include "HitTestResult.h"
 #include "HTMLMediaElement.h"
 #include "HTMLNames.h"
 #include "KURL.h"
 #include "Widget.h"
 MSVC_POP_WARNING();
 #undef LOG
 
 #include "webkit/glue/context_menu_client_impl.h"
 
 #include "base/string_util.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLResponse.h"
 #include "webkit/glue/context_menu.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webdatasource_impl.h"
 #include "webkit/glue/webview_impl.h"
 
 #include "base/word_iterator.h"
 
+using namespace WebCore;
 using WebKit::WebDataSource;
 
 namespace {
 
 // Helper function to determine whether text is a single word or a sentence.
 bool IsASingleWord(const std::wstring& text) {
   WordIterator iter(text, WordIterator::BREAK_WORD);
   int word_count = 0;
   if (!iter.Init()) return false;
   while (iter.Advance()) {
@@ skipping 116 matching lines @@
       selected_frame->view()->contentsToWindow(r.point());
 
   ContextNodeType node_type;
 
   // Links, Images, Media tags, and Image/Media-Links take preference over
   // all else.
   WebCore::KURL link_url = r.absoluteLinkURL();
   if (!link_url.isEmpty()) {
     node_type.type |= ContextNodeType::LINK;
   }
-
   WebCore::KURL src_url;
 
   ContextMenuMediaParams media_params;
+  GURL bkg_url;
 
   if (!r.absoluteImageURL().isEmpty()) {
     src_url = r.absoluteImageURL();
     node_type.type |= ContextNodeType::IMAGE;
   } else if (!r.absoluteMediaURL().isEmpty()) {
     src_url = r.absoluteMediaURL();
-          
+
     // We know that if absoluteMediaURL() is not empty, then this is a media
     // element.
     WebCore::HTMLMediaElement* media_element =
         static_cast<WebCore::HTMLMediaElement*>(r.innerNonSharedNode());
     if (media_element->hasTagName(WebCore::HTMLNames::videoTag)) {
       node_type.type |= ContextNodeType::VIDEO;
     } else if (media_element->hasTagName(WebCore::HTMLNames::audioTag)) {
       node_type.type |= ContextNodeType::AUDIO;
     }
 
     media_params.playback_rate = media_element->playbackRate();
 
     if (media_element->paused()) {
       media_params.player_state |= ContextMenuMediaParams::PAUSED;
     }
     if (media_element->muted()) {
       media_params.player_state |= ContextMenuMediaParams::MUTED;
     }
     if (media_element->loop()) {
       media_params.player_state |= ContextMenuMediaParams::LOOP;
     }
     if (media_element->supportsSave()) {
       media_params.player_state |= ContextMenuMediaParams::CAN_SAVE;
     }
     // TODO(ajwong): Report error states in the media player.
   }
+  else {
+    //looks to see if the node we're clicking on contains a background image
+    //since the media inspection was done I figured we could
+    //apply that to the background image
+    WebCore::HTMLElement* gen_element =
+      static_cast<WebCore::HTMLElement*>(r.innerNonSharedNode());
+
+    //for now just take the inline style. The end solution will merge with the element in the css doc.
+    RefPtr<WebCore::CSSMutableStyleDeclaration> decl = gen_element->getInlineStyleDecl()->copy();
+    WebCore::CSSMutableStyleDeclarationConstIterator end = decl->end();
+
+    //this is a dumb loop in the sense that I'm just looking for any property that
+    //supports an image value.
+    //
+    //Will need to make this better going forward
+    for(WebCore::CSSMutableStyleDeclarationConstIterator it = decl->begin(); it != end; ++it) {
+      const WebCore::CSSProperty& prop = *it;
+      WebCore::CSSValue* val = prop.value();
+
+      //wasn't sure the difference between isImageGeneratorValue or isImageValue
+      //appears isImageValue returns true for what we need, but I'm lumping the
+      //other in here for now.
+      if ((val->isImageGeneratorValue()) || (val->isImageValue())) {
+        WebCore::CSSImageValue* imgVal =
+          static_cast<WebCore::CSSImageValue*>(val);
+
+        //this is nice. well done.
+        bkg_url = webkit_glue::StringToGURL(imgVal->getStringValue());
+      }
+    }
+  }
 
   // If it's not a link, an image, a media element, or an image/media link,
   // show a selection menu or a more generic page menu.
   std::wstring selection_text_string;
   std::wstring misspelled_word_string;
   GURL frame_url;
   GURL page_url;
   std::string security_info;
 
   std::string frame_charset = WideToASCII(
       webkit_glue::StringToStdWString(selected_frame->loader()->encoding()));
+
+
   // Send the frame and page URLs in any case.
   ContextNodeType frame_node = ContextNodeType(ContextNodeType::NONE);
   ContextNodeType page_node =
       GetTypeAndURLFromFrame(webview_->main_frame()->frame(),
                              &page_url,
                              ContextNodeType(ContextNodeType::PAGE));
+
+
   if (selected_frame != webview_->main_frame()->frame()) {
     frame_node =
       GetTypeAndURLFromFrame(selected_frame,
           &frame_url,
           ContextNodeType(ContextNodeType::FRAME));
   }
 
   if (r.isSelected()) {
     node_type.type |= ContextNodeType::SELECTION;
     selection_text_string = CollapseWhitespace(
@@ skipping 43 matching lines @@
   WebViewDelegate* d = webview_->delegate();
   if (d) {
     d->ShowContextMenu(webview_,
                        node_type,
                        menu_point.x(),
                        menu_point.y(),
                        webkit_glue::KURLToGURL(link_url),
                        webkit_glue::KURLToGURL(src_url),
                        page_url,
                        frame_url,
+                       bkg_url,
                        media_params,
                        selection_text_string,
                        misspelled_word_string,
                        edit_flags,
                        security_info,
                        frame_charset);
   }
   return NULL;
 }
 
@@ skipping 20 matching lines @@
   return false;
 }
 
 void ContextMenuClientImpl::stopSpeaking() {
 }
 
 bool ContextMenuClientImpl::shouldIncludeInspectElementItem() {
     return false;  // TODO(jackson): Eventually include the inspector context menu item
 }
 
+
+
 #if defined(OS_MACOSX)
 void ContextMenuClientImpl::searchWithSpotlight() {
   // TODO(pinkerton): write this
 }
 #endif
+
+