bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Significant API changes for issue #218:

Browse Source 
- Replace CefHandler with a new CefClient interface and separate handler interfaces.
- Add support for virtual inheritance to allow multiple CefBase parented interfaces to be implemented in the same class.
- Replace CefThreadSafeBase with IMPLEMENT_* macros to support virtual inheritance and to only provide locking implementations when needed.
- Move the CefBrowserSettings parameter from CefInitialize to CreateBrowser.
- Add a new cef_build.h header that provides platform-specific and OS_* defines.
- Introduce the use of OVERRIDE to generate compiler errors on Windows if a child virtual method declaration doesn't match the parent declaration.
- Use NDEBUG instead of _DEBUG because _DEBUG is not defined on Mac. (issue #240).

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@235 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt
2011-05-20 14:42:25 +00:00
parent 9a69e96950
commit dbe8de277f
251 changed files with 7127 additions and 4945 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
libcef_dll/ctocpp/base_ctocpp.h
View File

@@ -11,7 +11,7 @@
// CefCToCpp implementation for CefBase.
class CefBaseCToCpp : public CefThreadSafeBase<CefBase>
class CefBaseCToCpp : public CefBase
{
public:
// Use this method to create a wrapper class instance for a structure
@@ -56,16 +56,20 @@ public:
// CefBase methods increment/decrement reference counts on both this object
// and the underlying wrapped structure.
virtual int AddRef()
int AddRef()
{
UnderlyingAddRef();
return CefThreadSafeBase<CefBase>::AddRef();
return refct_.AddRef();
}
virtual int Release()
int Release()
{
UnderlyingRelease();
return CefThreadSafeBase<CefBase>::Release();
int retval = refct_.Release();
if (retval == 0)
delete this;
return retval;
}
int GetRefCt() { return refct_.GetRefCt(); }
// Increment/decrement reference counts on only the underlying class.
int UnderlyingAddRef()
@@ -88,6 +92,7 @@ public:
}
protected:
CefRefCount refct_;
cef_base_t* struct_;
};

32
libcef_dll/ctocpp/browser_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -10,7 +10,7 @@
// tools directory for more information.
//
#include "libcef_dll/cpptoc/handler_cpptoc.h"
#include "libcef_dll/cpptoc/client_cpptoc.h"
#include "libcef_dll/ctocpp/browser_ctocpp.h"
#include "libcef_dll/ctocpp/frame_ctocpp.h"
#include "libcef_dll/transfer_util.h"
@@ -18,18 +18,20 @@
// STATIC METHODS - Body may be edited by hand.
bool CefBrowser::CreateBrowser(CefWindowInfo& windowInfo, bool popup,
CefRefPtr<CefHandler> handler, const CefString& url)
bool CefBrowser::CreateBrowser(CefWindowInfo& windowInfo,
CefRefPtr<CefClient> client, const CefString& url,
const CefBrowserSettings& settings)
{
return cef_browser_create(&windowInfo, popup, CefHandlerCppToC::Wrap(handler),
url.GetStruct())?true:false;
return cef_browser_create(&windowInfo, CefClientCppToC::Wrap(client),
url.GetStruct(), &settings)?true:false;
}
CefRefPtr<CefBrowser> CefBrowser::CreateBrowserSync(CefWindowInfo& windowInfo,
bool popup, CefRefPtr<CefHandler> handler, const CefString& url)
CefRefPtr<CefClient> client, const CefString& url,
const CefBrowserSettings& settings)
{
cef_browser_t* impl = cef_browser_create_sync(&windowInfo, popup,
CefHandlerCppToC::Wrap(handler), url.GetStruct());
cef_browser_t* impl = cef_browser_create_sync(&windowInfo,
CefClientCppToC::Wrap(client), url.GetStruct(), &settings);
if(impl)
return CefBrowserCToCpp::Wrap(impl);
return NULL;
@@ -126,14 +128,14 @@ bool CefBrowserCToCpp::IsPopup()
return struct_->is_popup(struct_)?true:false;
}
CefRefPtr<CefHandler> CefBrowserCToCpp::GetHandler()
CefRefPtr<CefClient> CefBrowserCToCpp::GetClient()
{
if(CEF_MEMBER_MISSING(struct_, get_handler))
if (CEF_MEMBER_MISSING(struct_, get_client))
return NULL;
cef_handler_t* handlerStruct = struct_->get_handler(struct_);
if(handlerStruct)
return CefHandlerCppToC::Unwrap(handlerStruct);
cef_client_t* clientStruct = struct_->get_client(struct_);
if(clientStruct)
return CefClientCppToC::Unwrap(clientStruct);
return NULL;
}
@@ -341,7 +343,7 @@ void CefBrowserCToCpp::SendCaptureLostEvent()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefBrowserCToCpp, CefBrowser,
cef_browser_t>::DebugObjCt = 0;
#endif

72
libcef_dll/ctocpp/browser_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,45 +31,45 @@ public:
virtual ~CefBrowserCToCpp() {}
// CefBrowser methods
virtual void CloseBrowser();
virtual bool CanGoBack();
virtual void GoBack();
virtual bool CanGoForward();
virtual void GoForward();
virtual void Reload();
virtual void ReloadIgnoreCache();
virtual void StopLoad();
virtual void SetFocus(bool enable);
virtual CefWindowHandle GetWindowHandle();
virtual bool IsPopup();
virtual CefRefPtr<CefHandler> GetHandler();
virtual CefRefPtr<CefFrame> GetMainFrame();
virtual CefRefPtr<CefFrame> GetFocusedFrame();
virtual CefRefPtr<CefFrame> GetFrame(const CefString& name);
virtual void GetFrameNames(std::vector<CefString>& names);
virtual void CloseBrowser() OVERRIDE;
virtual bool CanGoBack() OVERRIDE;
virtual void GoBack() OVERRIDE;
virtual bool CanGoForward() OVERRIDE;
virtual void GoForward() OVERRIDE;
virtual void Reload() OVERRIDE;
virtual void ReloadIgnoreCache() OVERRIDE;
virtual void StopLoad() OVERRIDE;
virtual void SetFocus(bool enable) OVERRIDE;
virtual CefWindowHandle GetWindowHandle() OVERRIDE;
virtual bool IsPopup() OVERRIDE;
virtual CefRefPtr<CefClient> GetClient() OVERRIDE;
virtual CefRefPtr<CefFrame> GetMainFrame() OVERRIDE;
virtual CefRefPtr<CefFrame> GetFocusedFrame() OVERRIDE;
virtual CefRefPtr<CefFrame> GetFrame(const CefString& name) OVERRIDE;
virtual void GetFrameNames(std::vector<CefString>& names) OVERRIDE;
virtual void Find(int identifier, const CefString& searchText, bool forward,
bool matchCase, bool findNext);
virtual void StopFinding(bool clearSelection);
virtual double GetZoomLevel();
virtual void SetZoomLevel(double zoomLevel);
virtual void ShowDevTools();
virtual void CloseDevTools();
virtual bool IsWindowRenderingDisabled();
virtual bool GetSize(PaintElementType type, int& width, int& height);
virtual void SetSize(PaintElementType type, int width, int height);
virtual bool IsPopupVisible();
virtual void HidePopup();
virtual void Invalidate(const CefRect& dirtyRect);
bool matchCase, bool findNext) OVERRIDE;
virtual void StopFinding(bool clearSelection) OVERRIDE;
virtual double GetZoomLevel() OVERRIDE;
virtual void SetZoomLevel(double zoomLevel) OVERRIDE;
virtual void ShowDevTools() OVERRIDE;
virtual void CloseDevTools() OVERRIDE;
virtual bool IsWindowRenderingDisabled() OVERRIDE;
virtual bool GetSize(PaintElementType type, int& width, int& height) OVERRIDE;
virtual void SetSize(PaintElementType type, int width, int height) OVERRIDE;
virtual bool IsPopupVisible() OVERRIDE;
virtual void HidePopup() OVERRIDE;
virtual void Invalidate(const CefRect& dirtyRect) OVERRIDE;
virtual bool GetImage(PaintElementType type, int width, int height,
void* buffer);
void* buffer) OVERRIDE;
virtual void SendKeyEvent(KeyType type, int key, int modifiers, bool sysChar,
bool imeChar);
bool imeChar) OVERRIDE;
virtual void SendMouseClickEvent(int x, int y, MouseButtonType type,
bool mouseUp, int clickCount);
virtual void SendMouseMoveEvent(int x, int y, bool mouseLeave);
virtual void SendMouseWheelEvent(int x, int y, int delta);
virtual void SendFocusEvent(bool setFocus);
virtual void SendCaptureLostEvent();
bool mouseUp, int clickCount) OVERRIDE;
virtual void SendMouseMoveEvent(int x, int y, bool mouseLeave) OVERRIDE;
virtual void SendMouseWheelEvent(int x, int y, int delta) OVERRIDE;
virtual void SendFocusEvent(bool setFocus) OVERRIDE;
virtual void SendCaptureLostEvent() OVERRIDE;
};
#endif // USING_CEF_SHARED

183
libcef_dll/ctocpp/client_ctocpp.cc Normal file
View File

@@ -0,0 +1,183 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/ctocpp/client_ctocpp.h"
#include "libcef_dll/ctocpp/display_handler_ctocpp.h"
#include "libcef_dll/ctocpp/find_handler_ctocpp.h"
#include "libcef_dll/ctocpp/focus_handler_ctocpp.h"
#include "libcef_dll/ctocpp/jsbinding_handler_ctocpp.h"
#include "libcef_dll/ctocpp/jsdialog_handler_ctocpp.h"
#include "libcef_dll/ctocpp/keyboard_handler_ctocpp.h"
#include "libcef_dll/ctocpp/life_span_handler_ctocpp.h"
#include "libcef_dll/ctocpp/load_handler_ctocpp.h"
#include "libcef_dll/ctocpp/menu_handler_ctocpp.h"
#include "libcef_dll/ctocpp/print_handler_ctocpp.h"
#include "libcef_dll/ctocpp/render_handler_ctocpp.h"
#include "libcef_dll/ctocpp/request_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
CefRefPtr<CefLifeSpanHandler> CefClientCToCpp::GetLifeSpanHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_life_span_handler))
return NULL;
cef_life_span_handler_t* handlerStruct =
struct_->get_life_span_handler(struct_);
if(handlerStruct)
return CefLifeSpanHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefLoadHandler> CefClientCToCpp::GetLoadHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_load_handler))
return NULL;
cef_load_handler_t* handlerStruct = struct_->get_load_handler(struct_);
if(handlerStruct)
return CefLoadHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefRequestHandler> CefClientCToCpp::GetRequestHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_request_handler))
return NULL;
cef_request_handler_t* handlerStruct = struct_->get_request_handler(struct_);
if(handlerStruct)
return CefRequestHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefDisplayHandler> CefClientCToCpp::GetDisplayHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_display_handler))
return NULL;
cef_display_handler_t* handlerStruct = struct_->get_display_handler(struct_);
if(handlerStruct)
return CefDisplayHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefFocusHandler> CefClientCToCpp::GetFocusHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_focus_handler))
return NULL;
cef_focus_handler_t* handlerStruct = struct_->get_focus_handler(struct_);
if(handlerStruct)
return CefFocusHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefKeyboardHandler> CefClientCToCpp::GetKeyboardHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_keyboard_handler))
return NULL;
cef_keyboard_handler_t* handlerStruct =
struct_->get_keyboard_handler(struct_);
if(handlerStruct)
return CefKeyboardHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefMenuHandler> CefClientCToCpp::GetMenuHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_menu_handler))
return NULL;
cef_menu_handler_t* handlerStruct = struct_->get_menu_handler(struct_);
if(handlerStruct)
return CefMenuHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefPrintHandler> CefClientCToCpp::GetPrintHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_print_handler))
return NULL;
cef_print_handler_t* handlerStruct = struct_->get_print_handler(struct_);
if(handlerStruct)
return CefPrintHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefFindHandler> CefClientCToCpp::GetFindHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_find_handler))
return NULL;
cef_find_handler_t* handlerStruct = struct_->get_find_handler(struct_);
if(handlerStruct)
return CefFindHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefJSDialogHandler> CefClientCToCpp::GetJSDialogHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_jsdialog_handler))
return NULL;
cef_jsdialog_handler_t* handlerStruct =
struct_->get_jsdialog_handler(struct_);
if(handlerStruct)
return CefJSDialogHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefJSBindingHandler> CefClientCToCpp::GetJSBindingHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_jsbinding_handler))
return NULL;
cef_jsbinding_handler_t* handlerStruct =
struct_->get_jsbinding_handler(struct_);
if(handlerStruct)
return CefJSBindingHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
CefRefPtr<CefRenderHandler> CefClientCToCpp::GetRenderHandler()
{
if (CEF_MEMBER_MISSING(struct_, get_render_handler))
return NULL;
cef_render_handler_t* handlerStruct = struct_->get_render_handler(struct_);
if(handlerStruct)
return CefRenderHandlerCToCpp::Wrap(handlerStruct);
return NULL;
}
#ifndef NDEBUG
template<> long CefCToCpp<CefClientCToCpp, CefClient,
cef_client_t>::DebugObjCt = 0;
#endif

50
libcef_dll/ctocpp/client_ctocpp.h Normal file
View File

