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

- Fix Mac compile errors due to string type changes (issue #146).

Browse Source 
- Fix Windows crash due to string type changes (issue #147).
- Add missing svn:eol-style properties.

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@149 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt
2010-11-23 14:46:01 +00:00
parent 81b7d378f7
commit e826c9b1a0
22 changed files with 1699 additions and 1707 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
libcef_dll/cpptoc/handler_cpptoc.cc
View File

@@ -53,9 +53,10 @@ enum cef_retval_t CEF_CALLBACK handler_handle_before_created(
if(parentBrowser)
browserPtr = CefBrowserCToCpp::Wrap(parentBrowser);
CefString urlStr(url);
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->HandleBeforeCreated(
browserPtr, wndInfo, popup?true:false, features, handlerPtr,
CefString(url), browserSettings);
urlStr, browserSettings);
if(handlerPtr.get() != origHandler) {
// The handler has been changed.
@@ -177,9 +178,10 @@ enum cef_retval_t CEF_CALLBACK handler_handle_load_error(
if(!self || !browser || !errorText || !frame)
return RV_CONTINUE;
CefString errorTextStr(errorText);
return CefHandlerCppToC::Get(self)->HandleLoadError(
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame), errorCode,
CefString(failedUrl), CefString(errorText));
CefString(failedUrl), errorTextStr);
}
enum cef_retval_t CEF_CALLBACK handler_handle_before_resource_load(
@@ -198,10 +200,12 @@ enum cef_retval_t CEF_CALLBACK handler_handle_before_resource_load(
CefRefPtr<CefStreamReader> streamPtr;
CefString redirectUrlStr(redirectUrl);
CefString mimeTypeStr(mimeType);
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->
HandleBeforeResourceLoad(CefBrowserCToCpp::Wrap(browser),
CefRequestCToCpp::Wrap(request), CefString(redirectUrl), streamPtr,
CefString(mimeType), loadFlags);
CefRequestCToCpp::Wrap(request), redirectUrlStr, streamPtr, mimeTypeStr,
loadFlags);
if(streamPtr.get())
*resourceStream = CefStreamReaderCToCpp::Unwrap(streamPtr);
@@ -257,8 +261,9 @@ enum cef_retval_t CEF_CALLBACK handler_handle_get_menu_label(
if(!self || !browser || !label)
return RV_CONTINUE;
CefString labelStr(label);
return CefHandlerCppToC::Get(self)->HandleGetMenuLabel(
CefBrowserCToCpp::Wrap(browser), menuId, CefString(label));
CefBrowserCToCpp::Wrap(browser), menuId, labelStr);
}
enum cef_retval_t CEF_CALLBACK handler_handle_menu_action(
@@ -307,12 +312,17 @@ enum cef_retval_t CEF_CALLBACK handler_handle_print_header_footer(
CefPrintInfo info = *printInfo;
CefString topLeftStr(topLeft);
CefString topCenterStr(topCenter);
CefString topRightStr(topRight);
CefString bottomLeftStr(bottomLeft);
CefString bottomCenterStr(bottomCenter);
CefString bottomRightStr(bottomRight);
return CefHandlerCppToC::Get(self)->
HandlePrintHeaderFooter(CefBrowserCToCpp::Wrap(browser),
CefFrameCToCpp::Wrap(frame), info, CefString(url), CefString(title),
currentPage, maxPages, CefString(topLeft), CefString(topCenter),
CefString(topRight), CefString(bottomLeft), CefString(bottomCenter),
CefString(bottomRight));
currentPage, maxPages, topLeftStr, topCenterStr, topRightStr,
bottomLeftStr, bottomCenterStr, bottomRightStr);
}
enum cef_retval_t CEF_CALLBACK handler_handle_jsalert(
@@ -364,9 +374,10 @@ enum cef_retval_t CEF_CALLBACK handler_handle_jsprompt(
return RV_CONTINUE;
bool ret = false;
CefString resultStr(result);
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->HandleJSPrompt(
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame),
CefString(message), CefString(defaultValue), ret, CefString(result));
CefString(message), CefString(defaultValue), ret, resultStr);
*retval = (ret ? 1 : 0);
return rv;
@@ -448,8 +459,9 @@ enum cef_retval_t CEF_CALLBACK handler_handle_tooltip(
if(!self || !browser || !text)
return RV_CONTINUE;
CefString textStr(text);
return CefHandlerCppToC::Get(self)->HandleTooltip(
CefBrowserCToCpp::Wrap(browser), CefString(text));
CefBrowserCToCpp::Wrap(browser), textStr);
}
enum cef_retval_t CEF_CALLBACK handler_handle_console_message(

3
libcef_dll/cpptoc/scheme_handler_cpptoc.cc
View File

@@ -27,8 +27,9 @@ int CEF_CALLBACK scheme_handler_process_request(
if(!self || !request || !mime_type || !response_length)
return 0;
CefString mimeTypeStr(mime_type);
return CefSchemeHandlerCppToC::Get(self)->ProcessRequest(
CefRequestCToCpp::Wrap(request), CefString(mime_type), response_length);
CefRequestCToCpp::Wrap(request), mimeTypeStr, response_length);
}
void CEF_CALLBACK scheme_handler_cancel(struct _cef_scheme_handler_t* self)