@@ -0,0 +1,50 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _CLIENT_CTOCPP_H
#define _CLIENT_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefClientCToCpp
: public CefCToCpp<CefClientCToCpp, CefClient, cef_client_t>
{
public:
CefClientCToCpp(cef_client_t* str)
: CefCToCpp<CefClientCToCpp, CefClient, cef_client_t>(str) {}
virtual ~CefClientCToCpp() {}
// CefClient methods
virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE;
virtual CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE;
virtual CefRefPtr<CefRequestHandler> GetRequestHandler() OVERRIDE;
virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() OVERRIDE;
virtual CefRefPtr<CefFocusHandler> GetFocusHandler() OVERRIDE;
virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() OVERRIDE;
virtual CefRefPtr<CefMenuHandler> GetMenuHandler() OVERRIDE;
virtual CefRefPtr<CefPrintHandler> GetPrintHandler() OVERRIDE;
virtual CefRefPtr<CefFindHandler> GetFindHandler() OVERRIDE;
virtual CefRefPtr<CefJSDialogHandler> GetJSDialogHandler() OVERRIDE;
virtual CefRefPtr<CefJSBindingHandler> GetJSBindingHandler() OVERRIDE;
virtual CefRefPtr<CefRenderHandler> GetRenderHandler() OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _CLIENT_CTOCPP_H

4
libcef_dll/ctocpp/cookie_visitor_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -30,7 +30,7 @@ bool CefCookieVisitorCToCpp::Visit(const CefCookie& cookie, int count,
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefCookieVisitorCToCpp, CefCookieVisitor,
cef_cookie_visitor_t>::DebugObjCt = 0;
#endif

4
libcef_dll/ctocpp/cookie_visitor_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -34,7 +34,7 @@ public:
// CefCookieVisitor methods
virtual bool Visit(const CefCookie& cookie, int count, int total,
bool& deleteCookie);
bool& deleteCookie) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

21
libcef_dll/ctocpp/ctocpp.h
View File

@@ -14,7 +14,7 @@
// exists on the other side of the DLL boundary but will have methods called on
// this side of the DLL boundary.
template <class ClassName, class BaseName, class StructName>
class CefCToCpp : public CefThreadSafeBase<BaseName>
class CefCToCpp : public BaseName
{
public:
// Use this method to create a wrapper class instance for a structure
@@ -50,13 +50,13 @@ public:
{
DCHECK(str);
#ifdef _DEBUG
#ifndef NDEBUG
CefAtomicIncrement(&DebugObjCt);
#endif
}
virtual ~CefCToCpp()
{
#ifdef _DEBUG
#ifndef NDEBUG
CefAtomicDecrement(&DebugObjCt);
#endif
}
@@ -68,16 +68,20 @@ public:
// CefBase methods increment/decrement reference counts on both this object
// and the underlying wrapped structure.
virtual int AddRef()
int AddRef()
{
UnderlyingAddRef();
return CefThreadSafeBase<BaseName>::AddRef();
return refct_.AddRef();
}
virtual int Release()
int Release()
{
UnderlyingRelease();
return CefThreadSafeBase<BaseName>::Release();
int retval = refct_.Release();
if (retval == 0)
delete this;
return retval;
}
int GetRefCt() { return refct_.GetRefCt(); }
// Increment/decrement reference counts on only the underlying class.
int UnderlyingAddRef()
@@ -99,12 +103,13 @@ public:
return struct_->base.get_refct(&struct_->base);
}
#ifdef _DEBUG
#ifndef NDEBUG
// Simple tracking of allocated objects.
static long DebugObjCt;
#endif
protected:
CefRefCount refct_;
StructName* struct_;
};

85
libcef_dll/ctocpp/display_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,85 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/cpptoc/frame_cpptoc.h"
#include "libcef_dll/ctocpp/display_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
void CefDisplayHandlerCToCpp::OnNavStateChange(CefRefPtr<CefBrowser> browser,
bool canGoBack, bool canGoForward)
{
if (CEF_MEMBER_MISSING(struct_, on_nav_state_change))
return;
struct_->on_nav_state_change(struct_, CefBrowserCppToC::Wrap(browser),
canGoBack, canGoForward);
}
void CefDisplayHandlerCToCpp::OnAddressChange(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& url)
{
if (CEF_MEMBER_MISSING(struct_, on_address_change))
return;
struct_->on_address_change(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), url.GetStruct());
}
void CefDisplayHandlerCToCpp::OnTitleChange(CefRefPtr<CefBrowser> browser,
const CefString& title)
{
if (CEF_MEMBER_MISSING(struct_, on_title_change))
return;
struct_->on_title_change(struct_, CefBrowserCppToC::Wrap(browser),
title.GetStruct());
}
bool CefDisplayHandlerCToCpp::OnTooltip(CefRefPtr<CefBrowser> browser,
CefString& text)
{
if (CEF_MEMBER_MISSING(struct_, on_tooltip))
return false;
return struct_->on_tooltip(struct_, CefBrowserCppToC::Wrap(browser),
text.GetWritableStruct()) ? true : false;
}
void CefDisplayHandlerCToCpp::OnStatusMessage(CefRefPtr<CefBrowser> browser,
const CefString& value, StatusType type)
{
if (CEF_MEMBER_MISSING(struct_, on_status_message))
return;
struct_->on_status_message(struct_, CefBrowserCppToC::Wrap(browser),
value.GetStruct(), type);
}
bool CefDisplayHandlerCToCpp::OnConsoleMessage(CefRefPtr<CefBrowser> browser,
const CefString& message, const CefString& source, int line)
{
if (CEF_MEMBER_MISSING(struct_, on_console_message))
return false;
return struct_->on_console_message(struct_, CefBrowserCppToC::Wrap(browser),
message.GetStruct(), source.GetStruct(), line) ? true : false;
}
#ifndef NDEBUG
template<> long CefCToCpp<CefDisplayHandlerCToCpp, CefDisplayHandler,
cef_display_handler_t>::DebugObjCt = 0;
#endif

52
libcef_dll/ctocpp/display_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,52 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _DISPLAYHANDLER_CTOCPP_H
#define _DISPLAYHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefDisplayHandlerCToCpp
: public CefCToCpp<CefDisplayHandlerCToCpp, CefDisplayHandler,
cef_display_handler_t>
{
public:
CefDisplayHandlerCToCpp(cef_display_handler_t* str)
: CefCToCpp<CefDisplayHandlerCToCpp, CefDisplayHandler,
cef_display_handler_t>(str) {}
virtual ~CefDisplayHandlerCToCpp() {}
// CefDisplayHandler methods
virtual void OnNavStateChange(CefRefPtr<CefBrowser> browser, bool canGoBack,
bool canGoForward) OVERRIDE;
virtual void OnAddressChange(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& url) OVERRIDE;
virtual void OnTitleChange(CefRefPtr<CefBrowser> browser,
const CefString& title) OVERRIDE;
virtual bool OnTooltip(CefRefPtr<CefBrowser> browser,
CefString& text) OVERRIDE;
virtual void OnStatusMessage(CefRefPtr<CefBrowser> browser,
const CefString& value, StatusType type) OVERRIDE;
virtual bool OnConsoleMessage(CefRefPtr<CefBrowser> browser,
const CefString& message, const CefString& source, int line) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _DISPLAYHANDLER_CTOCPP_H

4
libcef_dll/ctocpp/domdocument_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -183,7 +183,7 @@ CefString CefDOMDocumentCToCpp::GetCompleteURL(const CefString& partialURL)
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefDOMDocumentCToCpp, CefDOMDocument,
cef_domdocument_t>::DebugObjCt = 0;
#endif

34
libcef_dll/ctocpp/domdocument_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -32,22 +32,22 @@ public:
virtual ~CefDOMDocumentCToCpp() {}
// CefDOMDocument methods
virtual Type GetType();
virtual CefRefPtr<CefDOMNode> GetDocument();
virtual CefRefPtr<CefDOMNode> GetBody();
virtual CefRefPtr<CefDOMNode> GetHead();
virtual CefString GetTitle();
virtual CefRefPtr<CefDOMNode> GetElementById(const CefString& id);
virtual CefRefPtr<CefDOMNode> GetFocusedNode();
virtual bool HasSelection();
virtual CefRefPtr<CefDOMNode> GetSelectionStartNode();
virtual int GetSelectionStartOffset();
virtual CefRefPtr<CefDOMNode> GetSelectionEndNode();
virtual int GetSelectionEndOffset();
virtual CefString GetSelectionAsMarkup();
virtual CefString GetSelectionAsText();
virtual CefString GetBaseURL();
virtual CefString GetCompleteURL(const CefString& partialURL);
virtual Type GetType() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetDocument() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetBody() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetHead() OVERRIDE;
virtual CefString GetTitle() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetElementById(const CefString& id) OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetFocusedNode() OVERRIDE;
virtual bool HasSelection() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetSelectionStartNode() OVERRIDE;
virtual int GetSelectionStartOffset() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetSelectionEndNode() OVERRIDE;
virtual int GetSelectionEndOffset() OVERRIDE;
virtual CefString GetSelectionAsMarkup() OVERRIDE;
virtual CefString GetSelectionAsText() OVERRIDE;
virtual CefString GetBaseURL() OVERRIDE;
virtual CefString GetCompleteURL(const CefString& partialURL) OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/domevent_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -94,7 +94,7 @@ CefRefPtr<CefDOMNode> CefDOMEventCToCpp::GetCurrentTarget()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefDOMEventCToCpp, CefDOMEvent,
cef_domevent_t>::DebugObjCt = 0;
#endif

18
libcef_dll/ctocpp/domevent_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,14 +31,14 @@ public:
virtual ~CefDOMEventCToCpp() {}
// CefDOMEvent methods
virtual CefString GetType();
virtual Category GetCategory();
virtual Phase GetPhase();
virtual bool CanBubble();
virtual bool CanCancel();
virtual CefRefPtr<CefDOMDocument> GetDocument();
virtual CefRefPtr<CefDOMNode> GetTarget();
virtual CefRefPtr<CefDOMNode> GetCurrentTarget();
virtual CefString GetType() OVERRIDE;
virtual Category GetCategory() OVERRIDE;
virtual Phase GetPhase() OVERRIDE;
virtual bool CanBubble() OVERRIDE;
virtual bool CanCancel() OVERRIDE;
virtual CefRefPtr<CefDOMDocument> GetDocument() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetTarget() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetCurrentTarget() OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/domevent_listener_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -28,7 +28,7 @@ void CefDOMEventListenerCToCpp::HandleEvent(CefRefPtr<CefDOMEvent> event)
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefDOMEventListenerCToCpp, CefDOMEventListener,
cef_domevent_listener_t>::DebugObjCt = 0;
#endif

4
libcef_dll/ctocpp/domevent_listener_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,7 +33,7 @@ public:
virtual ~CefDOMEventListenerCToCpp() {}
// CefDOMEventListener methods
virtual void HandleEvent(CefRefPtr<CefDOMEvent> event);
virtual void HandleEvent(CefRefPtr<CefDOMEvent> event) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/domnode_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -253,7 +253,7 @@ CefString CefDOMNodeCToCpp::GetElementInnerText()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefDOMNodeCToCpp, CefDOMNode,
cef_domnode_t>::DebugObjCt = 0;
#endif

48
libcef_dll/ctocpp/domnode_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,31 +31,31 @@ public:
virtual ~CefDOMNodeCToCpp() {}
// CefDOMNode methods
virtual Type GetType();
virtual bool IsText();
virtual bool IsElement();
virtual bool IsSame(CefRefPtr<CefDOMNode> that);
virtual CefString GetName();
virtual CefString GetValue();
virtual bool SetValue(const CefString& value);
virtual CefString GetAsMarkup();
virtual CefRefPtr<CefDOMDocument> GetDocument();
virtual CefRefPtr<CefDOMNode> GetParent();
virtual CefRefPtr<CefDOMNode> GetPreviousSibling();
virtual CefRefPtr<CefDOMNode> GetNextSibling();
virtual bool HasChildren();
virtual CefRefPtr<CefDOMNode> GetFirstChild();
virtual CefRefPtr<CefDOMNode> GetLastChild();
virtual Type GetType() OVERRIDE;
virtual bool IsText() OVERRIDE;
virtual bool IsElement() OVERRIDE;
virtual bool IsSame(CefRefPtr<CefDOMNode> that) OVERRIDE;
virtual CefString GetName() OVERRIDE;
virtual CefString GetValue() OVERRIDE;
virtual bool SetValue(const CefString& value) OVERRIDE;
virtual CefString GetAsMarkup() OVERRIDE;
virtual CefRefPtr<CefDOMDocument> GetDocument() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetParent() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetPreviousSibling() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetNextSibling() OVERRIDE;
virtual bool HasChildren() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetFirstChild() OVERRIDE;
virtual CefRefPtr<CefDOMNode> GetLastChild() OVERRIDE;
virtual void AddEventListener(const CefString& eventType,
CefRefPtr<CefDOMEventListener> listener, bool useCapture);
virtual CefString GetElementTagName();
virtual bool HasElementAttributes();
virtual bool HasElementAttribute(const CefString& attrName);
virtual CefString GetElementAttribute(const CefString& attrName);
virtual void GetElementAttributes(AttributeMap& attrMap);
CefRefPtr<CefDOMEventListener> listener, bool useCapture) OVERRIDE;
virtual CefString GetElementTagName() OVERRIDE;
virtual bool HasElementAttributes() OVERRIDE;
virtual bool HasElementAttribute(const CefString& attrName) OVERRIDE;
virtual CefString GetElementAttribute(const CefString& attrName) OVERRIDE;
virtual void GetElementAttributes(AttributeMap& attrMap) OVERRIDE;
virtual bool SetElementAttribute(const CefString& attrName,
const CefString& value);
virtual CefString GetElementInnerText();
const CefString& value) OVERRIDE;
virtual CefString GetElementInnerText() OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/domvisitor_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -28,7 +28,7 @@ void CefDOMVisitorCToCpp::Visit(CefRefPtr<CefDOMDocument> document)
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefDOMVisitorCToCpp, CefDOMVisitor,
cef_domvisitor_t>::DebugObjCt = 0;
#endif

4
libcef_dll/ctocpp/domvisitor_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,7 +31,7 @@ public:
virtual ~CefDOMVisitorCToCpp() {}
// CefDOMVisitor methods
virtual void Visit(CefRefPtr<CefDOMDocument> document);
virtual void Visit(CefRefPtr<CefDOMDocument> document) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/download_handler_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -32,7 +32,7 @@ void CefDownloadHandlerCToCpp::Complete()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefDownloadHandlerCToCpp, CefDownloadHandler,
cef_download_handler_t>::DebugObjCt = 0;
#endif

6
libcef_dll/ctocpp/download_handler_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,8 +33,8 @@ public:
virtual ~CefDownloadHandlerCToCpp() {}
// CefDownloadHandler methods
virtual bool ReceivedData(void* data, int data_size);
virtual void Complete();
virtual bool ReceivedData(void* data, int data_size) OVERRIDE;
virtual void Complete() OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

35
libcef_dll/ctocpp/find_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,35 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/ctocpp/find_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
void CefFindHandlerCToCpp::OnFindResult(CefRefPtr<CefBrowser> browser,
int identifier, int count, const CefRect& selectionRect,
int activeMatchOrdinal, bool finalUpdate)
{
if (CEF_MEMBER_MISSING(struct_, on_find_result))
return;
struct_->on_find_result(struct_, CefBrowserCppToC::Wrap(browser), identifier,
count, &selectionRect, activeMatchOrdinal, finalUpdate);
}
#ifndef NDEBUG
template<> long CefCToCpp<CefFindHandlerCToCpp, CefFindHandler,
cef_find_handler_t>::DebugObjCt = 0;
#endif

42
libcef_dll/ctocpp/find_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,42 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _FINDHANDLER_CTOCPP_H
#define _FINDHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefFindHandlerCToCpp
: public CefCToCpp<CefFindHandlerCToCpp, CefFindHandler, cef_find_handler_t>
{
public:
CefFindHandlerCToCpp(cef_find_handler_t* str)
: CefCToCpp<CefFindHandlerCToCpp, CefFindHandler, cef_find_handler_t>(
str) {}
virtual ~CefFindHandlerCToCpp() {}
// CefFindHandler methods
virtual void OnFindResult(CefRefPtr<CefBrowser> browser, int identifier,
int count, const CefRect& selectionRect, int activeMatchOrdinal,
bool finalUpdate) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _FINDHANDLER_CTOCPP_H

43
libcef_dll/ctocpp/focus_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,43 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/ctocpp/focus_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
void CefFocusHandlerCToCpp::OnTakeFocus(CefRefPtr<CefBrowser> browser,
bool next)
{
if (CEF_MEMBER_MISSING(struct_, on_take_focus))
return;
struct_->on_take_focus(struct_, CefBrowserCppToC::Wrap(browser), next);
}
bool CefFocusHandlerCToCpp::OnSetFocus(CefRefPtr<CefBrowser> browser,
bool isWidget)
{
if (CEF_MEMBER_MISSING(struct_, on_set_focus))
return false;
return struct_->on_set_focus(struct_, CefBrowserCppToC::Wrap(browser),
isWidget) ? true : false;
}
#ifndef NDEBUG
template<> long CefCToCpp<CefFocusHandlerCToCpp, CefFocusHandler,
cef_focus_handler_t>::DebugObjCt = 0;
#endif

43
libcef_dll/ctocpp/focus_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,43 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _FOCUSHANDLER_CTOCPP_H
#define _FOCUSHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefFocusHandlerCToCpp
: public CefCToCpp<CefFocusHandlerCToCpp, CefFocusHandler,
cef_focus_handler_t>
{
public:
CefFocusHandlerCToCpp(cef_focus_handler_t* str)
: CefCToCpp<CefFocusHandlerCToCpp, CefFocusHandler, cef_focus_handler_t>(
str) {}
virtual ~CefFocusHandlerCToCpp() {}
// CefFocusHandler methods
virtual void OnTakeFocus(CefRefPtr<CefBrowser> browser, bool next) OVERRIDE;
virtual bool OnSetFocus(CefRefPtr<CefBrowser> browser,
bool isWidget) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _FOCUSHANDLER_CTOCPP_H

4
libcef_dll/ctocpp/frame_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -217,7 +217,7 @@ void CefFrameCToCpp::VisitDOM(CefRefPtr<CefDOMVisitor> visitor)
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefFrameCToCpp, CefFrame, cef_frame_t>::DebugObjCt =
0;
#endif

47
libcef_dll/ctocpp/frame_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,30 +31,31 @@ public:
virtual ~CefFrameCToCpp() {}
// CefFrame methods
virtual void Undo();
virtual void Redo();
virtual void Cut();
virtual void Copy();
virtual void Paste();
virtual void Delete();
virtual void SelectAll();
virtual void Print();
virtual void ViewSource();
virtual CefString GetSource();
virtual CefString GetText();
virtual void LoadRequest(CefRefPtr<CefRequest> request);
virtual void LoadURL(const CefString& url);
virtual void LoadString(const CefString& string, const CefString& url);
virtual void Undo() OVERRIDE;
virtual void Redo() OVERRIDE;
virtual void Cut() OVERRIDE;
virtual void Copy() OVERRIDE;
virtual void Paste() OVERRIDE;
virtual void Delete() OVERRIDE;
virtual void SelectAll() OVERRIDE;
virtual void Print() OVERRIDE;
virtual void ViewSource() OVERRIDE;
virtual CefString GetSource() OVERRIDE;
virtual CefString GetText() OVERRIDE;
virtual void LoadRequest(CefRefPtr<CefRequest> request) OVERRIDE;
virtual void LoadURL(const CefString& url) OVERRIDE;
virtual void LoadString(const CefString& string,
const CefString& url) OVERRIDE;
virtual void LoadStream(CefRefPtr<CefStreamReader> stream,
const CefString& url);
const CefString& url) OVERRIDE;
virtual void ExecuteJavaScript(const CefString& jsCode,
const CefString& scriptUrl, int startLine);
virtual bool IsMain();
virtual bool IsFocused();
virtual CefString GetName();
virtual CefString GetURL();
virtual CefRefPtr<CefBrowser> GetBrowser();
virtual void VisitDOM(CefRefPtr<CefDOMVisitor> visitor);
const CefString& scriptUrl, int startLine) OVERRIDE;
virtual bool IsMain() OVERRIDE;
virtual bool IsFocused() OVERRIDE;
virtual CefString GetName() OVERRIDE;
virtual CefString GetURL() OVERRIDE;
virtual CefRefPtr<CefBrowser> GetBrowser() OVERRIDE;
virtual void VisitDOM(CefRefPtr<CefDOMVisitor> visitor) OVERRIDE;
};
#endif // USING_CEF_SHARED

474
libcef_dll/ctocpp/handler_ctocpp.cc
View File