3
libcef_dll/cpptoc/v8handler_cpptoc.cc
View File

@@ -35,8 +35,9 @@ int CEF_CALLBACK v8handler_execute(struct _cef_v8handler_t* self,
}
CefRefPtr<CefV8Value> retValPtr;
CefString exceptionStr(exception);
bool rv = CefV8HandlerCppToC::Get(self)->Execute(CefString(name), objectPtr,
list, retValPtr, CefString(exception));
list, retValPtr, exceptionStr);
if(rv) {
if(retValPtr.get() && retval)
*retval = CefV8ValueCToCpp::Unwrap(retValPtr);

3
libcef_dll/cpptoc/v8value_cpptoc.cc
View File

@@ -385,8 +385,9 @@ int CEF_CALLBACK v8value_execute_function(struct _cef_v8value_t* self,
}
CefRefPtr<CefV8Value> retvalPtr;
CefString exceptionStr(exception);
bool rv = CefV8ValueCppToC::Get(self)->ExecuteFunction(objectPtr,
argsList, retvalPtr, CefString(exception));
argsList, retvalPtr, exceptionStr);
if(retvalPtr.get() && retval)
*retval = CefV8ValueCppToC::Wrap(retvalPtr);

768
libcef_dll/cpptoc/xml_reader_cpptoc.cc
View File