@@ -1,474 +0,0 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/cpptoc/frame_cpptoc.h"
#include "libcef_dll/cpptoc/request_cpptoc.h"
#include "libcef_dll/cpptoc/response_cpptoc.h"
#include "libcef_dll/cpptoc/stream_reader_cpptoc.h"
#include "libcef_dll/cpptoc/v8value_cpptoc.h"
#include "libcef_dll/ctocpp/download_handler_ctocpp.h"
#include "libcef_dll/ctocpp/handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
CefHandler::RetVal CefHandlerCToCpp::HandleBeforeCreated(
CefRefPtr<CefBrowser> parentBrowser, CefWindowInfo& windowInfo, bool popup,
const CefPopupFeatures& popupFeatures, CefRefPtr<CefHandler>& handler,
const CefString& url, CefBrowserSettings& settings)
{
if(CEF_MEMBER_MISSING(struct_, handle_before_created))
return RV_CONTINUE;
cef_browser_t* browserStruct = NULL;
if(parentBrowser.get())
browserStruct = CefBrowserCppToC::Wrap(parentBrowser);
cef_handler_t* handlerStruct = NULL;
if(handler.get())
handlerStruct = CefHandlerCToCpp::Unwrap(handler);
cef_handler_t *origHandlerStruct = handlerStruct;
cef_retval_t rv = struct_->handle_before_created(struct_,
browserStruct, &windowInfo, popup, &popupFeatures, &handlerStruct,
url.GetStruct(), &settings);
if(handlerStruct && handlerStruct != origHandlerStruct) {
// The handler was changed.
if(handlerStruct)
handler = CefHandlerCToCpp::Wrap(handlerStruct);
else
handler = NULL;
}
return rv;
}
CefHandler::RetVal CefHandlerCToCpp::HandleAfterCreated(
CefRefPtr<CefBrowser> browser)
{
if(CEF_MEMBER_MISSING(struct_, handle_after_created))
return RV_CONTINUE;
return struct_->handle_after_created(struct_,
CefBrowserCppToC::Wrap(browser));
}
CefHandler::RetVal CefHandlerCToCpp::HandleAddressChange(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
const CefString& url)
{
if(CEF_MEMBER_MISSING(struct_, handle_address_change))
return RV_CONTINUE;
return struct_->handle_address_change(struct_,
CefBrowserCppToC::Wrap(browser), CefFrameCppToC::Wrap(frame),
url.GetStruct());
}
CefHandler::RetVal CefHandlerCToCpp::HandleTitleChange(
CefRefPtr<CefBrowser> browser, const CefString& title)
{
if(CEF_MEMBER_MISSING(struct_, handle_title_change))
return RV_CONTINUE;
return struct_->handle_title_change(struct_, CefBrowserCppToC::Wrap(browser),
title.GetStruct());
}
CefHandler::RetVal CefHandlerCToCpp::HandleNavStateChange(
CefRefPtr<CefBrowser> browser, bool canGoBack, bool canGoForward)
{
if(CEF_MEMBER_MISSING(struct_, handle_nav_state_change))
return RV_CONTINUE;
return struct_->handle_nav_state_change(struct_,
CefBrowserCppToC::Wrap(browser), canGoBack, canGoForward);
}
CefHandler::RetVal CefHandlerCToCpp::HandleBeforeBrowse(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request, NavType navType, bool isRedirect)
{
if(CEF_MEMBER_MISSING(struct_, handle_before_browse))
return RV_CONTINUE;
return struct_->handle_before_browse(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), CefRequestCppToC::Wrap(request),
navType, isRedirect);
}
CefHandler::RetVal CefHandlerCToCpp::HandleLoadStart(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame)
{
if(CEF_MEMBER_MISSING(struct_, handle_load_start))
return RV_CONTINUE;
cef_frame_t* frameStruct = NULL;
if(frame.get())
frameStruct = CefFrameCppToC::Wrap(frame);
return struct_->handle_load_start(struct_, CefBrowserCppToC::Wrap(browser),
frameStruct);
}
CefHandler::RetVal CefHandlerCToCpp::HandleLoadEnd(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
int httpStatusCode)
{
if(CEF_MEMBER_MISSING(struct_, handle_load_end))
return RV_CONTINUE;
cef_frame_t* frameStruct = NULL;
if(frame.get())
frameStruct = CefFrameCppToC::Wrap(frame);
return struct_->handle_load_end(struct_, CefBrowserCppToC::Wrap(browser),
frameStruct, httpStatusCode);
}
CefHandler::RetVal CefHandlerCToCpp::HandleLoadError(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
ErrorCode errorCode, const CefString& failedUrl, CefString& errorText)
{
if(CEF_MEMBER_MISSING(struct_, handle_load_error))
return RV_CONTINUE;
return struct_->handle_load_error(struct_,
CefBrowserCppToC::Wrap(browser), CefFrameCppToC::Wrap(frame), errorCode,
failedUrl.GetStruct(), errorText.GetWritableStruct());
}
CefHandler::RetVal CefHandlerCToCpp::HandleBeforeResourceLoad(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefRequest> request,
CefString& redirectUrl, CefRefPtr<CefStreamReader>& resourceStream,
CefRefPtr<CefResponse> response, int loadFlags)
{
if(CEF_MEMBER_MISSING(struct_, handle_before_resource_load))
return RV_CONTINUE;
cef_stream_reader_t* streamRet = NULL;
cef_retval_t rv = struct_->handle_before_resource_load(struct_,
CefBrowserCppToC::Wrap(browser), CefRequestCppToC::Wrap(request),
redirectUrl.GetWritableStruct(), &streamRet,
CefResponseCppToC::Wrap(response), loadFlags);
if(streamRet)
resourceStream = CefStreamReaderCppToC::Unwrap(streamRet);
return rv;
}
CefHandler::RetVal CefHandlerCToCpp::HandleProtocolExecution(
CefRefPtr<CefBrowser> browser, const CefString& url,
bool& allow_os_execution)
{
if(CEF_MEMBER_MISSING(struct_, handle_protocol_execution))
return RV_CONTINUE;
int allowExec = allow_os_execution;
cef_retval_t rv = struct_->handle_protocol_execution(struct_,
CefBrowserCppToC::Wrap(browser), url.GetStruct(), &allowExec);
allow_os_execution = allowExec?true:false;
return rv;
}
CefHandler::RetVal CefHandlerCToCpp::HandleDownloadResponse(
CefRefPtr<CefBrowser> browser, const CefString& mimeType,
const CefString& fileName, int64 contentLength,
CefRefPtr<CefDownloadHandler>& handler)
{
if(CEF_MEMBER_MISSING(struct_, handle_download_response))
return RV_CONTINUE;
cef_download_handler_t* handlerRet = NULL;
cef_retval_t rv = struct_->handle_download_response(struct_,
CefBrowserCppToC::Wrap(browser), mimeType.GetStruct(), fileName.GetStruct(),
contentLength, &handlerRet);
if(handlerRet)
handler = CefDownloadHandlerCToCpp::Wrap(handlerRet);
return rv;
}
CefHandler::RetVal CefHandlerCToCpp::HandleAuthenticationRequest(
CefRefPtr<CefBrowser> browser, bool isProxy, const CefString& host,
const CefString& realm, const CefString& scheme, CefString& username,
CefString& password)
{
if(CEF_MEMBER_MISSING(struct_, handle_authentication_request))
return RV_CONTINUE;
return struct_->handle_authentication_request(struct_,
CefBrowserCppToC::Wrap(browser), isProxy,
host.GetStruct(), realm.GetStruct(), scheme.GetStruct(),
username.GetWritableStruct(), password.GetWritableStruct());
}
CefHandler::RetVal CefHandlerCToCpp::HandleBeforeMenu(
CefRefPtr<CefBrowser> browser, const MenuInfo& menuInfo)
{
if(CEF_MEMBER_MISSING(struct_, handle_before_menu))
return RV_CONTINUE;
return struct_->handle_before_menu(struct_, CefBrowserCppToC::Wrap(browser),
&menuInfo);
}
CefHandler::RetVal CefHandlerCToCpp::HandleGetMenuLabel(
CefRefPtr<CefBrowser> browser, MenuId menuId, CefString& label)
{
if(CEF_MEMBER_MISSING(struct_, handle_get_menu_label))
return RV_CONTINUE;
return struct_->handle_get_menu_label(struct_,
CefBrowserCppToC::Wrap(browser), menuId, label.GetWritableStruct());
}
CefHandler::RetVal CefHandlerCToCpp::HandleMenuAction(
CefRefPtr<CefBrowser> browser, MenuId menuId)
{
if(CEF_MEMBER_MISSING(struct_, handle_menu_action))
return RV_CONTINUE;
return struct_->handle_menu_action(struct_, CefBrowserCppToC::Wrap(browser),
menuId);
}
CefHandler::RetVal CefHandlerCToCpp::HandlePrintOptions(
CefRefPtr<CefBrowser> browser, CefPrintOptions& printOptions)
{
if (CEF_MEMBER_MISSING(struct_, handle_print_options))
return RV_CONTINUE;
return struct_->handle_print_options(struct_, CefBrowserCppToC::Wrap(browser),
&printOptions);
}
CefHandler::RetVal CefHandlerCToCpp::HandlePrintHeaderFooter(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
CefPrintInfo& printInfo, const CefString& url, const CefString& title,
int currentPage, int maxPages, CefString& topLeft, CefString& topCenter,
CefString& topRight, CefString& bottomLeft, CefString& bottomCenter,
CefString& bottomRight)
{
if(CEF_MEMBER_MISSING(struct_, handle_print_header_footer))
return RV_CONTINUE;
return struct_->handle_print_header_footer(struct_,
CefBrowserCppToC::Wrap(browser), CefFrameCppToC::Wrap(frame),
&printInfo, url.GetStruct(), title.GetStruct(), currentPage, maxPages,
topLeft.GetWritableStruct(), topCenter.GetWritableStruct(),
topRight.GetWritableStruct(), bottomLeft.GetWritableStruct(),
bottomCenter.GetWritableStruct(), bottomRight.GetWritableStruct());
}
CefHandler::RetVal CefHandlerCToCpp::HandleJSAlert(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
const CefString& message)
{
if(CEF_MEMBER_MISSING(struct_, handle_jsalert))
return RV_CONTINUE;
return struct_->handle_jsalert(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), message.GetStruct());
}
CefHandler::RetVal CefHandlerCToCpp::HandleJSConfirm(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
const CefString& message, bool& retval)
{
if(CEF_MEMBER_MISSING(struct_, handle_jsconfirm))
return RV_CONTINUE;
int ret = 0;
cef_retval_t rv = struct_->handle_jsconfirm(struct_,
CefBrowserCppToC::Wrap(browser), CefFrameCppToC::Wrap(frame),
message.GetStruct(), &ret);
retval = (ret ? true : false);
return rv;
}
CefHandler::RetVal CefHandlerCToCpp::HandleJSPrompt(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
const CefString& message, const CefString& defaultValue, bool& retval,
CefString& result)
{
if(CEF_MEMBER_MISSING(struct_, handle_jsprompt))
return RV_CONTINUE;
int ret = 0;
cef_retval_t rv = struct_->handle_jsprompt(struct_,
CefBrowserCppToC::Wrap(browser), CefFrameCppToC::Wrap(frame),
message.GetStruct(), defaultValue.GetStruct(), &ret,
result.GetWritableStruct());
retval = (ret ? true : false);
return rv;
}
CefHandler::RetVal CefHandlerCToCpp::HandleJSBinding(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Value> object)
{
if(CEF_MEMBER_MISSING(struct_, handle_jsbinding))
return RV_CONTINUE;
return struct_->handle_jsbinding(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), CefV8ValueCppToC::Wrap(object));
}
CefHandler::RetVal CefHandlerCToCpp::HandleBeforeWindowClose(
CefRefPtr<CefBrowser> browser)
{
if(CEF_MEMBER_MISSING(struct_, handle_before_window_close))
return RV_CONTINUE;
return struct_->handle_before_window_close(struct_,
CefBrowserCppToC::Wrap(browser));
}
CefHandler::RetVal CefHandlerCToCpp::HandleTakeFocus(
CefRefPtr<CefBrowser> browser, bool reverse)
{
if(CEF_MEMBER_MISSING(struct_, handle_take_focus))
return RV_CONTINUE;
return struct_->handle_take_focus(struct_, CefBrowserCppToC::Wrap(browser),
reverse);
}
CefHandler::RetVal CefHandlerCToCpp::HandleSetFocus(
CefRefPtr<CefBrowser> browser, bool isWidget)
{
if(CEF_MEMBER_MISSING(struct_, handle_set_focus))
return RV_CONTINUE;
return struct_->handle_set_focus(struct_, CefBrowserCppToC::Wrap(browser),
isWidget);
}
CefHandler::RetVal CefHandlerCToCpp::HandleKeyEvent(
CefRefPtr<CefBrowser> browser, KeyEventType type, int code, int modifiers,
bool isSystemKey)
{
if(CEF_MEMBER_MISSING(struct_, handle_key_event))
return RV_CONTINUE;
return struct_->handle_key_event(struct_, CefBrowserCppToC::Wrap(browser),
type, code, modifiers, isSystemKey);
}
CefHandler::RetVal CefHandlerCToCpp::HandleTooltip(
CefRefPtr<CefBrowser> browser, CefString& text)
{
if(CEF_MEMBER_MISSING(struct_, handle_tooltip))
return RV_CONTINUE;
return struct_->handle_tooltip(struct_,
CefBrowserCppToC::Wrap(browser), text.GetWritableStruct());
}
CefHandler::RetVal CefHandlerCToCpp::HandleStatus(CefRefPtr<CefBrowser> browser,
const CefString& value, StatusType type)
{
if(CEF_MEMBER_MISSING(struct_, handle_status))
return RV_CONTINUE;
return struct_->handle_status(struct_,
CefBrowserCppToC::Wrap(browser), value.GetStruct(), type);
}
CefHandler::RetVal CefHandlerCToCpp::HandleConsoleMessage(
CefRefPtr<CefBrowser> browser, const CefString& message,
const CefString& source, int line)
{
if(CEF_MEMBER_MISSING(struct_, handle_console_message))
return RV_CONTINUE;
return struct_->handle_console_message(struct_,
CefBrowserCppToC::Wrap(browser), message.GetStruct(), source.GetStruct(),
line);
}
CefHandler::RetVal CefHandlerCToCpp::HandleFindResult(
CefRefPtr<CefBrowser> browser, int identifier, int count,
const CefRect& selectionRect, int activeMatchOrdinal, bool finalUpdate)
{
if(CEF_MEMBER_MISSING(struct_, handle_find_result))
return RV_CONTINUE;
return struct_->handle_find_result(struct_,
CefBrowserCppToC::Wrap(browser), identifier, count, &selectionRect,
activeMatchOrdinal, finalUpdate);
}
CefHandler::RetVal CefHandlerCToCpp::HandleGetRect(
CefRefPtr<CefBrowser> browser, bool screen, CefRect& rect)
{
if(CEF_MEMBER_MISSING(struct_, handle_get_rect))
return RV_CONTINUE;
return struct_->handle_get_rect(struct_, CefBrowserCppToC::Wrap(browser),
screen, &rect);
}
CefHandler::RetVal CefHandlerCToCpp::HandleGetScreenPoint(
CefRefPtr<CefBrowser> browser, int viewX, int viewY, int& screenX,
int& screenY)
{
if(CEF_MEMBER_MISSING(struct_, handle_get_screen_point))
return RV_CONTINUE;
return struct_->handle_get_screen_point(struct_,
CefBrowserCppToC::Wrap(browser), viewX, viewY, &screenX, &screenY);
}
CefHandler::RetVal CefHandlerCToCpp::HandlePopupChange(
CefRefPtr<CefBrowser> browser, bool show, const CefRect& rect)
{
if(CEF_MEMBER_MISSING(struct_, handle_popup_change))
return RV_CONTINUE;
return struct_->handle_popup_change(struct_, CefBrowserCppToC::Wrap(browser),
show, &rect);
}
CefHandler::RetVal CefHandlerCToCpp::HandlePaint(CefRefPtr<CefBrowser> browser,
PaintElementType type, const CefRect& dirtyRect, const void* buffer)
{
if(CEF_MEMBER_MISSING(struct_, handle_paint))
return RV_CONTINUE;
return struct_->handle_paint(struct_, CefBrowserCppToC::Wrap(browser), type,
&dirtyRect, buffer);
}
CefHandler::RetVal CefHandlerCToCpp::HandleCursorChange(
CefRefPtr<CefBrowser> browser, CefCursorHandle cursor)
{
if(CEF_MEMBER_MISSING(struct_, handle_cursor_change))
return RV_CONTINUE;
return struct_->handle_cursor_change(struct_, CefBrowserCppToC::Wrap(browser),
cursor);
}
#ifdef _DEBUG
template<> long CefCToCpp<CefHandlerCToCpp, CefHandler,
cef_handler_t>::DebugObjCt = 0;
#endif

115
libcef_dll/ctocpp/handler_ctocpp.h
View File

@@ -1,115 +0,0 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _HANDLER_CTOCPP_H
#define _HANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefHandlerCToCpp
: public CefCToCpp<CefHandlerCToCpp, CefHandler, cef_handler_t>
{
public:
CefHandlerCToCpp(cef_handler_t* str)
: CefCToCpp<CefHandlerCToCpp, CefHandler, cef_handler_t>(str) {}
virtual ~CefHandlerCToCpp() {}
// CefHandler methods
virtual RetVal HandleBeforeCreated(CefRefPtr<CefBrowser> parentBrowser,
CefWindowInfo& windowInfo, bool popup,
const CefPopupFeatures& popupFeatures, CefRefPtr<CefHandler>& handler,
const CefString& url, CefBrowserSettings& settings);
virtual RetVal HandleAfterCreated(CefRefPtr<CefBrowser> browser);
virtual RetVal HandleAddressChange(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& url);
virtual RetVal HandleTitleChange(CefRefPtr<CefBrowser> browser,
const CefString& title);
virtual RetVal HandleNavStateChange(CefRefPtr<CefBrowser> browser,
bool canGoBack, bool canGoForward);
virtual RetVal HandleBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefRefPtr<CefRequest> request,
NavType navType, bool isRedirect);
virtual RetVal HandleLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame);
virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, int httpStatusCode);
virtual RetVal HandleLoadError(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, ErrorCode errorCode,
const CefString& failedUrl, CefString& errorText);
virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request, CefString& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream,
CefRefPtr<CefResponse> response, int loadFlags);
virtual RetVal HandleProtocolExecution(CefRefPtr<CefBrowser> browser,
const CefString& url, bool& allow_os_execution);
virtual RetVal HandleDownloadResponse(CefRefPtr<CefBrowser> browser,
const CefString& mimeType, const CefString& fileName,
int64 contentLength, CefRefPtr<CefDownloadHandler>& handler);
virtual RetVal HandleAuthenticationRequest(CefRefPtr<CefBrowser> browser,
bool isProxy, const CefString& host, const CefString& realm,
const CefString& scheme, CefString& username, CefString& password);
virtual RetVal HandleBeforeMenu(CefRefPtr<CefBrowser> browser,
const MenuInfo& menuInfo);
virtual RetVal HandleGetMenuLabel(CefRefPtr<CefBrowser> browser,
MenuId menuId, CefString& label);
virtual RetVal HandleMenuAction(CefRefPtr<CefBrowser> browser, MenuId menuId);
virtual RetVal HandlePrintOptions(CefRefPtr<CefBrowser> browser,
CefPrintOptions& printOptions);
virtual RetVal HandlePrintHeaderFooter(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefPrintInfo& printInfo, const CefString& url,
const CefString& title, int currentPage, int maxPages,
CefString& topLeft, CefString& topCenter, CefString& topRight,
CefString& bottomLeft, CefString& bottomCenter, CefString& bottomRight);
virtual RetVal HandleJSAlert(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message);
virtual RetVal HandleJSConfirm(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message, bool& retval);
virtual RetVal HandleJSPrompt(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message,
const CefString& defaultValue, bool& retval, CefString& result);
virtual RetVal HandleJSBinding(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Value> object);
virtual RetVal HandleBeforeWindowClose(CefRefPtr<CefBrowser> browser);
virtual RetVal HandleTakeFocus(CefRefPtr<CefBrowser> browser, bool reverse);
virtual RetVal HandleSetFocus(CefRefPtr<CefBrowser> browser, bool isWidget);
virtual RetVal HandleKeyEvent(CefRefPtr<CefBrowser> browser,
KeyEventType type, int code, int modifiers, bool isSystemKey);
virtual RetVal HandleTooltip(CefRefPtr<CefBrowser> browser, CefString& text);
virtual RetVal HandleStatus(CefRefPtr<CefBrowser> browser,
const CefString& value, StatusType type);
virtual RetVal HandleConsoleMessage(CefRefPtr<CefBrowser> browser,
const CefString& message, const CefString& source, int line);
virtual RetVal HandleFindResult(CefRefPtr<CefBrowser> browser, int identifier,
int count, const CefRect& selectionRect, int activeMatchOrdinal,
bool finalUpdate);
virtual RetVal HandleGetRect(CefRefPtr<CefBrowser> browser, bool screen,
CefRect& rect);
virtual RetVal HandleGetScreenPoint(CefRefPtr<CefBrowser> browser, int viewX,
int viewY, int& screenX, int& screenY);
virtual RetVal HandlePopupChange(CefRefPtr<CefBrowser> browser, bool show,
const CefRect& rect);
virtual RetVal HandlePaint(CefRefPtr<CefBrowser> browser,
PaintElementType type, const CefRect& dirtyRect, const void* buffer);
virtual RetVal HandleCursorChange(CefRefPtr<CefBrowser> browser,
CefCursorHandle cursor);
};
#endif // BUILDING_CEF_SHARED
#endif // _HANDLER_CTOCPP_H

36
libcef_dll/ctocpp/jsbinding_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,36 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/cpptoc/frame_cpptoc.h"
#include "libcef_dll/cpptoc/v8value_cpptoc.h"
#include "libcef_dll/ctocpp/jsbinding_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
void CefJSBindingHandlerCToCpp::OnJSBinding(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Value> object)
{
if (CEF_MEMBER_MISSING(struct_, on_jsbinding))
return;
struct_->on_jsbinding(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), CefV8ValueCppToC::Wrap(object));
}
#ifndef NDEBUG
template<> long CefCToCpp<CefJSBindingHandlerCToCpp, CefJSBindingHandler,
cef_jsbinding_handler_t>::DebugObjCt = 0;
#endif

42
libcef_dll/ctocpp/jsbinding_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,42 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _JSBINDINGHANDLER_CTOCPP_H
#define _JSBINDINGHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefJSBindingHandlerCToCpp
: public CefCToCpp<CefJSBindingHandlerCToCpp, CefJSBindingHandler,
cef_jsbinding_handler_t>
{
public:
CefJSBindingHandlerCToCpp(cef_jsbinding_handler_t* str)
: CefCToCpp<CefJSBindingHandlerCToCpp, CefJSBindingHandler,
cef_jsbinding_handler_t>(str) {}
virtual ~CefJSBindingHandlerCToCpp() {}
// CefJSBindingHandler methods
virtual void OnJSBinding(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Value> object) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _JSBINDINGHANDLER_CTOCPP_H

63
libcef_dll/ctocpp/jsdialog_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,63 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/cpptoc/frame_cpptoc.h"
#include "libcef_dll/ctocpp/jsdialog_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
bool CefJSDialogHandlerCToCpp::OnJSAlert(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message)
{
if (CEF_MEMBER_MISSING(struct_, on_jsalert))
return false;
return struct_->on_jsalert(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), message.GetStruct()) ? true : false;
}
bool CefJSDialogHandlerCToCpp::OnJSConfirm(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message, bool& retval)
{
if (CEF_MEMBER_MISSING(struct_, on_jsconfirm))
return false;
int ret = 0;
int rv = struct_->on_jsconfirm(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), message.GetStruct(), &ret);
retval = (ret ? true : false);
return (rv ? true : false);
}
bool CefJSDialogHandlerCToCpp::OnJSPrompt(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message,
const CefString& defaultValue, bool& retval, CefString& result)
{
if (CEF_MEMBER_MISSING(struct_, on_jsprompt))
return false;
int ret = 0;
int rv = struct_->on_jsprompt(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), message.GetStruct(),
defaultValue.GetStruct(), &ret, result.GetWritableStruct());
retval = (ret ? true : false);
return (rv ? true : false);
}
#ifndef NDEBUG
template<> long CefCToCpp<CefJSDialogHandlerCToCpp, CefJSDialogHandler,
cef_jsdialog_handler_t>::DebugObjCt = 0;
#endif

49
libcef_dll/ctocpp/jsdialog_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,49 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _JSDIALOGHANDLER_CTOCPP_H
#define _JSDIALOGHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefJSDialogHandlerCToCpp
: public CefCToCpp<CefJSDialogHandlerCToCpp, CefJSDialogHandler,
cef_jsdialog_handler_t>
{
public:
CefJSDialogHandlerCToCpp(cef_jsdialog_handler_t* str)
: CefCToCpp<CefJSDialogHandlerCToCpp, CefJSDialogHandler,
cef_jsdialog_handler_t>(str) {}
virtual ~CefJSDialogHandlerCToCpp() {}
// CefJSDialogHandler methods
virtual bool OnJSAlert(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message) OVERRIDE;
virtual bool OnJSConfirm(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message,
bool& retval) OVERRIDE;
virtual bool OnJSPrompt(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefString& message,
const CefString& defaultValue, bool& retval,
CefString& result) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _JSDIALOGHANDLER_CTOCPP_H

34
libcef_dll/ctocpp/keyboard_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,34 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/ctocpp/keyboard_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
bool CefKeyboardHandlerCToCpp::OnKeyEvent(CefRefPtr<CefBrowser> browser,
KeyEventType type, int code, int modifiers, bool isSystemKey)
{
if (CEF_MEMBER_MISSING(struct_, on_key_event))
return false;
return struct_->on_key_event(struct_, CefBrowserCppToC::Wrap(browser),
type, code, modifiers, isSystemKey) ? true : false;
}
#ifndef NDEBUG
template<> long CefCToCpp<CefKeyboardHandlerCToCpp, CefKeyboardHandler,
cef_keyboard_handler_t>::DebugObjCt = 0;
#endif

42
libcef_dll/ctocpp/keyboard_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,42 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _KEYBOARDHANDLER_CTOCPP_H
#define _KEYBOARDHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefKeyboardHandlerCToCpp
: public CefCToCpp<CefKeyboardHandlerCToCpp, CefKeyboardHandler,
cef_keyboard_handler_t>
{
public:
CefKeyboardHandlerCToCpp(cef_keyboard_handler_t* str)
: CefCToCpp<CefKeyboardHandlerCToCpp, CefKeyboardHandler,
cef_keyboard_handler_t>(str) {}
virtual ~CefKeyboardHandlerCToCpp() {}
// CefKeyboardHandler methods
virtual bool OnKeyEvent(CefRefPtr<CefBrowser> browser, KeyEventType type,
int code, int modifiers, bool isSystemKey) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _KEYBOARDHANDLER_CTOCPP_H

71
libcef_dll/ctocpp/life_span_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,71 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/ctocpp/client_ctocpp.h"
#include "libcef_dll/ctocpp/life_span_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
bool CefLifeSpanHandlerCToCpp::OnBeforePopup(
CefRefPtr<CefBrowser> parentBrowser, const CefPopupFeatures& popupFeatures,
CefWindowInfo& windowInfo, const CefString& url,
CefRefPtr<CefClient>& client, CefBrowserSettings& settings)
{
if (CEF_MEMBER_MISSING(struct_, on_before_popup))
return false;
cef_browser_t* browserStruct = CefBrowserCppToC::Wrap(parentBrowser);
cef_client_t* clientStruct = NULL;
if(client.get())
clientStruct = CefClientCToCpp::Unwrap(client);
cef_client_t* origClientStruct = clientStruct;
int rv = struct_->on_before_popup(struct_,
browserStruct, &popupFeatures, &windowInfo, url.GetStruct(),
&clientStruct, &settings);
if (clientStruct) {
if (clientStruct != origClientStruct) {
// The handler was changed.
client = CefClientCToCpp::Wrap(clientStruct);
}
} else {
client = NULL;
}
return (rv ? true : false);
}
void CefLifeSpanHandlerCToCpp::OnAfterCreated(CefRefPtr<CefBrowser> browser)
{
if (CEF_MEMBER_MISSING(struct_, on_after_created))
return;
return struct_->on_after_created(struct_, CefBrowserCppToC::Wrap(browser));
}
void CefLifeSpanHandlerCToCpp::OnBeforeClose(CefRefPtr<CefBrowser> browser)
{
if (CEF_MEMBER_MISSING(struct_, on_before_close))
return;
return struct_->on_before_close(struct_, CefBrowserCppToC::Wrap(browser));
}
#ifndef NDEBUG
template<> long CefCToCpp<CefLifeSpanHandlerCToCpp, CefLifeSpanHandler,
cef_life_span_handler_t>::DebugObjCt = 0;
#endif

46
libcef_dll/ctocpp/life_span_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,46 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _LIFESPANHANDLER_CTOCPP_H
#define _LIFESPANHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefLifeSpanHandlerCToCpp
: public CefCToCpp<CefLifeSpanHandlerCToCpp, CefLifeSpanHandler,
cef_life_span_handler_t>
{
public:
CefLifeSpanHandlerCToCpp(cef_life_span_handler_t* str)
: CefCToCpp<CefLifeSpanHandlerCToCpp, CefLifeSpanHandler,
cef_life_span_handler_t>(str) {}
virtual ~CefLifeSpanHandlerCToCpp() {}
// CefLifeSpanHandler methods
virtual bool OnBeforePopup(CefRefPtr<CefBrowser> parentBrowser,
const CefPopupFeatures& popupFeatures, CefWindowInfo& windowInfo,
const CefString& url, CefRefPtr<CefClient>& client,
CefBrowserSettings& settings) OVERRIDE;
virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;
virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _LIFESPANHANDLER_CTOCPP_H

57
libcef_dll/ctocpp/load_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,57 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/cpptoc/frame_cpptoc.h"
#include "libcef_dll/ctocpp/load_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
void CefLoadHandlerCToCpp::OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame)
{
if (CEF_MEMBER_MISSING(struct_, on_load_start))
return;
struct_->on_load_start(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame));
}
void CefLoadHandlerCToCpp::OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, int httpStatusCode)
{
if (CEF_MEMBER_MISSING(struct_, on_load_end))
return;
struct_->on_load_end(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), httpStatusCode);
}
bool CefLoadHandlerCToCpp::OnLoadError(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, ErrorCode errorCode, const CefString& failedUrl,
CefString& errorText)
{
if (CEF_MEMBER_MISSING(struct_, on_load_error))
return false;
return struct_->on_load_error(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), errorCode, failedUrl.GetStruct(),
errorText.GetWritableStruct()) ? true : false;
}
#ifndef NDEBUG
template<> long CefCToCpp<CefLoadHandlerCToCpp, CefLoadHandler,
cef_load_handler_t>::DebugObjCt = 0;
#endif

46
libcef_dll/ctocpp/load_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,46 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _LOADHANDLER_CTOCPP_H
#define _LOADHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefLoadHandlerCToCpp
: public CefCToCpp<CefLoadHandlerCToCpp, CefLoadHandler, cef_load_handler_t>
{
public:
CefLoadHandlerCToCpp(cef_load_handler_t* str)
: CefCToCpp<CefLoadHandlerCToCpp, CefLoadHandler, cef_load_handler_t>(
str) {}
virtual ~CefLoadHandlerCToCpp() {}
// CefLoadHandler methods
virtual void OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) OVERRIDE;
virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, int httpStatusCode) OVERRIDE;
virtual bool OnLoadError(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, ErrorCode errorCode,
const CefString& failedUrl, CefString& errorText) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _LOADHANDLER_CTOCPP_H