@@ -1,384 +1,384 @@
// 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 function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#include "libcef_dll/cpptoc/stream_reader_cpptoc.h"
#include "libcef_dll/cpptoc/xml_reader_cpptoc.h"
// GLOBAL FUNCTIONS - Body may be edited by hand.
CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create(cef_stream_reader_t* stream,
enum cef_xml_encoding_type_t encodingType, const cef_string_t* URI)
{
CefRefPtr<CefXmlReader> impl = CefXmlReader::Create(
CefStreamReaderCppToC::Unwrap(stream), encodingType, CefString(URI));
if(impl.get())
return CefXmlReaderCppToC::Wrap(impl);
return NULL;
}
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK xml_reader_move_to_next_node(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToNextNode();
}
int CEF_CALLBACK xml_reader_close(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->Close();
}
int CEF_CALLBACK xml_reader_has_error(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->HasError();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_error(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetError();
return retStr.DetachToUserFree();
}
enum cef_xml_node_type_t CEF_CALLBACK xml_reader_get_type(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return XML_NODE_UNSUPPORTED;
return CefXmlReaderCppToC::Get(self)->GetType();
}
int CEF_CALLBACK xml_reader_get_depth(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return -1;
return CefXmlReaderCppToC::Get(self)->GetDepth();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_local_name(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetLocalName();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_prefix(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetPrefix();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_qualified_name(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetQualifiedName();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_namespace_uri(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetNamespaceURI();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_base_uri(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetBaseURI();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_xml_lang(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetXmlLang();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_is_empty_element(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->IsEmptyElement();
}
int CEF_CALLBACK xml_reader_has_value(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->HasValue();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_value(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetValue();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_has_attributes(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->HasAttributes();
}
size_t CEF_CALLBACK xml_reader_get_attribute_count(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->GetAttributeCount();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_byindex(
struct _cef_xml_reader_t* self, int index)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(index);
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_byqname(
struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName)
{
DCHECK(self);
DCHECK(qualifiedName);
if(!self || !qualifiedName)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(
CefString(qualifiedName));
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_bylname(
struct _cef_xml_reader_t* self, const cef_string_t* localName,
const cef_string_t* namespaceURI)
{
DCHECK(self);
DCHECK(localName);
DCHECK(namespaceURI);
if(!self || !localName || !namespaceURI)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(
CefString(localName), CefString(namespaceURI));
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_inner_xml(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetInnerXml();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_outer_xml(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetOuterXml();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_get_line_number(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->GetLineNumber();
}
int CEF_CALLBACK xml_reader_move_to_attribute_byindex(
struct _cef_xml_reader_t* self, int index)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(index);
}
int CEF_CALLBACK xml_reader_move_to_attribute_byqname(
struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName)
{
DCHECK(self);
DCHECK(qualifiedName);
if(!self || !qualifiedName)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(
CefString(qualifiedName));
}
int CEF_CALLBACK xml_reader_move_to_attribute_bylname(
struct _cef_xml_reader_t* self, const cef_string_t* localName,
const cef_string_t* namespaceURI)
{
DCHECK(self);
DCHECK(localName);
DCHECK(namespaceURI);
if(!self || !localName || !namespaceURI)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(CefString(localName),
CefString(namespaceURI));
}
int CEF_CALLBACK xml_reader_move_to_first_attribute(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToFirstAttribute();
}
int CEF_CALLBACK xml_reader_move_to_next_attribute(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToNextAttribute();
}
int CEF_CALLBACK xml_reader_move_to_carrying_element(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToCarryingElement();
}
// CONSTRUCTOR - Do not edit by hand.
CefXmlReaderCppToC::CefXmlReaderCppToC(CefXmlReader* cls)
: CefCppToC<CefXmlReaderCppToC, CefXmlReader, cef_xml_reader_t>(cls)
{
struct_.struct_.move_to_next_node = xml_reader_move_to_next_node;
struct_.struct_.close = xml_reader_close;
struct_.struct_.has_error = xml_reader_has_error;
struct_.struct_.get_error = xml_reader_get_error;
struct_.struct_.get_type = xml_reader_get_type;
struct_.struct_.get_depth = xml_reader_get_depth;
struct_.struct_.get_local_name = xml_reader_get_local_name;
struct_.struct_.get_prefix = xml_reader_get_prefix;
struct_.struct_.get_qualified_name = xml_reader_get_qualified_name;
struct_.struct_.get_namespace_uri = xml_reader_get_namespace_uri;
struct_.struct_.get_base_uri = xml_reader_get_base_uri;
struct_.struct_.get_xml_lang = xml_reader_get_xml_lang;
struct_.struct_.is_empty_element = xml_reader_is_empty_element;
struct_.struct_.has_value = xml_reader_has_value;
struct_.struct_.get_value = xml_reader_get_value;
struct_.struct_.has_attributes = xml_reader_has_attributes;
struct_.struct_.get_attribute_count = xml_reader_get_attribute_count;
struct_.struct_.get_attribute_byindex = xml_reader_get_attribute_byindex;
struct_.struct_.get_attribute_byqname = xml_reader_get_attribute_byqname;
struct_.struct_.get_attribute_bylname = xml_reader_get_attribute_bylname;
struct_.struct_.get_inner_xml = xml_reader_get_inner_xml;
struct_.struct_.get_outer_xml = xml_reader_get_outer_xml;
struct_.struct_.get_line_number = xml_reader_get_line_number;
struct_.struct_.move_to_attribute_byindex =
xml_reader_move_to_attribute_byindex;
struct_.struct_.move_to_attribute_byqname =
xml_reader_move_to_attribute_byqname;
struct_.struct_.move_to_attribute_bylname =
xml_reader_move_to_attribute_bylname;
struct_.struct_.move_to_first_attribute = xml_reader_move_to_first_attribute;
struct_.struct_.move_to_next_attribute = xml_reader_move_to_next_attribute;
struct_.struct_.move_to_carrying_element =
xml_reader_move_to_carrying_element;
}
#ifdef _DEBUG
long CefCppToC<CefXmlReaderCppToC, CefXmlReader, cef_xml_reader_t>::DebugObjCt =
0;
#endif
// 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 function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#include "libcef_dll/cpptoc/stream_reader_cpptoc.h"
#include "libcef_dll/cpptoc/xml_reader_cpptoc.h"
// GLOBAL FUNCTIONS - Body may be edited by hand.
CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create(cef_stream_reader_t* stream,
enum cef_xml_encoding_type_t encodingType, const cef_string_t* URI)
{
CefRefPtr<CefXmlReader> impl = CefXmlReader::Create(
CefStreamReaderCppToC::Unwrap(stream), encodingType, CefString(URI));
if(impl.get())
return CefXmlReaderCppToC::Wrap(impl);
return NULL;
}
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK xml_reader_move_to_next_node(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToNextNode();
}
int CEF_CALLBACK xml_reader_close(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->Close();
}
int CEF_CALLBACK xml_reader_has_error(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->HasError();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_error(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetError();
return retStr.DetachToUserFree();
}
enum cef_xml_node_type_t CEF_CALLBACK xml_reader_get_type(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return XML_NODE_UNSUPPORTED;
return CefXmlReaderCppToC::Get(self)->GetType();
}
int CEF_CALLBACK xml_reader_get_depth(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return -1;
return CefXmlReaderCppToC::Get(self)->GetDepth();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_local_name(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetLocalName();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_prefix(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetPrefix();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_qualified_name(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetQualifiedName();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_namespace_uri(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetNamespaceURI();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_base_uri(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetBaseURI();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_xml_lang(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetXmlLang();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_is_empty_element(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->IsEmptyElement();
}
int CEF_CALLBACK xml_reader_has_value(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->HasValue();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_value(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetValue();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_has_attributes(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->HasAttributes();
}
size_t CEF_CALLBACK xml_reader_get_attribute_count(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->GetAttributeCount();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_byindex(
struct _cef_xml_reader_t* self, int index)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(index);
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_byqname(
struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName)
{
DCHECK(self);
DCHECK(qualifiedName);
if(!self || !qualifiedName)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(
CefString(qualifiedName));
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_bylname(
struct _cef_xml_reader_t* self, const cef_string_t* localName,
const cef_string_t* namespaceURI)
{
DCHECK(self);
DCHECK(localName);
DCHECK(namespaceURI);
if(!self || !localName || !namespaceURI)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(
CefString(localName), CefString(namespaceURI));
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_inner_xml(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetInnerXml();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_outer_xml(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetOuterXml();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_get_line_number(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->GetLineNumber();
}
int CEF_CALLBACK xml_reader_move_to_attribute_byindex(
struct _cef_xml_reader_t* self, int index)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(index);
}
int CEF_CALLBACK xml_reader_move_to_attribute_byqname(
struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName)
{
DCHECK(self);
DCHECK(qualifiedName);
if(!self || !qualifiedName)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(
CefString(qualifiedName));
}
int CEF_CALLBACK xml_reader_move_to_attribute_bylname(
struct _cef_xml_reader_t* self, const cef_string_t* localName,
const cef_string_t* namespaceURI)
{
DCHECK(self);
DCHECK(localName);
DCHECK(namespaceURI);
if(!self || !localName || !namespaceURI)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(CefString(localName),
CefString(namespaceURI));
}
int CEF_CALLBACK xml_reader_move_to_first_attribute(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToFirstAttribute();
}
int CEF_CALLBACK xml_reader_move_to_next_attribute(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToNextAttribute();
}
int CEF_CALLBACK xml_reader_move_to_carrying_element(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToCarryingElement();
}
// CONSTRUCTOR - Do not edit by hand.
CefXmlReaderCppToC::CefXmlReaderCppToC(CefXmlReader* cls)
: CefCppToC<CefXmlReaderCppToC, CefXmlReader, cef_xml_reader_t>(cls)
{
struct_.struct_.move_to_next_node = xml_reader_move_to_next_node;
struct_.struct_.close = xml_reader_close;
struct_.struct_.has_error = xml_reader_has_error;
struct_.struct_.get_error = xml_reader_get_error;
struct_.struct_.get_type = xml_reader_get_type;
struct_.struct_.get_depth = xml_reader_get_depth;
struct_.struct_.get_local_name = xml_reader_get_local_name;
struct_.struct_.get_prefix = xml_reader_get_prefix;
struct_.struct_.get_qualified_name = xml_reader_get_qualified_name;
struct_.struct_.get_namespace_uri = xml_reader_get_namespace_uri;
struct_.struct_.get_base_uri = xml_reader_get_base_uri;
struct_.struct_.get_xml_lang = xml_reader_get_xml_lang;
struct_.struct_.is_empty_element = xml_reader_is_empty_element;
struct_.struct_.has_value = xml_reader_has_value;
struct_.struct_.get_value = xml_reader_get_value;
struct_.struct_.has_attributes = xml_reader_has_attributes;
struct_.struct_.get_attribute_count = xml_reader_get_attribute_count;
struct_.struct_.get_attribute_byindex = xml_reader_get_attribute_byindex;
struct_.struct_.get_attribute_byqname = xml_reader_get_attribute_byqname;
struct_.struct_.get_attribute_bylname = xml_reader_get_attribute_bylname;
struct_.struct_.get_inner_xml = xml_reader_get_inner_xml;
struct_.struct_.get_outer_xml = xml_reader_get_outer_xml;
struct_.struct_.get_line_number = xml_reader_get_line_number;
struct_.struct_.move_to_attribute_byindex =
xml_reader_move_to_attribute_byindex;
struct_.struct_.move_to_attribute_byqname =
xml_reader_move_to_attribute_byqname;
struct_.struct_.move_to_attribute_bylname =
xml_reader_move_to_attribute_bylname;
struct_.struct_.move_to_first_attribute = xml_reader_move_to_first_attribute;
struct_.struct_.move_to_next_attribute = xml_reader_move_to_next_attribute;
struct_.struct_.move_to_carrying_element =
xml_reader_move_to_carrying_element;
}
#ifdef _DEBUG
long CefCppToC<CefXmlReaderCppToC, CefXmlReader, cef_xml_reader_t>::DebugObjCt =
0;
#endif

68
libcef_dll/cpptoc/xml_reader_cpptoc.h
View File

@@ -1,34 +1,34 @@
// 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 _XMLREADER_CPPTOC_H
#define _XMLREADER_CPPTOC_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/cpptoc/cpptoc.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefXmlReaderCppToC
: public CefCppToC<CefXmlReaderCppToC, CefXmlReader, cef_xml_reader_t>
{
public:
CefXmlReaderCppToC(CefXmlReader* cls);
virtual ~CefXmlReaderCppToC() {}
};
#endif // BUILDING_CEF_SHARED
#endif // _XMLREADER_CPPTOC_H
// 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 _XMLREADER_CPPTOC_H
#define _XMLREADER_CPPTOC_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/cpptoc/cpptoc.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefXmlReaderCppToC
: public CefCppToC<CefXmlReaderCppToC, CefXmlReader, cef_xml_reader_t>
{
public:
CefXmlReaderCppToC(CefXmlReader* cls);
virtual ~CefXmlReaderCppToC() {}
};
#endif // BUILDING_CEF_SHARED
#endif // _XMLREADER_CPPTOC_H

628
libcef_dll/ctocpp/xml_reader_ctocpp.cc
View File

@@ -1,314 +1,314 @@
// 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/ctocpp/stream_reader_ctocpp.h"
#include "libcef_dll/ctocpp/xml_reader_ctocpp.h"
// STATIC METHODS - Body may be edited by hand.
CefRefPtr<CefXmlReader> CefXmlReader::Create(CefRefPtr<CefStreamReader> stream,
EncodingType encodingType, const CefString& URI)
{
cef_xml_reader_t* impl = cef_xml_reader_create(
CefStreamReaderCToCpp::Unwrap(stream), encodingType, URI.GetStruct());
if(impl)
return CefXmlReaderCToCpp::Wrap(impl);
return NULL;
}
// VIRTUAL METHODS - Body may be edited by hand.
bool CefXmlReaderCToCpp::MoveToNextNode()
{
if(CEF_MEMBER_MISSING(struct_, move_to_next_node))
return false;
return struct_->move_to_next_node(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::Close()
{
if(CEF_MEMBER_MISSING(struct_, close))
return false;
return struct_->close(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::HasError()
{
if(CEF_MEMBER_MISSING(struct_, has_error))
return false;
return struct_->has_error(struct_) ? true : false;
}
CefString CefXmlReaderCToCpp::GetError()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_error))
return str;
cef_string_userfree_t strPtr = struct_->get_error(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefXmlReader::NodeType CefXmlReaderCToCpp::GetType()
{
if(CEF_MEMBER_MISSING(struct_, get_type))
return XML_NODE_UNSUPPORTED;
return struct_->get_type(struct_);
}
int CefXmlReaderCToCpp::GetDepth()
{
if(CEF_MEMBER_MISSING(struct_, get_depth))
return -1;
return struct_->get_depth(struct_);
}
CefString CefXmlReaderCToCpp::GetLocalName()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_local_name))
return str;
cef_string_userfree_t strPtr = struct_->get_local_name(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetPrefix()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_prefix))
return str;
cef_string_userfree_t strPtr = struct_->get_prefix(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetQualifiedName()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_qualified_name))
return str;
cef_string_userfree_t strPtr = struct_->get_qualified_name(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetNamespaceURI()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_namespace_uri))
return str;
cef_string_userfree_t strPtr = struct_->get_namespace_uri(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetBaseURI()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_base_uri))
return str;
cef_string_userfree_t strPtr = struct_->get_base_uri(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetXmlLang()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_xml_lang))
return str;
cef_string_userfree_t strPtr = struct_->get_xml_lang(struct_);
str.AttachToUserFree(strPtr);
return str;
}
bool CefXmlReaderCToCpp::IsEmptyElement()
{
if(CEF_MEMBER_MISSING(struct_, is_empty_element))
return false;
return struct_->is_empty_element(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::HasValue()
{
if(CEF_MEMBER_MISSING(struct_, has_value))
return false;
return struct_->has_value(struct_) ? true : false;
}
CefString CefXmlReaderCToCpp::GetValue()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_value))
return str;
cef_string_userfree_t strPtr = struct_->get_value(struct_);
str.AttachToUserFree(strPtr);
return str;
}
bool CefXmlReaderCToCpp::HasAttributes()
{
if(CEF_MEMBER_MISSING(struct_, has_attributes))
return false;
return struct_->has_attributes(struct_) ? true : false;
}
size_t CefXmlReaderCToCpp::GetAttributeCount()
{
if(CEF_MEMBER_MISSING(struct_, get_attribute_count))
return 0;
return struct_->get_attribute_count(struct_);
}
CefString CefXmlReaderCToCpp::GetAttribute(int index)
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_attribute_byindex))
return str;
cef_string_userfree_t strPtr = struct_->get_attribute_byindex(struct_, index);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetAttribute(const CefString& qualifiedName)
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_attribute_byqname))
return str;
cef_string_userfree_t strPtr = struct_->get_attribute_byqname(struct_,
qualifiedName.GetStruct());
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetAttribute(const CefString& localName,
const CefString& namespaceURI)
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_attribute_bylname))
return str;
cef_string_userfree_t strPtr = struct_->get_attribute_bylname(struct_,
localName.GetStruct(), namespaceURI.GetStruct());
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetInnerXml()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_inner_xml))
return str;
cef_string_userfree_t strPtr = struct_->get_inner_xml(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetOuterXml()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_outer_xml))
return str;
cef_string_userfree_t strPtr = struct_->get_outer_xml(struct_);
str.AttachToUserFree(strPtr);
return str;
}
int CefXmlReaderCToCpp::GetLineNumber()
{
if(CEF_MEMBER_MISSING(struct_, get_line_number))
return false;
return struct_->get_line_number(struct_);
}
bool CefXmlReaderCToCpp::MoveToAttribute(int index)
{
if(CEF_MEMBER_MISSING(struct_, move_to_attribute_byindex))
return false;
return struct_->move_to_attribute_byindex(struct_, index) ? true : false;
}
bool CefXmlReaderCToCpp::MoveToAttribute(const CefString& qualifiedName)
{
if(CEF_MEMBER_MISSING(struct_, move_to_attribute_byqname))
return false;
return struct_->move_to_attribute_byqname(struct_, qualifiedName.GetStruct())?
true : false;
}
bool CefXmlReaderCToCpp::MoveToAttribute(const CefString& localName,
const CefString& namespaceURI)
{
if(CEF_MEMBER_MISSING(struct_, move_to_attribute_bylname))
return false;
return struct_->move_to_attribute_bylname(struct_, localName.GetStruct(),
namespaceURI.GetStruct()) ? true : false;
}
bool CefXmlReaderCToCpp::MoveToFirstAttribute()
{
if(CEF_MEMBER_MISSING(struct_, move_to_first_attribute))
return false;
return struct_->move_to_first_attribute(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::MoveToNextAttribute()
{
if(CEF_MEMBER_MISSING(struct_, move_to_next_attribute))
return false;
return struct_->move_to_next_attribute(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::MoveToCarryingElement()
{
if(CEF_MEMBER_MISSING(struct_, move_to_carrying_element))
return false;
return struct_->move_to_carrying_element(struct_) ? true : false;
}
#ifdef _DEBUG
long CefCToCpp<CefXmlReaderCToCpp, CefXmlReader, cef_xml_reader_t>::DebugObjCt =
0;
#endif
// 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/ctocpp/stream_reader_ctocpp.h"
#include "libcef_dll/ctocpp/xml_reader_ctocpp.h"
// STATIC METHODS - Body may be edited by hand.
CefRefPtr<CefXmlReader> CefXmlReader::Create(CefRefPtr<CefStreamReader> stream,
EncodingType encodingType, const CefString& URI)
{
cef_xml_reader_t* impl = cef_xml_reader_create(
CefStreamReaderCToCpp::Unwrap(stream), encodingType, URI.GetStruct());
if(impl)
return CefXmlReaderCToCpp::Wrap(impl);
return NULL;
}
// VIRTUAL METHODS - Body may be edited by hand.
bool CefXmlReaderCToCpp::MoveToNextNode()
{
if(CEF_MEMBER_MISSING(struct_, move_to_next_node))
return false;
return struct_->move_to_next_node(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::Close()
{
if(CEF_MEMBER_MISSING(struct_, close))
return false;
return struct_->close(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::HasError()
{
if(CEF_MEMBER_MISSING(struct_, has_error))
return false;
return struct_->has_error(struct_) ? true : false;
}
CefString CefXmlReaderCToCpp::GetError()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_error))
return str;
cef_string_userfree_t strPtr = struct_->get_error(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefXmlReader::NodeType CefXmlReaderCToCpp::GetType()
{
if(CEF_MEMBER_MISSING(struct_, get_type))
return XML_NODE_UNSUPPORTED;
return struct_->get_type(struct_);
}
int CefXmlReaderCToCpp::GetDepth()
{
if(CEF_MEMBER_MISSING(struct_, get_depth))
return -1;
return struct_->get_depth(struct_);
}
CefString CefXmlReaderCToCpp::GetLocalName()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_local_name))
return str;
cef_string_userfree_t strPtr = struct_->get_local_name(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetPrefix()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_prefix))
return str;
cef_string_userfree_t strPtr = struct_->get_prefix(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetQualifiedName()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_qualified_name))
return str;
cef_string_userfree_t strPtr = struct_->get_qualified_name(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetNamespaceURI()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_namespace_uri))
return str;
cef_string_userfree_t strPtr = struct_->get_namespace_uri(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetBaseURI()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_base_uri))
return str;
cef_string_userfree_t strPtr = struct_->get_base_uri(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetXmlLang()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_xml_lang))
return str;
cef_string_userfree_t strPtr = struct_->get_xml_lang(struct_);
str.AttachToUserFree(strPtr);
return str;
}
bool CefXmlReaderCToCpp::IsEmptyElement()
{
if(CEF_MEMBER_MISSING(struct_, is_empty_element))
return false;
return struct_->is_empty_element(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::HasValue()
{
if(CEF_MEMBER_MISSING(struct_, has_value))
return false;
return struct_->has_value(struct_) ? true : false;
}
CefString CefXmlReaderCToCpp::GetValue()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_value))
return str;
cef_string_userfree_t strPtr = struct_->get_value(struct_);
str.AttachToUserFree(strPtr);
return str;
}
bool CefXmlReaderCToCpp::HasAttributes()
{
if(CEF_MEMBER_MISSING(struct_, has_attributes))
return false;
return struct_->has_attributes(struct_) ? true : false;
}
size_t CefXmlReaderCToCpp::GetAttributeCount()
{
if(CEF_MEMBER_MISSING(struct_, get_attribute_count))
return 0;
return struct_->get_attribute_count(struct_);
}
CefString CefXmlReaderCToCpp::GetAttribute(int index)
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_attribute_byindex))
return str;
cef_string_userfree_t strPtr = struct_->get_attribute_byindex(struct_, index);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetAttribute(const CefString& qualifiedName)
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_attribute_byqname))
return str;
cef_string_userfree_t strPtr = struct_->get_attribute_byqname(struct_,
qualifiedName.GetStruct());
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetAttribute(const CefString& localName,
const CefString& namespaceURI)
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_attribute_bylname))
return str;
cef_string_userfree_t strPtr = struct_->get_attribute_bylname(struct_,
localName.GetStruct(), namespaceURI.GetStruct());
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetInnerXml()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_inner_xml))
return str;
cef_string_userfree_t strPtr = struct_->get_inner_xml(struct_);
str.AttachToUserFree(strPtr);
return str;
}
CefString CefXmlReaderCToCpp::GetOuterXml()
{
CefString str;
if(CEF_MEMBER_MISSING(struct_, get_outer_xml))
return str;
cef_string_userfree_t strPtr = struct_->get_outer_xml(struct_);
str.AttachToUserFree(strPtr);
return str;
}
int CefXmlReaderCToCpp::GetLineNumber()
{
if(CEF_MEMBER_MISSING(struct_, get_line_number))
return false;
return struct_->get_line_number(struct_);
}
bool CefXmlReaderCToCpp::MoveToAttribute(int index)
{
if(CEF_MEMBER_MISSING(struct_, move_to_attribute_byindex))
return false;
return struct_->move_to_attribute_byindex(struct_, index) ? true : false;
}
bool CefXmlReaderCToCpp::MoveToAttribute(const CefString& qualifiedName)
{
if(CEF_MEMBER_MISSING(struct_, move_to_attribute_byqname))
return false;
return struct_->move_to_attribute_byqname(struct_, qualifiedName.GetStruct())?
true : false;
}
bool CefXmlReaderCToCpp::MoveToAttribute(const CefString& localName,
const CefString& namespaceURI)
{
if(CEF_MEMBER_MISSING(struct_, move_to_attribute_bylname))
return false;
return struct_->move_to_attribute_bylname(struct_, localName.GetStruct(),
namespaceURI.GetStruct()) ? true : false;
}
bool CefXmlReaderCToCpp::MoveToFirstAttribute()
{
if(CEF_MEMBER_MISSING(struct_, move_to_first_attribute))
return false;
return struct_->move_to_first_attribute(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::MoveToNextAttribute()
{
if(CEF_MEMBER_MISSING(struct_, move_to_next_attribute))
return false;
return struct_->move_to_next_attribute(struct_) ? true : false;
}
bool CefXmlReaderCToCpp::MoveToCarryingElement()
{
if(CEF_MEMBER_MISSING(struct_, move_to_carrying_element))
return false;
return struct_->move_to_carrying_element(struct_) ? true : false;
}
#ifdef _DEBUG
long CefCToCpp<CefXmlReaderCToCpp, CefXmlReader, cef_xml_reader_t>::DebugObjCt =
0;
#endif

138
libcef_dll/ctocpp/xml_reader_ctocpp.h
View File

@@ -1,69 +1,69 @@
// 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 _XMLREADER_CTOCPP_H
#define _XMLREADER_CTOCPP_H
#ifndef USING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
#else // USING_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 wrapper-side only.
class CefXmlReaderCToCpp
: public CefCToCpp<CefXmlReaderCToCpp, CefXmlReader, cef_xml_reader_t>
{
public:
CefXmlReaderCToCpp(cef_xml_reader_t* str)
: CefCToCpp<CefXmlReaderCToCpp, CefXmlReader, cef_xml_reader_t>(str) {}
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 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);
virtual bool MoveToAttribute(const CefString& localName,
const CefString& namespaceURI);
virtual bool MoveToFirstAttribute();
virtual bool MoveToNextAttribute();
virtual bool MoveToCarryingElement();
};
#endif // USING_CEF_SHARED
#endif // _XMLREADER_CTOCPP_H
// 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 _XMLREADER_CTOCPP_H
#define _XMLREADER_CTOCPP_H
#ifndef USING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
#else // USING_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 wrapper-side only.
class CefXmlReaderCToCpp
: public CefCToCpp<CefXmlReaderCToCpp, CefXmlReader, cef_xml_reader_t>
{
public:
CefXmlReaderCToCpp(cef_xml_reader_t* str)
: CefCToCpp<CefXmlReaderCToCpp, CefXmlReader, cef_xml_reader_t>(str) {}
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 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);
virtual bool MoveToAttribute(const CefString& localName,
const CefString& namespaceURI);
virtual bool MoveToFirstAttribute();
virtual bool MoveToNextAttribute();
virtual bool MoveToCarryingElement();
};
#endif // USING_CEF_SHARED
#endif // _XMLREADER_CTOCPP_H