54
libcef_dll/ctocpp/menu_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,54 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/ctocpp/menu_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
bool CefMenuHandlerCToCpp::OnBeforeMenu(CefRefPtr<CefBrowser> browser,
const MenuInfo& menuInfo)
{
if (CEF_MEMBER_MISSING(struct_, on_before_menu))
return false;
return struct_->on_before_menu(struct_, CefBrowserCppToC::Wrap(browser),
&menuInfo) ? true : false;
}
void CefMenuHandlerCToCpp::GetMenuLabel(CefRefPtr<CefBrowser> browser,
MenuId menuId, CefString& label)
{
if (CEF_MEMBER_MISSING(struct_, get_menu_label))
return;
return struct_->get_menu_label(struct_, CefBrowserCppToC::Wrap(browser),
menuId, label.GetWritableStruct());
}
bool CefMenuHandlerCToCpp::OnMenuAction(CefRefPtr<CefBrowser> browser,
MenuId menuId)
{
if (CEF_MEMBER_MISSING(struct_, on_menu_action))
return false;
return struct_->on_menu_action(struct_, CefBrowserCppToC::Wrap(browser),
menuId) ? true : false;
}
#ifndef NDEBUG
template<> long CefCToCpp<CefMenuHandlerCToCpp, CefMenuHandler,
cef_menu_handler_t>::DebugObjCt = 0;
#endif

45
libcef_dll/ctocpp/menu_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,45 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _MENUHANDLER_CTOCPP_H
#define _MENUHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefMenuHandlerCToCpp
: public CefCToCpp<CefMenuHandlerCToCpp, CefMenuHandler, cef_menu_handler_t>
{
public:
CefMenuHandlerCToCpp(cef_menu_handler_t* str)
: CefCToCpp<CefMenuHandlerCToCpp, CefMenuHandler, cef_menu_handler_t>(
str) {}
virtual ~CefMenuHandlerCToCpp() {}
// CefMenuHandler methods
virtual bool OnBeforeMenu(CefRefPtr<CefBrowser> browser,
const MenuInfo& menuInfo) OVERRIDE;
virtual void GetMenuLabel(CefRefPtr<CefBrowser> browser, MenuId menuId,
CefString& label) OVERRIDE;
virtual bool OnMenuAction(CefRefPtr<CefBrowser> browser,
MenuId menuId) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _MENUHANDLER_CTOCPP_H

4
libcef_dll/ctocpp/post_data_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -79,7 +79,7 @@ void CefPostDataCToCpp::RemoveElements()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefPostDataCToCpp, CefPostData,
cef_post_data_t>::DebugObjCt = 0;
#endif

12
libcef_dll/ctocpp/post_data_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,11 +31,11 @@ public:
virtual ~CefPostDataCToCpp() {}
// CefPostData methods
virtual size_t GetElementCount();
virtual void GetElements(ElementVector& elements);
virtual bool RemoveElement(CefRefPtr<CefPostDataElement> element);
virtual bool AddElement(CefRefPtr<CefPostDataElement> element);
virtual void RemoveElements();
virtual size_t GetElementCount() OVERRIDE;
virtual void GetElements(ElementVector& elements) OVERRIDE;
virtual bool RemoveElement(CefRefPtr<CefPostDataElement> element) OVERRIDE;
virtual bool AddElement(CefRefPtr<CefPostDataElement> element) OVERRIDE;
virtual void RemoveElements() OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/post_data_element_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -86,7 +86,7 @@ size_t CefPostDataElementCToCpp::GetBytes(size_t size, void* bytes)
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefPostDataElementCToCpp, CefPostDataElement,
cef_post_data_element_t>::DebugObjCt = 0;
#endif

16
libcef_dll/ctocpp/post_data_element_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,13 +33,13 @@ public:
virtual ~CefPostDataElementCToCpp() {}
// CefPostDataElement methods
virtual void SetToEmpty();
virtual void SetToFile(const CefString& fileName);
virtual void SetToBytes(size_t size, const void* bytes);
virtual Type GetType();
virtual CefString GetFile();
virtual size_t GetBytesCount();
virtual size_t GetBytes(size_t size, void* bytes);
virtual void SetToEmpty() OVERRIDE;
virtual void SetToFile(const CefString& fileName) OVERRIDE;
virtual void SetToBytes(size_t size, const void* bytes) OVERRIDE;
virtual Type GetType() OVERRIDE;
virtual CefString GetFile() OVERRIDE;
virtual size_t GetBytesCount() OVERRIDE;
virtual size_t GetBytes(size_t size, void* bytes) OVERRIDE;
};
#endif // USING_CEF_SHARED

54
libcef_dll/ctocpp/print_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,54 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/cpptoc/frame_cpptoc.h"
#include "libcef_dll/ctocpp/print_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
bool CefPrintHandlerCToCpp::GetPrintOptions(CefRefPtr<CefBrowser> browser,
CefPrintOptions& printOptions)
{
if (CEF_MEMBER_MISSING(struct_, get_print_options))
return false;
return struct_->get_print_options(struct_, CefBrowserCppToC::Wrap(browser),
&printOptions) ? true : false;
}
bool CefPrintHandlerCToCpp::GetPrintHeaderFooter(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefPrintInfo& printInfo,
const CefString& url, const CefString& title, int currentPage,
int maxPages, CefString& topLeft, CefString& topCenter,
CefString& topRight, CefString& bottomLeft, CefString& bottomCenter,
CefString& bottomRight)
{
if (CEF_MEMBER_MISSING(struct_, get_print_header_footer))
return false;
return struct_->get_print_header_footer(struct_,
CefBrowserCppToC::Wrap(browser), CefFrameCppToC::Wrap(frame),
&printInfo, url.GetStruct(), title.GetStruct(), currentPage, maxPages,
topLeft.GetWritableStruct(), topCenter.GetWritableStruct(),
topRight.GetWritableStruct(), bottomLeft.GetWritableStruct(),
bottomCenter.GetWritableStruct(), bottomRight.GetWritableStruct()) ?
true : false;
}
#ifndef NDEBUG
template<> long CefCToCpp<CefPrintHandlerCToCpp, CefPrintHandler,
cef_print_handler_t>::DebugObjCt = 0;
#endif

48
libcef_dll/ctocpp/print_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,48 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _PRINTHANDLER_CTOCPP_H
#define _PRINTHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefPrintHandlerCToCpp
: public CefCToCpp<CefPrintHandlerCToCpp, CefPrintHandler,
cef_print_handler_t>
{
public:
CefPrintHandlerCToCpp(cef_print_handler_t* str)
: CefCToCpp<CefPrintHandlerCToCpp, CefPrintHandler, cef_print_handler_t>(
str) {}
virtual ~CefPrintHandlerCToCpp() {}
// CefPrintHandler methods
virtual bool GetPrintOptions(CefRefPtr<CefBrowser> browser,
CefPrintOptions& printOptions) OVERRIDE;
virtual bool GetPrintHeaderFooter(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, const CefPrintInfo& printInfo,
const CefString& url, const CefString& title, int currentPage,
int maxPages, CefString& topLeft, CefString& topCenter,
CefString& topRight, CefString& bottomLeft, CefString& bottomCenter,
CefString& bottomRight) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _PRINTHANDLER_CTOCPP_H

4
libcef_dll/ctocpp/read_handler_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -48,7 +48,7 @@ int CefReadHandlerCToCpp::Eof()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefReadHandlerCToCpp, CefReadHandler,
cef_read_handler_t>::DebugObjCt = 0;
#endif

10
libcef_dll/ctocpp/read_handler_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -32,10 +32,10 @@ public:
virtual ~CefReadHandlerCToCpp() {}
// CefReadHandler methods
virtual size_t Read(void* ptr, size_t size, size_t n);
virtual int Seek(long offset, int whence);
virtual long Tell();
virtual int Eof();
virtual size_t Read(void* ptr, size_t size, size_t n) OVERRIDE;
virtual int Seek(long offset, int whence) OVERRIDE;
virtual long Tell() OVERRIDE;
virtual int Eof() OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

93
libcef_dll/ctocpp/render_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,93 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/ctocpp/render_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
bool CefRenderHandlerCToCpp::GetViewRect(CefRefPtr<CefBrowser> browser,
CefRect& rect)
{
if (CEF_MEMBER_MISSING(struct_, get_view_rect))
return false;
return struct_->get_view_rect(struct_, CefBrowserCppToC::Wrap(browser),
&rect) ? true : false;
}
bool CefRenderHandlerCToCpp::GetScreenRect(CefRefPtr<CefBrowser> browser,
CefRect& rect)
{
if (CEF_MEMBER_MISSING(struct_, get_screen_rect))
return false;
return struct_->get_screen_rect(struct_, CefBrowserCppToC::Wrap(browser),
&rect) ? true : false;
}
bool CefRenderHandlerCToCpp::GetScreenPoint(CefRefPtr<CefBrowser> browser,
int viewX, int viewY, int& screenX, int& screenY)
{
if (CEF_MEMBER_MISSING(struct_, get_screen_point))
return false;
return struct_->get_screen_point(struct_, CefBrowserCppToC::Wrap(browser),
viewX, viewY, &screenX, &screenY) ? true : false;
}
void CefRenderHandlerCToCpp::OnPopupShow(CefRefPtr<CefBrowser> browser,
bool show)
{
if (CEF_MEMBER_MISSING(struct_, on_popup_show))
return;
struct_->on_popup_show(struct_, CefBrowserCppToC::Wrap(browser), show);
}
void CefRenderHandlerCToCpp::OnPopupSize(CefRefPtr<CefBrowser> browser,
const CefRect& rect)
{
// BEGIN DELETE BEFORE MODIFYING
if (CEF_MEMBER_MISSING(struct_, on_popup_size))
return;
struct_->on_popup_size(struct_, CefBrowserCppToC::Wrap(browser), &rect);
}
void CefRenderHandlerCToCpp::OnPaint(CefRefPtr<CefBrowser> browser,
PaintElementType type, const CefRect& dirtyRect, const void* buffer)
{
if (CEF_MEMBER_MISSING(struct_, on_paint))
return;
return struct_->on_paint(struct_, CefBrowserCppToC::Wrap(browser), type,
&dirtyRect, buffer);
}
void CefRenderHandlerCToCpp::OnCursorChange(CefRefPtr<CefBrowser> browser,
CefCursorHandle cursor)
{
if (CEF_MEMBER_MISSING(struct_, on_cursor_change))
return;
return struct_->on_cursor_change(struct_, CefBrowserCppToC::Wrap(browser),
cursor);
}
#ifndef NDEBUG
template<> long CefCToCpp<CefRenderHandlerCToCpp, CefRenderHandler,
cef_render_handler_t>::DebugObjCt = 0;
#endif

53
libcef_dll/ctocpp/render_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,53 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _RENDERHANDLER_CTOCPP_H
#define _RENDERHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefRenderHandlerCToCpp
: public CefCToCpp<CefRenderHandlerCToCpp, CefRenderHandler,
cef_render_handler_t>
{
public:
CefRenderHandlerCToCpp(cef_render_handler_t* str)
: CefCToCpp<CefRenderHandlerCToCpp, CefRenderHandler,
cef_render_handler_t>(str) {}
virtual ~CefRenderHandlerCToCpp() {}
// CefRenderHandler methods
virtual bool GetViewRect(CefRefPtr<CefBrowser> browser,
CefRect& rect) OVERRIDE;
virtual bool GetScreenRect(CefRefPtr<CefBrowser> browser,
CefRect& rect) OVERRIDE;
virtual bool GetScreenPoint(CefRefPtr<CefBrowser> browser, int viewX,
int viewY, int& screenX, int& screenY) OVERRIDE;
virtual void OnPopupShow(CefRefPtr<CefBrowser> browser, bool show) OVERRIDE;
virtual void OnPopupSize(CefRefPtr<CefBrowser> browser,
const CefRect& rect) OVERRIDE;
virtual void OnPaint(CefRefPtr<CefBrowser> browser, PaintElementType type,
const CefRect& dirtyRect, const void* buffer) OVERRIDE;
virtual void OnCursorChange(CefRefPtr<CefBrowser> browser,
CefCursorHandle cursor) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _RENDERHANDLER_CTOCPP_H

4
libcef_dll/ctocpp/request_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -183,7 +183,7 @@ void CefRequestCToCpp::SetFirstPartyForCookies(const CefString& url)
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefRequestCToCpp, CefRequest,
cef_request_t>::DebugObjCt = 0;
#endif

28
libcef_dll/ctocpp/request_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,20 +31,20 @@ public:
virtual ~CefRequestCToCpp() {}
// CefRequest methods
virtual CefString GetURL();
virtual void SetURL(const CefString& url);
virtual CefString GetMethod();
virtual void SetMethod(const CefString& method);
virtual CefRefPtr<CefPostData> GetPostData();
virtual void SetPostData(CefRefPtr<CefPostData> postData);
virtual void GetHeaderMap(HeaderMap& headerMap);
virtual void SetHeaderMap(const HeaderMap& headerMap);
virtual CefString GetURL() OVERRIDE;
virtual void SetURL(const CefString& url) OVERRIDE;
virtual CefString GetMethod() OVERRIDE;
virtual void SetMethod(const CefString& method) OVERRIDE;
virtual CefRefPtr<CefPostData> GetPostData() OVERRIDE;
virtual void SetPostData(CefRefPtr<CefPostData> postData) OVERRIDE;
virtual void GetHeaderMap(HeaderMap& headerMap) OVERRIDE;
virtual void SetHeaderMap(const HeaderMap& headerMap) OVERRIDE;
virtual void Set(const CefString& url, const CefString& method,
CefRefPtr<CefPostData> postData, const HeaderMap& headerMap);
virtual RequestFlags GetFlags();
virtual void SetFlags(RequestFlags flags);
virtual CefString GetFirstPartyForCookies();
virtual void SetFirstPartyForCookies(const CefString& url);
CefRefPtr<CefPostData> postData, const HeaderMap& headerMap) OVERRIDE;
virtual RequestFlags GetFlags() OVERRIDE;
virtual void SetFlags(RequestFlags flags) OVERRIDE;
virtual CefString GetFirstPartyForCookies() OVERRIDE;
virtual void SetFirstPartyForCookies(const CefString& url) OVERRIDE;
};
#endif // USING_CEF_SHARED

107
libcef_dll/ctocpp/request_handler_ctocpp.cc Normal file
View File

@@ -0,0 +1,107 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// A portion of this file was generated by the CEF translator tool. When
// making changes by hand only do so within the body of existing static and
// virtual method implementations. See the translator.README.txt file in the
// tools directory for more information.
//
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/cpptoc/frame_cpptoc.h"
#include "libcef_dll/cpptoc/request_cpptoc.h"
#include "libcef_dll/cpptoc/response_cpptoc.h"
#include "libcef_dll/cpptoc/stream_reader_cpptoc.h"
#include "libcef_dll/ctocpp/download_handler_ctocpp.h"
#include "libcef_dll/ctocpp/request_handler_ctocpp.h"
// VIRTUAL METHODS - Body may be edited by hand.
bool CefRequestHandlerCToCpp::OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefRefPtr<CefRequest> request, NavType navType,
bool isRedirect)
{
if (CEF_MEMBER_MISSING(struct_, on_before_browse))
return true;
return struct_->on_before_browse(struct_, CefBrowserCppToC::Wrap(browser),
CefFrameCppToC::Wrap(frame), CefRequestCppToC::Wrap(request),
navType, isRedirect) ? true : false;
}
bool CefRequestHandlerCToCpp::OnBeforeResourceLoad(
CefRefPtr<CefBrowser> browser, CefRefPtr<CefRequest> request,
CefString& redirectUrl, CefRefPtr<CefStreamReader>& resourceStream,
CefRefPtr<CefResponse> response, int loadFlags)
{
if (CEF_MEMBER_MISSING(struct_, on_before_resource_load))
return false;
cef_stream_reader_t* streamRet = NULL;
int rv = struct_->on_before_resource_load(struct_,
CefBrowserCppToC::Wrap(browser), CefRequestCppToC::Wrap(request),
redirectUrl.GetWritableStruct(), &streamRet,
CefResponseCppToC::Wrap(response), loadFlags);
if(streamRet)
resourceStream = CefStreamReaderCppToC::Unwrap(streamRet);
return (rv ? true : false);
}
bool CefRequestHandlerCToCpp::OnProtocolExecution(CefRefPtr<CefBrowser> browser,
const CefString& url, bool& allowOSExecution)
{
if (CEF_MEMBER_MISSING(struct_, on_protocol_execution))
return false;
int allowExec = allowOSExecution;
int rv = struct_->on_protocol_execution(struct_,
CefBrowserCppToC::Wrap(browser), url.GetStruct(), &allowExec);
allowOSExecution = allowExec?true:false;
return (rv ? true : false);
}
bool CefRequestHandlerCToCpp::GetDownloadHandler(CefRefPtr<CefBrowser> browser,
const CefString& mimeType, const CefString& fileName, int64 contentLength,
CefRefPtr<CefDownloadHandler>& handler)
{
if (CEF_MEMBER_MISSING(struct_, get_download_handler))
return false;
cef_download_handler_t* handlerRet = NULL;
int rv = struct_->get_download_handler(struct_,
CefBrowserCppToC::Wrap(browser), mimeType.GetStruct(),
fileName.GetStruct(), contentLength, &handlerRet);
if(handlerRet)
handler = CefDownloadHandlerCToCpp::Wrap(handlerRet);
return (rv ? true : false);
}
bool CefRequestHandlerCToCpp::GetAuthCredentials(CefRefPtr<CefBrowser> browser,
bool isProxy, const CefString& host, const CefString& realm,
const CefString& scheme, CefString& username, CefString& password)
{
if (CEF_MEMBER_MISSING(struct_, get_auth_credentials))
return false;
return struct_->get_auth_credentials(struct_, CefBrowserCppToC::Wrap(browser),
isProxy, host.GetStruct(), realm.GetStruct(), scheme.GetStruct(),
username.GetWritableStruct(), password.GetWritableStruct()) ?
true : false;
}
#ifndef NDEBUG
template<> long CefCToCpp<CefRequestHandlerCToCpp, CefRequestHandler,
cef_request_handler_t>::DebugObjCt = 0;
#endif

55
libcef_dll/ctocpp/request_handler_ctocpp.h Normal file
View File

@@ -0,0 +1,55 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// -------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef _REQUESTHANDLER_CTOCPP_H
#define _REQUESTHANDLER_CTOCPP_H
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include "include/cef.h"
#include "include/cef_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefRequestHandlerCToCpp
: public CefCToCpp<CefRequestHandlerCToCpp, CefRequestHandler,
cef_request_handler_t>
{
public:
CefRequestHandlerCToCpp(cef_request_handler_t* str)
: CefCToCpp<CefRequestHandlerCToCpp, CefRequestHandler,
cef_request_handler_t>(str) {}
virtual ~CefRequestHandlerCToCpp() {}
// CefRequestHandler methods
virtual bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame, CefRefPtr<CefRequest> request,
NavType navType, bool isRedirect) OVERRIDE;
virtual bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request, CefString& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream,
CefRefPtr<CefResponse> response, int loadFlags) OVERRIDE;
virtual bool OnProtocolExecution(CefRefPtr<CefBrowser> browser,
const CefString& url, bool& allowOSExecution) OVERRIDE;
virtual bool GetDownloadHandler(CefRefPtr<CefBrowser> browser,
const CefString& mimeType, const CefString& fileName,
int64 contentLength, CefRefPtr<CefDownloadHandler>& handler) OVERRIDE;
virtual bool GetAuthCredentials(CefRefPtr<CefBrowser> browser, bool isProxy,
const CefString& host, const CefString& realm, const CefString& scheme,
CefString& username, CefString& password) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED
#endif // _REQUESTHANDLER_CTOCPP_H

4
libcef_dll/ctocpp/response_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -115,7 +115,7 @@ void CefResponseCToCpp::SetHeaderMap(const HeaderMap& headerMap)
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefResponseCToCpp, CefResponse,
cef_response_t>::DebugObjCt = 0;
#endif

20
libcef_dll/ctocpp/response_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,15 +31,15 @@ public:
virtual ~CefResponseCToCpp() {}
// CefResponse methods
virtual int GetStatus();
virtual void SetStatus(int status);
virtual CefString GetStatusText();
virtual void SetStatusText(const CefString& statusText);
virtual CefString GetMimeType();
virtual void SetMimeType(const CefString& mimeType);
virtual CefString GetHeader(const CefString& name);
virtual void GetHeaderMap(HeaderMap& headerMap);
virtual void SetHeaderMap(const HeaderMap& headerMap);
virtual int GetStatus() OVERRIDE;
virtual void SetStatus(int status) OVERRIDE;
virtual CefString GetStatusText() OVERRIDE;
virtual void SetStatusText(const CefString& statusText) OVERRIDE;
virtual CefString GetMimeType() OVERRIDE;
virtual void SetMimeType(const CefString& mimeType) OVERRIDE;
virtual CefString GetHeader(const CefString& name) OVERRIDE;
virtual void GetHeaderMap(HeaderMap& headerMap) OVERRIDE;
virtual void SetHeaderMap(const HeaderMap& headerMap) OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/scheme_handler_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -48,7 +48,7 @@ bool CefSchemeHandlerCToCpp::ReadResponse(void* data_out, int bytes_to_read,
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefSchemeHandlerCToCpp, CefSchemeHandler,
cef_scheme_handler_t>::DebugObjCt = 0;
#endif

9
libcef_dll/ctocpp/scheme_handler_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -35,9 +35,10 @@ public:
// CefSchemeHandler methods
virtual bool ProcessRequest(CefRefPtr<CefRequest> request,
CefString& redirectUrl, CefRefPtr<CefResponse> response,
int* response_length);
virtual void Cancel();
virtual bool ReadResponse(void* data_out, int bytes_to_read, int* bytes_read);
int* response_length) OVERRIDE;
virtual void Cancel() OVERRIDE;
virtual bool ReadResponse(void* data_out, int bytes_to_read,
int* bytes_read) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/scheme_handler_factory_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -27,7 +27,7 @@ CefRefPtr<CefSchemeHandler> CefSchemeHandlerFactoryCToCpp::Create()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefSchemeHandlerFactoryCToCpp,
CefSchemeHandlerFactory, cef_scheme_handler_factory_t>::DebugObjCt = 0;
#endif

4
libcef_dll/ctocpp/scheme_handler_factory_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,7 +33,7 @@ public:
virtual ~CefSchemeHandlerFactoryCToCpp() {}
// CefSchemeHandlerFactory methods
virtual CefRefPtr<CefSchemeHandler> Create();
virtual CefRefPtr<CefSchemeHandler> Create() OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/stream_reader_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -81,7 +81,7 @@ int CefStreamReaderCToCpp::Eof()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefStreamReaderCToCpp, CefStreamReader,
cef_stream_reader_t>::DebugObjCt = 0;
#endif

10
libcef_dll/ctocpp/stream_reader_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,10 +33,10 @@ public:
virtual ~CefStreamReaderCToCpp() {}
// CefStreamReader methods
virtual size_t Read(void* ptr, size_t size, size_t n);
virtual int Seek(long offset, int whence);
virtual long Tell();
virtual int Eof();
virtual size_t Read(void* ptr, size_t size, size_t n) OVERRIDE;
virtual int Seek(long offset, int whence) OVERRIDE;
virtual long Tell() OVERRIDE;
virtual int Eof() OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/stream_writer_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -81,7 +81,7 @@ int CefStreamWriterCToCpp::Flush()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefStreamWriterCToCpp, CefStreamWriter,
cef_stream_writer_t>::DebugObjCt = 0;
#endif

10
libcef_dll/ctocpp/stream_writer_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,10 +33,10 @@ public:
virtual ~CefStreamWriterCToCpp() {}
// CefStreamWriter methods
virtual size_t Write(const void* ptr, size_t size, size_t n);
virtual int Seek(long offset, int whence);
virtual long Tell();
virtual int Flush();
virtual size_t Write(const void* ptr, size_t size, size_t n) OVERRIDE;
virtual int Seek(long offset, int whence) OVERRIDE;
virtual long Tell() OVERRIDE;
virtual int Flush() OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/task_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -24,7 +24,7 @@ void CefTaskCToCpp::Execute(CefThreadId threadId)
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefTaskCToCpp, CefTask, cef_task_t>::DebugObjCt = 0;
#endif

4
libcef_dll/ctocpp/task_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,7 +31,7 @@ public:
virtual ~CefTaskCToCpp() {}
// CefTask methods
virtual void Execute(CefThreadId threadId);
virtual void Execute(CefThreadId threadId) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/v8accessor_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -46,7 +46,7 @@ bool CefV8AccessorCToCpp::Set(const CefString& name,
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefV8AccessorCToCpp, CefV8Accessor,
cef_v8accessor_t>::DebugObjCt = 0;
#endif

6
libcef_dll/ctocpp/v8accessor_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -32,9 +32,9 @@ public:
// CefV8Accessor methods
virtual bool Get(const CefString& name, const CefRefPtr<CefV8Value> object,
CefRefPtr<CefV8Value>& retval);
CefRefPtr<CefV8Value>& retval) OVERRIDE;
virtual bool Set(const CefString& name, const CefRefPtr<CefV8Value> object,
const CefRefPtr<CefV8Value> value);
const CefRefPtr<CefV8Value> value) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/v8context_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -90,7 +90,7 @@ bool CefV8ContextCToCpp::Exit()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefV8ContextCToCpp, CefV8Context,
cef_v8context_t>::DebugObjCt = 0;
#endif

12
libcef_dll/ctocpp/v8context_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,11 +31,11 @@ public:
virtual ~CefV8ContextCToCpp() {}
// CefV8Context methods
virtual CefRefPtr<CefBrowser> GetBrowser();
virtual CefRefPtr<CefFrame> GetFrame();
virtual CefRefPtr<CefV8Value> GetGlobal();
virtual bool Enter();
virtual bool Exit();
virtual CefRefPtr<CefBrowser> GetBrowser() OVERRIDE;
virtual CefRefPtr<CefFrame> GetFrame() OVERRIDE;
virtual CefRefPtr<CefV8Value> GetGlobal() OVERRIDE;
virtual bool Enter() OVERRIDE;
virtual bool Exit() OVERRIDE;
};
#endif // USING_CEF_SHARED

6
libcef_dll/ctocpp/v8handler_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -21,7 +21,7 @@ bool CefV8HandlerCToCpp::Execute(const CefString& name,
CefRefPtr<CefV8Value>& retval, CefString& exception)
{
if(CEF_MEMBER_MISSING(struct_, execute))
return RV_CONTINUE;
return false;
cef_v8value_t** argsStructPtr = NULL;
int argsSize = arguments.size();
@@ -46,7 +46,7 @@ bool CefV8HandlerCToCpp::Execute(const CefString& name,
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefV8HandlerCToCpp, CefV8Handler,
cef_v8handler_t>::DebugObjCt = 0;
#endif

4
libcef_dll/ctocpp/v8handler_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,7 +33,7 @@ public:
// CefV8Handler methods
virtual bool Execute(const CefString& name, CefRefPtr<CefV8Value> object,
const CefV8ValueList& arguments, CefRefPtr<CefV8Value>& retval,
CefString& exception);
CefString& exception) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/v8value_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -439,7 +439,7 @@ bool CefV8ValueCToCpp::ExecuteFunctionWithContext(
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefV8ValueCToCpp, CefV8Value,
cef_v8value_t>::DebugObjCt = 0;
#endif

63
libcef_dll/ctocpp/v8value_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,41 +31,42 @@ public:
virtual ~CefV8ValueCToCpp() {}
// CefV8Value methods
virtual bool IsUndefined();
virtual bool IsNull();
virtual bool IsBool();
virtual bool IsInt();
virtual bool IsDouble();
virtual bool IsString();
virtual bool IsObject();
virtual bool IsArray();
virtual bool IsFunction();
virtual bool IsSame(CefRefPtr<CefV8Value> that);
virtual bool GetBoolValue();
virtual int GetIntValue();
virtual double GetDoubleValue();
virtual CefString GetStringValue();
virtual bool HasValue(const CefString& key);
virtual bool HasValue(int index);
virtual bool DeleteValue(const CefString& key);
virtual bool DeleteValue(int index);
virtual CefRefPtr<CefV8Value> GetValue(const CefString& key);
virtual CefRefPtr<CefV8Value> GetValue(int index);
virtual bool SetValue(const CefString& key, CefRefPtr<CefV8Value> value);
virtual bool SetValue(int index, CefRefPtr<CefV8Value> value);
virtual bool IsUndefined() OVERRIDE;
virtual bool IsNull() OVERRIDE;
virtual bool IsBool() OVERRIDE;
virtual bool IsInt() OVERRIDE;
virtual bool IsDouble() OVERRIDE;
virtual bool IsString() OVERRIDE;
virtual bool IsObject() OVERRIDE;
virtual bool IsArray() OVERRIDE;
virtual bool IsFunction() OVERRIDE;
virtual bool IsSame(CefRefPtr<CefV8Value> that) OVERRIDE;
virtual bool GetBoolValue() OVERRIDE;
virtual int GetIntValue() OVERRIDE;
virtual double GetDoubleValue() OVERRIDE;
virtual CefString GetStringValue() OVERRIDE;
virtual bool HasValue(const CefString& key) OVERRIDE;
virtual bool HasValue(int index) OVERRIDE;
virtual bool DeleteValue(const CefString& key) OVERRIDE;
virtual bool DeleteValue(int index) OVERRIDE;
virtual CefRefPtr<CefV8Value> GetValue(const CefString& key) OVERRIDE;
virtual CefRefPtr<CefV8Value> GetValue(int index) OVERRIDE;
virtual bool SetValue(const CefString& key,
CefRefPtr<CefV8Value> value) OVERRIDE;
virtual bool SetValue(int index, CefRefPtr<CefV8Value> value) OVERRIDE;
virtual bool SetValue(const CefString& key, AccessControl settings,
PropertyAttribute attribute);
virtual bool GetKeys(std::vector<CefString>& keys);
virtual CefRefPtr<CefBase> GetUserData();
virtual int GetArrayLength();
virtual CefString GetFunctionName();
virtual CefRefPtr<CefV8Handler> GetFunctionHandler();
PropertyAttribute attribute) OVERRIDE;
virtual bool GetKeys(std::vector<CefString>& keys) OVERRIDE;
virtual CefRefPtr<CefBase> GetUserData() OVERRIDE;
virtual int GetArrayLength() OVERRIDE;
virtual CefString GetFunctionName() OVERRIDE;
virtual CefRefPtr<CefV8Handler> GetFunctionHandler() OVERRIDE;
virtual bool ExecuteFunction(CefRefPtr<CefV8Value> object,
const CefV8ValueList& arguments, CefRefPtr<CefV8Value>& retval,
CefString& exception);
CefString& exception) OVERRIDE;
virtual bool ExecuteFunctionWithContext(CefRefPtr<CefV8Context> context,
CefRefPtr<CefV8Value> object, const CefV8ValueList& arguments,
CefRefPtr<CefV8Value>& retval, CefString& exception);
CefRefPtr<CefV8Value>& retval, CefString& exception) OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/web_urlrequest_client_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -81,7 +81,7 @@ void CefWebURLRequestClientCToCpp::OnError(
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefWebURLRequestClientCToCpp, CefWebURLRequestClient,
cef_web_urlrequest_client_t>::DebugObjCt = 0;
#endif

15
libcef_dll/ctocpp/web_urlrequest_client_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -34,17 +34,18 @@ public:
// CefWebURLRequestClient methods
virtual void OnStateChange(CefRefPtr<CefWebURLRequest> requester,
RequestState state);
RequestState state) OVERRIDE;
virtual void OnRedirect(CefRefPtr<CefWebURLRequest> requester,
CefRefPtr<CefRequest> request, CefRefPtr<CefResponse> response);
CefRefPtr<CefRequest> request,
CefRefPtr<CefResponse> response) OVERRIDE;
virtual void OnHeadersReceived(CefRefPtr<CefWebURLRequest> requester,
CefRefPtr<CefResponse> response);
CefRefPtr<CefResponse> response) OVERRIDE;
virtual void OnProgress(CefRefPtr<CefWebURLRequest> requester,
uint64 bytesSent, uint64 totalBytesToBeSent);
uint64 bytesSent, uint64 totalBytesToBeSent) OVERRIDE;
virtual void OnData(CefRefPtr<CefWebURLRequest> requester, const void* data,
int dataLength);
int dataLength) OVERRIDE;
virtual void OnError(CefRefPtr<CefWebURLRequest> requester,
ErrorCode errorCode);
ErrorCode errorCode) OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/web_urlrequest_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -55,7 +55,7 @@ CefWebURLRequest::RequestState CefWebURLRequestCToCpp::GetState()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefWebURLRequestCToCpp, CefWebURLRequest,
cef_web_urlrequest_t>::DebugObjCt = 0;
#endif

6
libcef_dll/ctocpp/web_urlrequest_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,8 +33,8 @@ public:
virtual ~CefWebURLRequestCToCpp() {}
// CefWebURLRequest methods
virtual void Cancel();
virtual RequestState GetState();
virtual void Cancel() OVERRIDE;
virtual RequestState GetState() OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/write_handler_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -48,7 +48,7 @@ int CefWriteHandlerCToCpp::Flush()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefWriteHandlerCToCpp, CefWriteHandler,
cef_write_handler_t>::DebugObjCt = 0;
#endif

10
libcef_dll/ctocpp/write_handler_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -33,10 +33,10 @@ public:
virtual ~CefWriteHandlerCToCpp() {}
// CefWriteHandler methods
virtual size_t Write(const void* ptr, size_t size, size_t n);
virtual int Seek(long offset, int whence);
virtual long Tell();
virtual int Flush();
virtual size_t Write(const void* ptr, size_t size, size_t n) OVERRIDE;
virtual int Seek(long offset, int whence) OVERRIDE;
virtual long Tell() OVERRIDE;
virtual int Flush() OVERRIDE;
};
#endif // BUILDING_CEF_SHARED

4
libcef_dll/ctocpp/xml_reader_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -307,7 +307,7 @@ bool CefXmlReaderCToCpp::MoveToCarryingElement()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefXmlReaderCToCpp, CefXmlReader,
cef_xml_reader_t>::DebugObjCt = 0;
#endif

60
libcef_dll/ctocpp/xml_reader_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,37 +31,37 @@ public:
virtual ~CefXmlReaderCToCpp() {}
// CefXmlReader methods
virtual bool MoveToNextNode();
virtual bool Close();
virtual bool HasError();
virtual CefString GetError();
virtual NodeType GetType();
virtual int GetDepth();
virtual CefString GetLocalName();
virtual CefString GetPrefix();
virtual CefString GetQualifiedName();
virtual CefString GetNamespaceURI();
virtual CefString GetBaseURI();
virtual CefString GetXmlLang();
virtual bool IsEmptyElement();
virtual bool HasValue();
virtual CefString GetValue();
virtual bool HasAttributes();
virtual size_t GetAttributeCount();
virtual CefString GetAttribute(int index);
virtual CefString GetAttribute(const CefString& qualifiedName);
virtual bool MoveToNextNode() OVERRIDE;
virtual bool Close() OVERRIDE;
virtual bool HasError() OVERRIDE;
virtual CefString GetError() OVERRIDE;
virtual NodeType GetType() OVERRIDE;
virtual int GetDepth() OVERRIDE;
virtual CefString GetLocalName() OVERRIDE;
virtual CefString GetPrefix() OVERRIDE;
virtual CefString GetQualifiedName() OVERRIDE;
virtual CefString GetNamespaceURI() OVERRIDE;
virtual CefString GetBaseURI() OVERRIDE;
virtual CefString GetXmlLang() OVERRIDE;
virtual bool IsEmptyElement() OVERRIDE;
virtual bool HasValue() OVERRIDE;
virtual CefString GetValue() OVERRIDE;
virtual bool HasAttributes() OVERRIDE;
virtual size_t GetAttributeCount() OVERRIDE;
virtual CefString GetAttribute(int index) OVERRIDE;
virtual CefString GetAttribute(const CefString& qualifiedName) OVERRIDE;
virtual CefString GetAttribute(const CefString& localName,
const CefString& namespaceURI);
virtual CefString GetInnerXml();
virtual CefString GetOuterXml();
virtual int GetLineNumber();
virtual bool MoveToAttribute(int index);
virtual bool MoveToAttribute(const CefString& qualifiedName);
const CefString& namespaceURI) OVERRIDE;
virtual CefString GetInnerXml() OVERRIDE;
virtual CefString GetOuterXml() OVERRIDE;
virtual int GetLineNumber() OVERRIDE;
virtual bool MoveToAttribute(int index) OVERRIDE;
virtual bool MoveToAttribute(const CefString& qualifiedName) OVERRIDE;
virtual bool MoveToAttribute(const CefString& localName,
const CefString& namespaceURI);
virtual bool MoveToFirstAttribute();
virtual bool MoveToNextAttribute();
virtual bool MoveToCarryingElement();
const CefString& namespaceURI) OVERRIDE;
virtual bool MoveToFirstAttribute() OVERRIDE;
virtual bool MoveToNextAttribute() OVERRIDE;
virtual bool MoveToCarryingElement() OVERRIDE;
};
#endif // USING_CEF_SHARED

4
libcef_dll/ctocpp/zip_reader_ctocpp.cc
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -130,7 +130,7 @@ bool CefZipReaderCToCpp::Eof()
}
#ifdef _DEBUG
#ifndef NDEBUG
template<> long CefCToCpp<CefZipReaderCToCpp, CefZipReader,
cef_zip_reader_t>::DebugObjCt = 0;
#endif

27
libcef_dll/ctocpp/zip_reader_ctocpp.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
@@ -31,18 +31,19 @@ public:
virtual ~CefZipReaderCToCpp() {}
// CefZipReader methods
virtual bool MoveToFirstFile();
virtual bool MoveToNextFile();
virtual bool MoveToFile(const CefString& fileName, bool caseSensitive);
virtual bool Close();
virtual CefString GetFileName();
virtual long GetFileSize();
virtual time_t GetFileLastModified();
virtual bool OpenFile(const CefString& password);
virtual bool CloseFile();
virtual int ReadFile(void* buffer, size_t bufferSize);
virtual long Tell();
virtual bool Eof();
virtual bool MoveToFirstFile() OVERRIDE;
virtual bool MoveToNextFile() OVERRIDE;
virtual bool MoveToFile(const CefString& fileName,
bool caseSensitive) OVERRIDE;
virtual bool Close() OVERRIDE;
virtual CefString GetFileName() OVERRIDE;
virtual long GetFileSize() OVERRIDE;
virtual time_t GetFileLastModified() OVERRIDE;
virtual bool OpenFile(const CefString& password) OVERRIDE;
virtual bool CloseFile() OVERRIDE;
virtual int ReadFile(void* buffer, size_t bufferSize) OVERRIDE;
virtual long Tell() OVERRIDE;
virtual bool Eof() OVERRIDE;
};
#endif // USING_CEF_SHARED