diff options
Diffstat (limited to 'include/capi')
105 files changed, 19924 insertions, 0 deletions
diff --git a/include/capi/cef_accessibility_handler_capi.h b/include/capi/cef_accessibility_handler_capi.h new file mode 100644 index 00000000..120714ac --- /dev/null +++ b/include/capi/cef_accessibility_handler_capi.h @@ -0,0 +1,81 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=0ac3c8ca887778a840c65108d56038d4d776e073$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to receive accessibility notification when +/// accessibility events have been registered. The functions of this structure +/// will be called on the UI thread. +/// +typedef struct _cef_accessibility_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called after renderer process sends accessibility tree changes to the + /// browser process. + /// + void(CEF_CALLBACK* on_accessibility_tree_change)( + struct _cef_accessibility_handler_t* self, + struct _cef_value_t* value); + + /// + /// Called after renderer process sends accessibility location changes to the + /// browser process. + /// + void(CEF_CALLBACK* on_accessibility_location_change)( + struct _cef_accessibility_handler_t* self, + struct _cef_value_t* value); +} cef_accessibility_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_ diff --git a/include/capi/cef_app_capi.h b/include/capi/cef_app_capi.h new file mode 100644 index 00000000..f1b58c56 --- /dev/null +++ b/include/capi/cef_app_capi.h @@ -0,0 +1,190 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=9b523fbf312a8a0cb1c743a3c8aca7bc9cc22bbc$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_process_handler_capi.h" +#include "include/capi/cef_command_line_capi.h" +#include "include/capi/cef_render_process_handler_capi.h" +#include "include/capi/cef_resource_bundle_handler_capi.h" +#include "include/capi/cef_scheme_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_app_t; + +/// +/// Implement this structure to provide handler implementations. Methods will be +/// called by the process and/or thread indicated. +/// +typedef struct _cef_app_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Provides an opportunity to view and/or modify command-line arguments + /// before processing by CEF and Chromium. The |process_type| value will be + /// NULL for the browser process. Do not keep a reference to the + /// cef_command_line_t object passed to this function. The + /// cef_settings_t.command_line_args_disabled value can be used to start with + /// an NULL command-line object. Any values specified in CefSettings that + /// equate to command-line arguments will be set before this function is + /// called. Be cautious when using this function to modify command-line + /// arguments for non-browser processes as this may result in undefined + /// behavior including crashes. + /// + void(CEF_CALLBACK* on_before_command_line_processing)( + struct _cef_app_t* self, + const cef_string_t* process_type, + struct _cef_command_line_t* command_line); + + /// + /// Provides an opportunity to register custom schemes. Do not keep a + /// reference to the |registrar| object. This function is called on the main + /// thread for each process and the registered schemes should be the same + /// across all processes. + /// + void(CEF_CALLBACK* on_register_custom_schemes)( + struct _cef_app_t* self, + struct _cef_scheme_registrar_t* registrar); + + /// + /// Return the handler for resource bundle events. If + /// cef_settings_t.pack_loading_disabled is true (1) a handler must be + /// returned. If no handler is returned resources will be loaded from pack + /// files. This function is called by the browser and render processes on + /// multiple threads. + /// + struct _cef_resource_bundle_handler_t*( + CEF_CALLBACK* get_resource_bundle_handler)(struct _cef_app_t* self); + + /// + /// Return the handler for functionality specific to the browser process. This + /// function is called on multiple threads in the browser process. + /// + struct _cef_browser_process_handler_t*( + CEF_CALLBACK* get_browser_process_handler)(struct _cef_app_t* self); + + /// + /// Return the handler for functionality specific to the render process. This + /// function is called on the render process main thread. + /// + struct _cef_render_process_handler_t*( + CEF_CALLBACK* get_render_process_handler)(struct _cef_app_t* self); +} cef_app_t; + +/// +/// This function should be called from the application entry point function to +/// execute a secondary process. It can be used to run secondary processes from +/// the browser client executable (default behavior) or from a separate +/// executable specified by the cef_settings_t.browser_subprocess_path value. If +/// called for the browser process (identified by no "type" command-line value) +/// it will return immediately with a value of -1. If called for a recognized +/// secondary process it will block until the process should exit and then +/// return the process exit code. The |application| parameter may be NULL. The +/// |windows_sandbox_info| parameter is only used on Windows and may be NULL +/// (see cef_sandbox_win.h for details). +/// +CEF_EXPORT int cef_execute_process(const cef_main_args_t* args, + cef_app_t* application, + void* windows_sandbox_info); + +/// +/// This function should be called on the main application thread to initialize +/// the CEF browser process. The |application| parameter may be NULL. A return +/// value of true (1) indicates that it succeeded and false (0) indicates that +/// it failed. The |windows_sandbox_info| parameter is only used on Windows and +/// may be NULL (see cef_sandbox_win.h for details). +/// +CEF_EXPORT int cef_initialize(const cef_main_args_t* args, + const struct _cef_settings_t* settings, + cef_app_t* application, + void* windows_sandbox_info); + +/// +/// This function should be called on the main application thread to shut down +/// the CEF browser process before the application exits. +/// +CEF_EXPORT void cef_shutdown(void); + +/// +/// Perform a single iteration of CEF message loop processing. This function is +/// provided for cases where the CEF message loop must be integrated into an +/// existing application message loop. Use of this function is not recommended +/// for most users; use either the cef_run_message_loop() function or +/// cef_settings_t.multi_threaded_message_loop if possible. When using this +/// function care must be taken to balance performance against excessive CPU +/// usage. It is recommended to enable the cef_settings_t.external_message_pump +/// option when using this function so that +/// cef_browser_process_handler_t::on_schedule_message_pump_work() callbacks can +/// facilitate the scheduling process. This function should only be called on +/// the main application thread and only if cef_initialize() is called with a +/// cef_settings_t.multi_threaded_message_loop value of false (0). This function +/// will not block. +/// +CEF_EXPORT void cef_do_message_loop_work(void); + +/// +/// Run the CEF message loop. Use this function instead of an application- +/// provided message loop to get the best balance between performance and CPU +/// usage. This function should only be called on the main application thread +/// and only if cef_initialize() is called with a +/// cef_settings_t.multi_threaded_message_loop value of false (0). This function +/// will block until a quit message is received by the system. +/// +CEF_EXPORT void cef_run_message_loop(void); + +/// +/// Quit the CEF message loop that was started by calling +/// cef_run_message_loop(). This function should only be called on the main +/// application thread and only if cef_run_message_loop() was used. +/// +CEF_EXPORT void cef_quit_message_loop(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_ diff --git a/include/capi/cef_audio_handler_capi.h b/include/capi/cef_audio_handler_capi.h new file mode 100644 index 00000000..78af95dd --- /dev/null +++ b/include/capi/cef_audio_handler_capi.h @@ -0,0 +1,121 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=936274d5539f225ff7adb7e0acba517fd9a8e2f8$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle audio events. +/// +typedef struct _cef_audio_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called on the UI thread to allow configuration of audio stream parameters. + /// Return true (1) to proceed with audio stream capture, or false (0) to + /// cancel it. All members of |params| can optionally be configured here, but + /// they are also pre-filled with some sensible defaults. + /// + int(CEF_CALLBACK* get_audio_parameters)(struct _cef_audio_handler_t* self, + struct _cef_browser_t* browser, + cef_audio_parameters_t* params); + + /// + /// Called on a browser audio capture thread when the browser starts streaming + /// audio. OnAudioStreamStopped will always be called after + /// OnAudioStreamStarted; both functions may be called multiple times for the + /// same browser. |params| contains the audio parameters like sample rate and + /// channel layout. |channels| is the number of channels. + /// + void(CEF_CALLBACK* on_audio_stream_started)( + struct _cef_audio_handler_t* self, + struct _cef_browser_t* browser, + const cef_audio_parameters_t* params, + int channels); + + /// + /// Called on the audio stream thread when a PCM packet is received for the + /// stream. |data| is an array representing the raw PCM data as a floating + /// point type, i.e. 4-byte value(s). |frames| is the number of frames in the + /// PCM packet. |pts| is the presentation timestamp (in milliseconds since the + /// Unix Epoch) and represents the time at which the decompressed packet + /// should be presented to the user. Based on |frames| and the + /// |channel_layout| value passed to OnAudioStreamStarted you can calculate + /// the size of the |data| array in bytes. + /// + void(CEF_CALLBACK* on_audio_stream_packet)(struct _cef_audio_handler_t* self, + struct _cef_browser_t* browser, + const float** data, + int frames, + int64 pts); + + /// + /// Called on the UI thread when the stream has stopped. OnAudioSteamStopped + /// will always be called after OnAudioStreamStarted; both functions may be + /// called multiple times for the same stream. + /// + void(CEF_CALLBACK* on_audio_stream_stopped)(struct _cef_audio_handler_t* self, + struct _cef_browser_t* browser); + + /// + /// Called on the UI or audio stream thread when an error occurred. During the + /// stream creation phase this callback will be called on the UI thread while + /// in the capturing phase it will be called on the audio stream thread. The + /// stream will be stopped immediately. + /// + void(CEF_CALLBACK* on_audio_stream_error)(struct _cef_audio_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* message); +} cef_audio_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_ diff --git a/include/capi/cef_auth_callback_capi.h b/include/capi/cef_auth_callback_capi.h new file mode 100644 index 00000000..6e74c0a4 --- /dev/null +++ b/include/capi/cef_auth_callback_capi.h @@ -0,0 +1,76 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=4b9c31ef9a23f899c6d8cd3da49934a41f1bd231$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Callback structure used for asynchronous continuation of authentication +/// requests. +/// +typedef struct _cef_auth_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Continue the authentication request. + /// + void(CEF_CALLBACK* cont)(struct _cef_auth_callback_t* self, + const cef_string_t* username, + const cef_string_t* password); + + /// + /// Cancel the authentication request. + /// + void(CEF_CALLBACK* cancel)(struct _cef_auth_callback_t* self); +} cef_auth_callback_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_ diff --git a/include/capi/cef_base_capi.h b/include/capi/cef_base_capi.h new file mode 100644 index 00000000..dbd0b9f3 --- /dev/null +++ b/include/capi/cef_base_capi.h @@ -0,0 +1,107 @@ +// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_ + +#include <stdint.h> + +#include "include/internal/cef_export.h" +#include "include/internal/cef_string.h" +#include "include/internal/cef_string_list.h" +#include "include/internal/cef_string_map.h" +#include "include/internal/cef_string_multimap.h" +#include "include/internal/cef_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +// All ref-counted framework structures must include this structure first. +/// +typedef struct _cef_base_ref_counted_t { + /// + // Size of the data structure. + /// + size_t size; + + /// + // Called to increment the reference count for the object. Should be called + // for every new copy of a pointer to a given object. + /// + void(CEF_CALLBACK* add_ref)(struct _cef_base_ref_counted_t* self); + + /// + // Called to decrement the reference count for the object. If the reference + // count falls to 0 the object should self-delete. Returns true (1) if the + // resulting reference count is 0. + /// + int(CEF_CALLBACK* release)(struct _cef_base_ref_counted_t* self); + + /// + // Returns true (1) if the current reference count is 1. + /// + int(CEF_CALLBACK* has_one_ref)(struct _cef_base_ref_counted_t* self); + + /// + // Returns true (1) if the current reference count is at least 1. + /// + int(CEF_CALLBACK* has_at_least_one_ref)(struct _cef_base_ref_counted_t* self); +} cef_base_ref_counted_t; + +/// +// All scoped framework structures must include this structure first. +/// +typedef struct _cef_base_scoped_t { + /// + // Size of the data structure. + /// + size_t size; + + /// + // Called to delete this object. May be NULL if the object is not owned. + /// + void(CEF_CALLBACK* del)(struct _cef_base_scoped_t* self); + +} cef_base_scoped_t; + +// Check that the structure |s|, which is defined with a size_t member at the +// top, is large enough to contain the specified member |f|. +#define CEF_MEMBER_EXISTS(s, f) \ + ((intptr_t) & \ + ((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= *reinterpret_cast<size_t*>(s)) + +#define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f)) + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_ diff --git a/include/capi/cef_browser_capi.h b/include/capi/cef_browser_capi.h new file mode 100644 index 00000000..244a20cd --- /dev/null +++ b/include/capi/cef_browser_capi.h @@ -0,0 +1,952 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=7254c050cd7db2ff7d40a1f54c99e941dc592692$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_devtools_message_observer_capi.h" +#include "include/capi/cef_drag_data_capi.h" +#include "include/capi/cef_frame_capi.h" +#include "include/capi/cef_image_capi.h" +#include "include/capi/cef_navigation_entry_capi.h" +#include "include/capi/cef_registration_capi.h" +#include "include/capi/cef_request_context_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_browser_host_t; +struct _cef_client_t; + +/// +/// Structure used to represent a browser. When used in the browser process the +/// functions of this structure may be called on any thread unless otherwise +/// indicated in the comments. When used in the render process the functions of +/// this structure may only be called on the main thread. +/// +typedef struct _cef_browser_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// True if this object is currently valid. This will return false (0) after + /// cef_life_span_handler_t::OnBeforeClose is called. + /// + int(CEF_CALLBACK* is_valid)(struct _cef_browser_t* self); + + /// + /// Returns the browser host object. This function can only be called in the + /// browser process. + /// + struct _cef_browser_host_t*(CEF_CALLBACK* get_host)( + struct _cef_browser_t* self); + + /// + /// Returns true (1) if the browser can navigate backwards. + /// + int(CEF_CALLBACK* can_go_back)(struct _cef_browser_t* self); + + /// + /// Navigate backwards. + /// + void(CEF_CALLBACK* go_back)(struct _cef_browser_t* self); + + /// + /// Returns true (1) if the browser can navigate forwards. + /// + int(CEF_CALLBACK* can_go_forward)(struct _cef_browser_t* self); + + /// + /// Navigate forwards. + /// + void(CEF_CALLBACK* go_forward)(struct _cef_browser_t* self); + + /// + /// Returns true (1) if the browser is currently loading. + /// + int(CEF_CALLBACK* is_loading)(struct _cef_browser_t* self); + + /// + /// Reload the current page. + /// + void(CEF_CALLBACK* reload)(struct _cef_browser_t* self); + + /// + /// Reload the current page ignoring any cached data. + /// + void(CEF_CALLBACK* reload_ignore_cache)(struct _cef_browser_t* self); + + /// + /// Stop loading the page. + /// + void(CEF_CALLBACK* stop_load)(struct _cef_browser_t* self); + + /// + /// Returns the globally unique identifier for this browser. This value is + /// also used as the tabId for extension APIs. + /// + int(CEF_CALLBACK* get_identifier)(struct _cef_browser_t* self); + + /// + /// Returns true (1) if this object is pointing to the same handle as |that| + /// object. + /// + int(CEF_CALLBACK* is_same)(struct _cef_browser_t* self, + struct _cef_browser_t* that); + + /// + /// Returns true (1) if the browser is a popup. + /// + int(CEF_CALLBACK* is_popup)(struct _cef_browser_t* self); + + /// + /// Returns true (1) if a document has been loaded in the browser. + /// + int(CEF_CALLBACK* has_document)(struct _cef_browser_t* self); + + /// + /// Returns the main (top-level) frame for the browser. In the browser process + /// this will return a valid object until after + /// cef_life_span_handler_t::OnBeforeClose is called. In the renderer process + /// this will return NULL if the main frame is hosted in a different renderer + /// process (e.g. for cross-origin sub-frames). The main frame object will + /// change during cross-origin navigation or re-navigation after renderer + /// process termination (due to crashes, etc). + /// + struct _cef_frame_t*(CEF_CALLBACK* get_main_frame)( + struct _cef_browser_t* self); + + /// + /// Returns the focused frame for the browser. + /// + struct _cef_frame_t*(CEF_CALLBACK* get_focused_frame)( + struct _cef_browser_t* self); + + /// + /// Returns the frame with the specified identifier, or NULL if not found. + /// + struct _cef_frame_t*(CEF_CALLBACK* get_frame_byident)( + struct _cef_browser_t* self, + int64 identifier); + + /// + /// Returns the frame with the specified name, or NULL if not found. + /// + struct _cef_frame_t*(CEF_CALLBACK* get_frame)(struct _cef_browser_t* self, + const cef_string_t* name); + + /// + /// Returns the number of frames that currently exist. + /// + size_t(CEF_CALLBACK* get_frame_count)(struct _cef_browser_t* self); + + /// + /// Returns the identifiers of all existing frames. + /// + void(CEF_CALLBACK* get_frame_identifiers)(struct _cef_browser_t* self, + size_t* identifiersCount, + int64* identifiers); + + /// + /// Returns the names of all existing frames. + /// + void(CEF_CALLBACK* get_frame_names)(struct _cef_browser_t* self, + cef_string_list_t names); +} cef_browser_t; + +/// +/// Callback structure for cef_browser_host_t::RunFileDialog. The functions of +/// this structure will be called on the browser process UI thread. +/// +typedef struct _cef_run_file_dialog_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called asynchronously after the file dialog is dismissed. |file_paths| + /// will be a single value or a list of values depending on the dialog mode. + /// If the selection was cancelled |file_paths| will be NULL. + /// + void(CEF_CALLBACK* on_file_dialog_dismissed)( + struct _cef_run_file_dialog_callback_t* self, + cef_string_list_t file_paths); +} cef_run_file_dialog_callback_t; + +/// +/// Callback structure for cef_browser_host_t::GetNavigationEntries. The +/// functions of this structure will be called on the browser process UI thread. +/// +typedef struct _cef_navigation_entry_visitor_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be executed. Do not keep a reference to |entry| outside + /// of this callback. Return true (1) to continue visiting entries or false + /// (0) to stop. |current| is true (1) if this entry is the currently loaded + /// navigation entry. |index| is the 0-based index of this entry and |total| + /// is the total number of entries. + /// + int(CEF_CALLBACK* visit)(struct _cef_navigation_entry_visitor_t* self, + struct _cef_navigation_entry_t* entry, + int current, + int index, + int total); +} cef_navigation_entry_visitor_t; + +/// +/// Callback structure for cef_browser_host_t::PrintToPDF. The functions of this +/// structure will be called on the browser process UI thread. +/// +typedef struct _cef_pdf_print_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be executed when the PDF printing has completed. |path| + /// is the output path. |ok| will be true (1) if the printing completed + /// successfully or false (0) otherwise. + /// + void(CEF_CALLBACK* on_pdf_print_finished)( + struct _cef_pdf_print_callback_t* self, + const cef_string_t* path, + int ok); +} cef_pdf_print_callback_t; + +/// +/// Callback structure for cef_browser_host_t::DownloadImage. The functions of +/// this structure will be called on the browser process UI thread. +/// +typedef struct _cef_download_image_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be executed when the image download has completed. + /// |image_url| is the URL that was downloaded and |http_status_code| is the + /// resulting HTTP status code. |image| is the resulting image, possibly at + /// multiple scale factors, or NULL if the download failed. + /// + void(CEF_CALLBACK* on_download_image_finished)( + struct _cef_download_image_callback_t* self, + const cef_string_t* image_url, + int http_status_code, + struct _cef_image_t* image); +} cef_download_image_callback_t; + +/// +/// Structure used to represent the browser process aspects of a browser. The +/// functions of this structure can only be called in the browser process. They +/// may be called on any thread in that process unless otherwise indicated in +/// the comments. +/// +typedef struct _cef_browser_host_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the hosted browser object. + /// + struct _cef_browser_t*(CEF_CALLBACK* get_browser)( + struct _cef_browser_host_t* self); + + /// + /// Request that the browser close. The JavaScript 'onbeforeunload' event will + /// be fired. If |force_close| is false (0) the event handler, if any, will be + /// allowed to prompt the user and the user can optionally cancel the close. + /// If |force_close| is true (1) the prompt will not be displayed and the + /// close will proceed. Results in a call to + /// cef_life_span_handler_t::do_close() if the event handler allows the close + /// or if |force_close| is true (1). See cef_life_span_handler_t::do_close() + /// documentation for additional usage information. + /// + void(CEF_CALLBACK* close_browser)(struct _cef_browser_host_t* self, + int force_close); + + /// + /// Helper for closing a browser. Call this function from the top-level window + /// close handler (if any). Internally this calls CloseBrowser(false (0)) if + /// the close has not yet been initiated. This function returns false (0) + /// while the close is pending and true (1) after the close has completed. See + /// close_browser() and cef_life_span_handler_t::do_close() documentation for + /// additional usage information. This function must be called on the browser + /// process UI thread. + /// + int(CEF_CALLBACK* try_close_browser)(struct _cef_browser_host_t* self); + + /// + /// Set whether the browser is focused. + /// + void(CEF_CALLBACK* set_focus)(struct _cef_browser_host_t* self, int focus); + + /// + /// Retrieve the window handle (if any) for this browser. If this browser is + /// wrapped in a cef_browser_view_t this function should be called on the + /// browser process UI thread and it will return the handle for the top-level + /// native window. + /// + cef_window_handle_t(CEF_CALLBACK* get_window_handle)( + struct _cef_browser_host_t* self); + + /// + /// Retrieve the window handle (if any) of the browser that opened this + /// browser. Will return NULL for non-popup browsers or if this browser is + /// wrapped in a cef_browser_view_t. This function can be used in combination + /// with custom handling of modal windows. + /// + cef_window_handle_t(CEF_CALLBACK* get_opener_window_handle)( + struct _cef_browser_host_t* self); + + /// + /// Returns true (1) if this browser is wrapped in a cef_browser_view_t. + /// + int(CEF_CALLBACK* has_view)(struct _cef_browser_host_t* self); + + /// + /// Returns the client for this browser. + /// + struct _cef_client_t*(CEF_CALLBACK* get_client)( + struct _cef_browser_host_t* self); + + /// + /// Returns the request context for this browser. + /// + struct _cef_request_context_t*(CEF_CALLBACK* get_request_context)( + struct _cef_browser_host_t* self); + + /// + /// Get the current zoom level. The default zoom level is 0.0. This function + /// can only be called on the UI thread. + /// + double(CEF_CALLBACK* get_zoom_level)(struct _cef_browser_host_t* self); + + /// + /// Change the zoom level to the specified value. Specify 0.0 to reset the + /// zoom level. If called on the UI thread the change will be applied + /// immediately. Otherwise, the change will be applied asynchronously on the + /// UI thread. + /// + void(CEF_CALLBACK* set_zoom_level)(struct _cef_browser_host_t* self, + double zoomLevel); + + /// + /// Call to run a file chooser dialog. Only a single file chooser dialog may + /// be pending at any given time. |mode| represents the type of dialog to + /// display. |title| to the title to be used for the dialog and may be NULL to + /// show the default title ("Open" or "Save" depending on the mode). + /// |default_file_path| is the path with optional directory and/or file name + /// component that will be initially selected in the dialog. |accept_filters| + /// are used to restrict the selectable file types and may any combination of + /// (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"), (b) + /// individual file extensions (e.g. ".txt" or ".png"), or (c) combined + /// description and file extension delimited using "|" and ";" (e.g. "Image + /// Types|.png;.gif;.jpg"). |callback| will be executed after the dialog is + /// dismissed or immediately if another dialog is already pending. The dialog + /// will be initiated asynchronously on the UI thread. + /// + void(CEF_CALLBACK* run_file_dialog)( + struct _cef_browser_host_t* self, + cef_file_dialog_mode_t mode, + const cef_string_t* title, + const cef_string_t* default_file_path, + cef_string_list_t accept_filters, + struct _cef_run_file_dialog_callback_t* callback); + + /// + /// Download the file at |url| using cef_download_handler_t. + /// + void(CEF_CALLBACK* start_download)(struct _cef_browser_host_t* self, + const cef_string_t* url); + + /// + /// Download |image_url| and execute |callback| on completion with the images + /// received from the renderer. If |is_favicon| is true (1) then cookies are + /// not sent and not accepted during download. Images with density independent + /// pixel (DIP) sizes larger than |max_image_size| are filtered out from the + /// image results. Versions of the image at different scale factors may be + /// downloaded up to the maximum scale factor supported by the system. If + /// there are no image results <= |max_image_size| then the smallest image is + /// resized to |max_image_size| and is the only result. A |max_image_size| of + /// 0 means unlimited. If |bypass_cache| is true (1) then |image_url| is + /// requested from the server even if it is present in the browser cache. + /// + void(CEF_CALLBACK* download_image)( + struct _cef_browser_host_t* self, + const cef_string_t* image_url, + int is_favicon, + uint32 max_image_size, + int bypass_cache, + struct _cef_download_image_callback_t* callback); + + /// + /// Print the current browser contents. + /// + void(CEF_CALLBACK* print)(struct _cef_browser_host_t* self); + + /// + /// Print the current browser contents to the PDF file specified by |path| and + /// execute |callback| on completion. The caller is responsible for deleting + /// |path| when done. For PDF printing to work on Linux you must implement the + /// cef_print_handler_t::GetPdfPaperSize function. + /// + void(CEF_CALLBACK* print_to_pdf)( + struct _cef_browser_host_t* self, + const cef_string_t* path, + const struct _cef_pdf_print_settings_t* settings, + struct _cef_pdf_print_callback_t* callback); + + /// + /// Search for |searchText|. |forward| indicates whether to search forward or + /// backward within the page. |matchCase| indicates whether the search should + /// be case-sensitive. |findNext| indicates whether this is the first request + /// or a follow-up. The search will be restarted if |searchText| or + /// |matchCase| change. The search will be stopped if |searchText| is NULL. + /// The cef_find_handler_t instance, if any, returned via + /// cef_client_t::GetFindHandler will be called to report find results. + /// + void(CEF_CALLBACK* find)(struct _cef_browser_host_t* self, + const cef_string_t* searchText, + int forward, + int matchCase, + int findNext); + + /// + /// Cancel all searches that are currently going on. + /// + void(CEF_CALLBACK* stop_finding)(struct _cef_browser_host_t* self, + int clearSelection); + + /// + /// Open developer tools (DevTools) in its own browser. The DevTools browser + /// will remain associated with this browser. If the DevTools browser is + /// already open then it will be focused, in which case the |windowInfo|, + /// |client| and |settings| parameters will be ignored. If + /// |inspect_element_at| is non-NULL then the element at the specified (x,y) + /// location will be inspected. The |windowInfo| parameter will be ignored if + /// this browser is wrapped in a cef_browser_view_t. + /// + void(CEF_CALLBACK* show_dev_tools)( + struct _cef_browser_host_t* self, + const struct _cef_window_info_t* windowInfo, + struct _cef_client_t* client, + const struct _cef_browser_settings_t* settings, + const cef_point_t* inspect_element_at); + + /// + /// Explicitly close the associated DevTools browser, if any. + /// + void(CEF_CALLBACK* close_dev_tools)(struct _cef_browser_host_t* self); + + /// + /// Returns true (1) if this browser currently has an associated DevTools + /// browser. Must be called on the browser process UI thread. + /// + int(CEF_CALLBACK* has_dev_tools)(struct _cef_browser_host_t* self); + + /// + /// Send a function call message over the DevTools protocol. |message| must be + /// a UTF8-encoded JSON dictionary that contains "id" (int), "function" + /// (string) and "params" (dictionary, optional) values. See the DevTools + /// protocol documentation at https://chromedevtools.github.io/devtools- + /// protocol/ for details of supported functions and the expected "params" + /// dictionary contents. |message| will be copied if necessary. This function + /// will return true (1) if called on the UI thread and the message was + /// successfully submitted for validation, otherwise false (0). Validation + /// will be applied asynchronously and any messages that fail due to + /// formatting errors or missing parameters may be discarded without + /// notification. Prefer ExecuteDevToolsMethod if a more structured approach + /// to message formatting is desired. + /// + /// Every valid function call will result in an asynchronous function result + /// or error message that references the sent message "id". Event messages are + /// received while notifications are enabled (for example, between function + /// calls for "Page.enable" and "Page.disable"). All received messages will be + /// delivered to the observer(s) registered with AddDevToolsMessageObserver. + /// See cef_dev_tools_message_observer_t::OnDevToolsMessage documentation for + /// details of received message contents. + /// + /// Usage of the SendDevToolsMessage, ExecuteDevToolsMethod and + /// AddDevToolsMessageObserver functions does not require an active DevTools + /// front-end or remote-debugging session. Other active DevTools sessions will + /// continue to function independently. However, any modification of global + /// browser state by one session may not be reflected in the UI of other + /// sessions. + /// + /// Communication with the DevTools front-end (when displayed) can be logged + /// for development purposes by passing the `--devtools-protocol-log- + /// file=<path>` command-line flag. + /// + int(CEF_CALLBACK* send_dev_tools_message)(struct _cef_browser_host_t* self, + const void* message, + size_t message_size); + + /// + /// Execute a function call over the DevTools protocol. This is a more + /// structured version of SendDevToolsMessage. |message_id| is an incremental + /// number that uniquely identifies the message (pass 0 to have the next + /// number assigned automatically based on previous values). |function| is the + /// function name. |params| are the function parameters, which may be NULL. + /// See the DevTools protocol documentation (linked above) for details of + /// supported functions and the expected |params| dictionary contents. This + /// function will return the assigned message ID if called on the UI thread + /// and the message was successfully submitted for validation, otherwise 0. + /// See the SendDevToolsMessage documentation for additional usage + /// information. + /// + int(CEF_CALLBACK* execute_dev_tools_method)( + struct _cef_browser_host_t* self, + int message_id, + const cef_string_t* method, + struct _cef_dictionary_value_t* params); + + /// + /// Add an observer for DevTools protocol messages (function results and + /// events). The observer will remain registered until the returned + /// Registration object is destroyed. See the SendDevToolsMessage + /// documentation for additional usage information. + /// + struct _cef_registration_t*(CEF_CALLBACK* add_dev_tools_message_observer)( + struct _cef_browser_host_t* self, + struct _cef_dev_tools_message_observer_t* observer); + + /// + /// Retrieve a snapshot of current navigation entries as values sent to the + /// specified visitor. If |current_only| is true (1) only the current + /// navigation entry will be sent, otherwise all navigation entries will be + /// sent. + /// + void(CEF_CALLBACK* get_navigation_entries)( + struct _cef_browser_host_t* self, + struct _cef_navigation_entry_visitor_t* visitor, + int current_only); + + /// + /// If a misspelled word is currently selected in an editable node calling + /// this function will replace it with the specified |word|. + /// + void(CEF_CALLBACK* replace_misspelling)(struct _cef_browser_host_t* self, + const cef_string_t* word); + + /// + /// Add the specified |word| to the spelling dictionary. + /// + void(CEF_CALLBACK* add_word_to_dictionary)(struct _cef_browser_host_t* self, + const cef_string_t* word); + + /// + /// Returns true (1) if window rendering is disabled. + /// + int(CEF_CALLBACK* is_window_rendering_disabled)( + struct _cef_browser_host_t* self); + + /// + /// Notify the browser that the widget has been resized. The browser will + /// first call cef_render_handler_t::GetViewRect to get the new size and then + /// call cef_render_handler_t::OnPaint asynchronously with the updated + /// regions. This function is only used when window rendering is disabled. + /// + void(CEF_CALLBACK* was_resized)(struct _cef_browser_host_t* self); + + /// + /// Notify the browser that it has been hidden or shown. Layouting and + /// cef_render_handler_t::OnPaint notification will stop when the browser is + /// hidden. This function is only used when window rendering is disabled. + /// + void(CEF_CALLBACK* was_hidden)(struct _cef_browser_host_t* self, int hidden); + + /// + /// Send a notification to the browser that the screen info has changed. The + /// browser will then call cef_render_handler_t::GetScreenInfo to update the + /// screen information with the new values. This simulates moving the webview + /// window from one display to another, or changing the properties of the + /// current display. This function is only used when window rendering is + /// disabled. + /// + void(CEF_CALLBACK* notify_screen_info_changed)( + struct _cef_browser_host_t* self); + + /// + /// Invalidate the view. The browser will call cef_render_handler_t::OnPaint + /// asynchronously. This function is only used when window rendering is + /// disabled. + /// + void(CEF_CALLBACK* invalidate)(struct _cef_browser_host_t* self, + cef_paint_element_type_t type); + + /// + /// Issue a BeginFrame request to Chromium. Only valid when + /// cef_window_tInfo::external_begin_frame_enabled is set to true (1). + /// + void(CEF_CALLBACK* send_external_begin_frame)( + struct _cef_browser_host_t* self); + + /// + /// Send a key event to the browser. + /// + void(CEF_CALLBACK* send_key_event)(struct _cef_browser_host_t* self, + const cef_key_event_t* event); + + /// + /// Send a mouse click event to the browser. The |x| and |y| coordinates are + /// relative to the upper-left corner of the view. + /// + void(CEF_CALLBACK* send_mouse_click_event)(struct _cef_browser_host_t* self, + const cef_mouse_event_t* event, + cef_mouse_button_type_t type, + int mouseUp, + int clickCount); + + /// + /// Send a mouse move event to the browser. The |x| and |y| coordinates are + /// relative to the upper-left corner of the view. + /// + void(CEF_CALLBACK* send_mouse_move_event)(struct _cef_browser_host_t* self, + const cef_mouse_event_t* event, + int mouseLeave); + + /// + /// Send a mouse wheel event to the browser. The |x| and |y| coordinates are + /// relative to the upper-left corner of the view. The |deltaX| and |deltaY| + /// values represent the movement delta in the X and Y directions + /// respectively. In order to scroll inside select popups with window + /// rendering disabled cef_render_handler_t::GetScreenPoint should be + /// implemented properly. + /// + void(CEF_CALLBACK* send_mouse_wheel_event)(struct _cef_browser_host_t* self, + const cef_mouse_event_t* event, + int deltaX, + int deltaY); + + /// + /// Send a touch event to the browser for a windowless browser. + /// + void(CEF_CALLBACK* send_touch_event)(struct _cef_browser_host_t* self, + const cef_touch_event_t* event); + + /// + /// Send a capture lost event to the browser. + /// + void(CEF_CALLBACK* send_capture_lost_event)(struct _cef_browser_host_t* self); + + /// + /// Notify the browser that the window hosting it is about to be moved or + /// resized. This function is only used on Windows and Linux. + /// + void(CEF_CALLBACK* notify_move_or_resize_started)( + struct _cef_browser_host_t* self); + + /// + /// Returns the maximum rate in frames per second (fps) that + /// cef_render_handler_t::OnPaint will be called for a windowless browser. The + /// actual fps may be lower if the browser cannot generate frames at the + /// requested rate. The minimum value is 1 and the maximum value is 60 + /// (default 30). This function can only be called on the UI thread. + /// + int(CEF_CALLBACK* get_windowless_frame_rate)( + struct _cef_browser_host_t* self); + + /// + /// Set the maximum rate in frames per second (fps) that + /// cef_render_handler_t:: OnPaint will be called for a windowless browser. + /// The actual fps may be lower if the browser cannot generate frames at the + /// requested rate. The minimum value is 1 and the maximum value is 60 + /// (default 30). Can also be set at browser creation via + /// cef_browser_tSettings.windowless_frame_rate. + /// + void(CEF_CALLBACK* set_windowless_frame_rate)( + struct _cef_browser_host_t* self, + int frame_rate); + + /// + /// Begins a new composition or updates the existing composition. Blink has a + /// special node (a composition node) that allows the input function to change + /// text without affecting other DOM nodes. |text| is the optional text that + /// will be inserted into the composition node. |underlines| is an optional + /// set of ranges that will be underlined in the resulting text. + /// |replacement_range| is an optional range of the existing text that will be + /// replaced. |selection_range| is an optional range of the resulting text + /// that will be selected after insertion or replacement. The + /// |replacement_range| value is only used on OS X. + /// + /// This function may be called multiple times as the composition changes. + /// When the client is done making changes the composition should either be + /// canceled or completed. To cancel the composition call + /// ImeCancelComposition. To complete the composition call either + /// ImeCommitText or ImeFinishComposingText. Completion is usually signaled + /// when: + /// + /// 1. The client receives a WM_IME_COMPOSITION message with a GCS_RESULTSTR + /// flag (on Windows), or; + /// 2. The client receives a "commit" signal of GtkIMContext (on Linux), or; + /// 3. insertText of NSTextInput is called (on Mac). + /// + /// This function is only used when window rendering is disabled. + /// + void(CEF_CALLBACK* ime_set_composition)( + struct _cef_browser_host_t* self, + const cef_string_t* text, + size_t underlinesCount, + cef_composition_underline_t const* underlines, + const cef_range_t* replacement_range, + const cef_range_t* selection_range); + + /// + /// Completes the existing composition by optionally inserting the specified + /// |text| into the composition node. |replacement_range| is an optional range + /// of the existing text that will be replaced. |relative_cursor_pos| is where + /// the cursor will be positioned relative to the current cursor position. See + /// comments on ImeSetComposition for usage. The |replacement_range| and + /// |relative_cursor_pos| values are only used on OS X. This function is only + /// used when window rendering is disabled. + /// + void(CEF_CALLBACK* ime_commit_text)(struct _cef_browser_host_t* self, + const cef_string_t* text, + const cef_range_t* replacement_range, + int relative_cursor_pos); + + /// + /// Completes the existing composition by applying the current composition + /// node contents. If |keep_selection| is false (0) the current selection, if + /// any, will be discarded. See comments on ImeSetComposition for usage. This + /// function is only used when window rendering is disabled. + /// + void(CEF_CALLBACK* ime_finish_composing_text)( + struct _cef_browser_host_t* self, + int keep_selection); + + /// + /// Cancels the existing composition and discards the composition node + /// contents without applying them. See comments on ImeSetComposition for + /// usage. This function is only used when window rendering is disabled. + /// + void(CEF_CALLBACK* ime_cancel_composition)(struct _cef_browser_host_t* self); + + /// + /// Call this function when the user drags the mouse into the web view (before + /// calling DragTargetDragOver/DragTargetLeave/DragTargetDrop). |drag_data| + /// should not contain file contents as this type of data is not allowed to be + /// dragged into the web view. File contents can be removed using + /// cef_drag_data_t::ResetFileContents (for example, if |drag_data| comes from + /// cef_render_handler_t::StartDragging). This function is only used when + /// window rendering is disabled. + /// + void(CEF_CALLBACK* drag_target_drag_enter)( + struct _cef_browser_host_t* self, + struct _cef_drag_data_t* drag_data, + const cef_mouse_event_t* event, + cef_drag_operations_mask_t allowed_ops); + + /// + /// Call this function each time the mouse is moved across the web view during + /// a drag operation (after calling DragTargetDragEnter and before calling + /// DragTargetDragLeave/DragTargetDrop). This function is only used when + /// window rendering is disabled. + /// + void(CEF_CALLBACK* drag_target_drag_over)( + struct _cef_browser_host_t* self, + const cef_mouse_event_t* event, + cef_drag_operations_mask_t allowed_ops); + + /// + /// Call this function when the user drags the mouse out of the web view + /// (after calling DragTargetDragEnter). This function is only used when + /// window rendering is disabled. + /// + void(CEF_CALLBACK* drag_target_drag_leave)(struct _cef_browser_host_t* self); + + /// + /// Call this function when the user completes the drag operation by dropping + /// the object onto the web view (after calling DragTargetDragEnter). The + /// object being dropped is |drag_data|, given as an argument to the previous + /// DragTargetDragEnter call. This function is only used when window rendering + /// is disabled. + /// + void(CEF_CALLBACK* drag_target_drop)(struct _cef_browser_host_t* self, + const cef_mouse_event_t* event); + + /// + /// Call this function when the drag operation started by a + /// cef_render_handler_t::StartDragging call has ended either in a drop or by + /// being cancelled. |x| and |y| are mouse coordinates relative to the upper- + /// left corner of the view. If the web view is both the drag source and the + /// drag target then all DragTarget* functions should be called before + /// DragSource* mthods. This function is only used when window rendering is + /// disabled. + /// + void(CEF_CALLBACK* drag_source_ended_at)(struct _cef_browser_host_t* self, + int x, + int y, + cef_drag_operations_mask_t op); + + /// + /// Call this function when the drag operation started by a + /// cef_render_handler_t::StartDragging call has completed. This function may + /// be called immediately without first calling DragSourceEndedAt to cancel a + /// drag operation. If the web view is both the drag source and the drag + /// target then all DragTarget* functions should be called before DragSource* + /// mthods. This function is only used when window rendering is disabled. + /// + void(CEF_CALLBACK* drag_source_system_drag_ended)( + struct _cef_browser_host_t* self); + + /// + /// Returns the current visible navigation entry for this browser. This + /// function can only be called on the UI thread. + /// + struct _cef_navigation_entry_t*(CEF_CALLBACK* get_visible_navigation_entry)( + struct _cef_browser_host_t* self); + + /// + /// Set accessibility state for all frames. |accessibility_state| may be + /// default, enabled or disabled. If |accessibility_state| is STATE_DEFAULT + /// then accessibility will be disabled by default and the state may be + /// further controlled with the "force-renderer-accessibility" and "disable- + /// renderer-accessibility" command-line switches. If |accessibility_state| is + /// STATE_ENABLED then accessibility will be enabled. If |accessibility_state| + /// is STATE_DISABLED then accessibility will be completely disabled. + /// + /// For windowed browsers accessibility will be enabled in Complete mode + /// (which corresponds to kAccessibilityModeComplete in Chromium). In this + /// mode all platform accessibility objects will be created and managed by + /// Chromium's internal implementation. The client needs only to detect the + /// screen reader and call this function appropriately. For example, on macOS + /// the client can handle the @"AXEnhancedUserStructure" accessibility + /// attribute to detect VoiceOver state changes and on Windows the client can + /// handle WM_GETOBJECT with OBJID_CLIENT to detect accessibility readers. + /// + /// For windowless browsers accessibility will be enabled in TreeOnly mode + /// (which corresponds to kAccessibilityModeWebContentsOnly in Chromium). In + /// this mode renderer accessibility is enabled, the full tree is computed, + /// and events are passed to CefAccessibiltyHandler, but platform + /// accessibility objects are not created. The client may implement platform + /// accessibility objects using CefAccessibiltyHandler callbacks if desired. + /// + void(CEF_CALLBACK* set_accessibility_state)(struct _cef_browser_host_t* self, + cef_state_t accessibility_state); + + /// + /// Enable notifications of auto resize via + /// cef_display_handler_t::OnAutoResize. Notifications are disabled by + /// default. |min_size| and |max_size| define the range of allowed sizes. + /// + void(CEF_CALLBACK* set_auto_resize_enabled)(struct _cef_browser_host_t* self, + int enabled, + const cef_size_t* min_size, + const cef_size_t* max_size); + + /// + /// Returns the extension hosted in this browser or NULL if no extension is + /// hosted. See cef_request_context_t::LoadExtension for details. + /// + struct _cef_extension_t*(CEF_CALLBACK* get_extension)( + struct _cef_browser_host_t* self); + + /// + /// Returns true (1) if this browser is hosting an extension background + /// script. Background hosts do not have a window and are not displayable. See + /// cef_request_context_t::LoadExtension for details. + /// + int(CEF_CALLBACK* is_background_host)(struct _cef_browser_host_t* self); + + /// + /// Set whether the browser's audio is muted. + /// + void(CEF_CALLBACK* set_audio_muted)(struct _cef_browser_host_t* self, + int mute); + + /// + /// Returns true (1) if the browser's audio is muted. This function can only + /// be called on the UI thread. + /// + int(CEF_CALLBACK* is_audio_muted)(struct _cef_browser_host_t* self); +} cef_browser_host_t; + +/// +/// Create a new browser using the window parameters specified by |windowInfo|. +/// All values will be copied internally and the actual window (if any) will be +/// created on the UI thread. If |request_context| is NULL the global request +/// context will be used. This function can be called on any browser process +/// thread and will not block. The optional |extra_info| parameter provides an +/// opportunity to specify extra information specific to the created browser +/// that will be passed to cef_render_process_handler_t::on_browser_created() in +/// the render process. +/// +CEF_EXPORT int cef_browser_host_create_browser( + const cef_window_info_t* windowInfo, + struct _cef_client_t* client, + const cef_string_t* url, + const struct _cef_browser_settings_t* settings, + struct _cef_dictionary_value_t* extra_info, + struct _cef_request_context_t* request_context); + +/// +/// Create a new browser using the window parameters specified by |windowInfo|. +/// If |request_context| is NULL the global request context will be used. This +/// function can only be called on the browser process UI thread. The optional +/// |extra_info| parameter provides an opportunity to specify extra information +/// specific to the created browser that will be passed to +/// cef_render_process_handler_t::on_browser_created() in the render process. +/// +CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync( + const cef_window_info_t* windowInfo, + struct _cef_client_t* client, + const cef_string_t* url, + const struct _cef_browser_settings_t* settings, + struct _cef_dictionary_value_t* extra_info, + struct _cef_request_context_t* request_context); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_ diff --git a/include/capi/cef_browser_process_handler_capi.h b/include/capi/cef_browser_process_handler_capi.h new file mode 100644 index 00000000..043deb4d --- /dev/null +++ b/include/capi/cef_browser_process_handler_capi.h @@ -0,0 +1,141 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=4ef8b73a5218531b370fdd76c23153a1f83b7f7b$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_client_capi.h" +#include "include/capi/cef_command_line_capi.h" +#include "include/capi/cef_preference_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used to implement browser process callbacks. The functions of this +/// structure will be called on the browser process main thread unless otherwise +/// indicated. +/// +typedef struct _cef_browser_process_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Provides an opportunity to register custom preferences prior to global and + /// request context initialization. + /// + /// If |type| is CEF_PREFERENCES_TYPE_GLOBAL the registered preferences can be + /// accessed via cef_preference_manager_t::GetGlobalPreferences after + /// OnContextInitialized is called. Global preferences are registered a single + /// time at application startup. See related cef_settings_t.cache_path and + /// cef_settings_t.persist_user_preferences configuration. + /// + /// If |type| is CEF_PREFERENCES_TYPE_REQUEST_CONTEXT the preferences can be + /// accessed via the cef_request_context_t after + /// cef_request_context_handler_t::OnRequestContextInitialized is called. + /// Request context preferences are registered each time a new + /// cef_request_context_t is created. It is intended but not required that all + /// request contexts have the same registered preferences. See related + /// cef_request_context_settings_t.cache_path and + /// cef_request_context_settings_t.persist_user_preferences configuration. + /// + /// Do not keep a reference to the |registrar| object. This function is called + /// on the browser process UI thread. + /// + void(CEF_CALLBACK* on_register_custom_preferences)( + struct _cef_browser_process_handler_t* self, + cef_preferences_type_t type, + struct _cef_preference_registrar_t* registrar); + + /// + /// Called on the browser process UI thread immediately after the CEF context + /// has been initialized. + /// + void(CEF_CALLBACK* on_context_initialized)( + struct _cef_browser_process_handler_t* self); + + /// + /// Called before a child process is launched. Will be called on the browser + /// process UI thread when launching a render process and on the browser + /// process IO thread when launching a GPU process. Provides an opportunity to + /// modify the child process command line. Do not keep a reference to + /// |command_line| outside of this function. + /// + void(CEF_CALLBACK* on_before_child_process_launch)( + struct _cef_browser_process_handler_t* self, + struct _cef_command_line_t* command_line); + + /// + /// Called from any thread when work has been scheduled for the browser + /// process main (UI) thread. This callback is used in combination with + /// cef_settings_t.external_message_pump and cef_do_message_loop_work() in + /// cases where the CEF message loop must be integrated into an existing + /// application message loop (see additional comments and warnings on + /// CefDoMessageLoopWork). This callback should schedule a + /// cef_do_message_loop_work() call to happen on the main (UI) thread. + /// |delay_ms| is the requested delay in milliseconds. If |delay_ms| is <= 0 + /// then the call should happen reasonably soon. If |delay_ms| is > 0 then the + /// call should be scheduled to happen after the specified delay and any + /// currently pending scheduled call should be cancelled. + /// + void(CEF_CALLBACK* on_schedule_message_pump_work)( + struct _cef_browser_process_handler_t* self, + int64 delay_ms); + + /// + /// Return the default client for use with a newly created browser window. If + /// null is returned the browser will be unmanaged (no callbacks will be + /// executed for that browser) and application shutdown will be blocked until + /// the browser window is closed manually. This function is currently only + /// used with the chrome runtime. + /// + struct _cef_client_t*(CEF_CALLBACK* get_default_client)( + struct _cef_browser_process_handler_t* self); +} cef_browser_process_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_ diff --git a/include/capi/cef_callback_capi.h b/include/capi/cef_callback_capi.h new file mode 100644 index 00000000..d5086aab --- /dev/null +++ b/include/capi/cef_callback_capi.h @@ -0,0 +1,88 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=4fd98ff68ecb42677c3344b75e26d4787161b0d2$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Generic callback structure used for asynchronous continuation. +/// +typedef struct _cef_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Continue processing. + /// + void(CEF_CALLBACK* cont)(struct _cef_callback_t* self); + + /// + /// Cancel processing. + /// + void(CEF_CALLBACK* cancel)(struct _cef_callback_t* self); +} cef_callback_t; + +/// +/// Generic callback structure used for asynchronous completion. +/// +typedef struct _cef_completion_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be called once the task is complete. + /// + void(CEF_CALLBACK* on_complete)(struct _cef_completion_callback_t* self); +} cef_completion_callback_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_ diff --git a/include/capi/cef_client_capi.h b/include/capi/cef_client_capi.h new file mode 100644 index 00000000..e85a33b3 --- /dev/null +++ b/include/capi/cef_client_capi.h @@ -0,0 +1,210 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=eb9dcb574252483dfab12834af93ba14138d4089$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_ +#pragma once + +#include "include/capi/cef_audio_handler_capi.h" +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_command_handler_capi.h" +#include "include/capi/cef_context_menu_handler_capi.h" +#include "include/capi/cef_dialog_handler_capi.h" +#include "include/capi/cef_display_handler_capi.h" +#include "include/capi/cef_download_handler_capi.h" +#include "include/capi/cef_drag_handler_capi.h" +#include "include/capi/cef_find_handler_capi.h" +#include "include/capi/cef_focus_handler_capi.h" +#include "include/capi/cef_frame_handler_capi.h" +#include "include/capi/cef_jsdialog_handler_capi.h" +#include "include/capi/cef_keyboard_handler_capi.h" +#include "include/capi/cef_life_span_handler_capi.h" +#include "include/capi/cef_load_handler_capi.h" +#include "include/capi/cef_permission_handler_capi.h" +#include "include/capi/cef_print_handler_capi.h" +#include "include/capi/cef_process_message_capi.h" +#include "include/capi/cef_render_handler_capi.h" +#include "include/capi/cef_request_handler_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to provide handler implementations. +/// +typedef struct _cef_client_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Return the handler for audio rendering events. + /// + struct _cef_audio_handler_t*(CEF_CALLBACK* get_audio_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for commands. If no handler is provided the default + /// implementation will be used. + /// + struct _cef_command_handler_t*(CEF_CALLBACK* get_command_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for context menus. If no handler is provided the + /// default implementation will be used. + /// + struct _cef_context_menu_handler_t*(CEF_CALLBACK* get_context_menu_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for dialogs. If no handler is provided the default + /// implementation will be used. + /// + struct _cef_dialog_handler_t*(CEF_CALLBACK* get_dialog_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for browser display state events. + /// + struct _cef_display_handler_t*(CEF_CALLBACK* get_display_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for download events. If no handler is returned + /// downloads will not be allowed. + /// + struct _cef_download_handler_t*(CEF_CALLBACK* get_download_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for drag events. + /// + struct _cef_drag_handler_t*(CEF_CALLBACK* get_drag_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for find result events. + /// + struct _cef_find_handler_t*(CEF_CALLBACK* get_find_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for focus events. + /// + struct _cef_focus_handler_t*(CEF_CALLBACK* get_focus_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for events related to cef_frame_t lifespan. This + /// function will be called once during cef_browser_t creation and the result + /// will be cached for performance reasons. + /// + struct _cef_frame_handler_t*(CEF_CALLBACK* get_frame_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for permission requests. + /// + struct _cef_permission_handler_t*(CEF_CALLBACK* get_permission_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for JavaScript dialogs. If no handler is provided the + /// default implementation will be used. + /// + struct _cef_jsdialog_handler_t*(CEF_CALLBACK* get_jsdialog_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for keyboard events. + /// + struct _cef_keyboard_handler_t*(CEF_CALLBACK* get_keyboard_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for browser life span events. + /// + struct _cef_life_span_handler_t*(CEF_CALLBACK* get_life_span_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for browser load status events. + /// + struct _cef_load_handler_t*(CEF_CALLBACK* get_load_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for printing on Linux. If a print handler is not + /// provided then printing will not be supported on the Linux platform. + /// + struct _cef_print_handler_t*(CEF_CALLBACK* get_print_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for off-screen rendering events. + /// + struct _cef_render_handler_t*(CEF_CALLBACK* get_render_handler)( + struct _cef_client_t* self); + + /// + /// Return the handler for browser request events. + /// + struct _cef_request_handler_t*(CEF_CALLBACK* get_request_handler)( + struct _cef_client_t* self); + + /// + /// Called when a new message is received from a different process. Return + /// true (1) if the message was handled or false (0) otherwise. It is safe to + /// keep a reference to |message| outside of this callback. + /// + int(CEF_CALLBACK* on_process_message_received)( + struct _cef_client_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + cef_process_id_t source_process, + struct _cef_process_message_t* message); +} cef_client_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_ diff --git a/include/capi/cef_command_handler_capi.h b/include/capi/cef_command_handler_capi.h new file mode 100644 index 00000000..862bff67 --- /dev/null +++ b/include/capi/cef_command_handler_capi.h @@ -0,0 +1,80 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=46817ef557307a55a9b7138134c4f5c32562f2d7$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_COMMAND_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events related to commands. The functions +/// of this structure will be called on the UI thread. +/// +typedef struct _cef_command_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called to execute a Chrome command triggered via menu selection or + /// keyboard shortcut. Values for |command_id| can be found in the + /// cef_command_ids.h file. |disposition| provides information about the + /// intended command target. Return true (1) if the command was handled or + /// false (0) for the default implementation. For context menu commands this + /// will be called after cef_context_menu_handler_t::OnContextMenuCommand. + /// Only used with the Chrome runtime. + /// + int(CEF_CALLBACK* on_chrome_command)( + struct _cef_command_handler_t* self, + struct _cef_browser_t* browser, + int command_id, + cef_window_open_disposition_t disposition); +} cef_command_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_COMMAND_HANDLER_CAPI_H_ diff --git a/include/capi/cef_command_line_capi.h b/include/capi/cef_command_line_capi.h new file mode 100644 index 00000000..3379baa3 --- /dev/null +++ b/include/capi/cef_command_line_capi.h @@ -0,0 +1,215 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=ac8fd3a7da20cff1fe2f20a75b045bf27c0312f2$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used to create and/or parse command line arguments. Arguments with +/// "--", "-" and, on Windows, "/" prefixes are considered switches. Switches +/// will always precede any arguments without switch prefixes. Switches can +/// optionally have a value specified using the "=" delimiter (e.g. +/// "-switch=value"). An argument of "--" will terminate switch parsing with all +/// subsequent tokens, regardless of prefix, being interpreted as non-switch +/// arguments. Switch names should be lowercase ASCII and will be converted to +/// such if necessary. Switch values will retain the original case and UTF8 +/// encoding. This structure can be used before cef_initialize() is called. +/// +typedef struct _cef_command_line_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. Do not call any other functions + /// if this function returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_command_line_t* self); + + /// + /// Returns true (1) if the values of this object are read-only. Some APIs may + /// expose read-only objects. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_command_line_t* self); + + /// + /// Returns a writable copy of this object. + /// + struct _cef_command_line_t*(CEF_CALLBACK* copy)( + struct _cef_command_line_t* self); + + /// + /// Initialize the command line with the specified |argc| and |argv| values. + /// The first argument must be the name of the program. This function is only + /// supported on non-Windows platforms. + /// + void(CEF_CALLBACK* init_from_argv)(struct _cef_command_line_t* self, + int argc, + const char* const* argv); + + /// + /// Initialize the command line with the string returned by calling + /// GetCommandLineW(). This function is only supported on Windows. + /// + void(CEF_CALLBACK* init_from_string)(struct _cef_command_line_t* self, + const cef_string_t* command_line); + + /// + /// Reset the command-line switches and arguments but leave the program + /// component unchanged. + /// + void(CEF_CALLBACK* reset)(struct _cef_command_line_t* self); + + /// + /// Retrieve the original command line string as a vector of strings. The argv + /// array: `{ program, [(--|-|/)switch[=value]]*, [--], [argument]* }` + /// + void(CEF_CALLBACK* get_argv)(struct _cef_command_line_t* self, + cef_string_list_t argv); + + /// + /// Constructs and returns the represented command line string. Use this + /// function cautiously because quoting behavior is unclear. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_command_line_string)( + struct _cef_command_line_t* self); + + /// + /// Get the program part of the command line string (the first item). + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_program)( + struct _cef_command_line_t* self); + + /// + /// Set the program part of the command line string (the first item). + /// + void(CEF_CALLBACK* set_program)(struct _cef_command_line_t* self, + const cef_string_t* program); + + /// + /// Returns true (1) if the command line has switches. + /// + int(CEF_CALLBACK* has_switches)(struct _cef_command_line_t* self); + + /// + /// Returns true (1) if the command line contains the given switch. + /// + int(CEF_CALLBACK* has_switch)(struct _cef_command_line_t* self, + const cef_string_t* name); + + /// + /// Returns the value associated with the given switch. If the switch has no + /// value or isn't present this function returns the NULL string. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_switch_value)( + struct _cef_command_line_t* self, + const cef_string_t* name); + + /// + /// Returns the map of switch names and values. If a switch has no value an + /// NULL string is returned. + /// + void(CEF_CALLBACK* get_switches)(struct _cef_command_line_t* self, + cef_string_map_t switches); + + /// + /// Add a switch to the end of the command line. + /// + void(CEF_CALLBACK* append_switch)(struct _cef_command_line_t* self, + const cef_string_t* name); + + /// + /// Add a switch with the specified value to the end of the command line. If + /// the switch has no value pass an NULL value string. + /// + void(CEF_CALLBACK* append_switch_with_value)(struct _cef_command_line_t* self, + const cef_string_t* name, + const cef_string_t* value); + + /// + /// True if there are remaining command line arguments. + /// + int(CEF_CALLBACK* has_arguments)(struct _cef_command_line_t* self); + + /// + /// Get the remaining command line arguments. + /// + void(CEF_CALLBACK* get_arguments)(struct _cef_command_line_t* self, + cef_string_list_t arguments); + + /// + /// Add an argument to the end of the command line. + /// + void(CEF_CALLBACK* append_argument)(struct _cef_command_line_t* self, + const cef_string_t* argument); + + /// + /// Insert a command before the current command. Common for debuggers, like + /// "valgrind" or "gdb --args". + /// + void(CEF_CALLBACK* prepend_wrapper)(struct _cef_command_line_t* self, + const cef_string_t* wrapper); +} cef_command_line_t; + +/// +/// Create a new cef_command_line_t instance. +/// +CEF_EXPORT cef_command_line_t* cef_command_line_create(void); + +/// +/// Returns the singleton global cef_command_line_t object. The returned object +/// will be read-only. +/// +CEF_EXPORT cef_command_line_t* cef_command_line_get_global(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_ diff --git a/include/capi/cef_context_menu_handler_capi.h b/include/capi/cef_context_menu_handler_capi.h new file mode 100644 index 00000000..bc273334 --- /dev/null +++ b/include/capi/cef_context_menu_handler_capi.h @@ -0,0 +1,367 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=c82f41d81f5afa5ed6995693e012c13d2a609f88$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_frame_capi.h" +#include "include/capi/cef_menu_model_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_context_menu_params_t; + +/// +/// Callback structure used for continuation of custom context menu display. +/// +typedef struct _cef_run_context_menu_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Complete context menu display by selecting the specified |command_id| and + /// |event_flags|. + /// + void(CEF_CALLBACK* cont)(struct _cef_run_context_menu_callback_t* self, + int command_id, + cef_event_flags_t event_flags); + + /// + /// Cancel context menu display. + /// + void(CEF_CALLBACK* cancel)(struct _cef_run_context_menu_callback_t* self); +} cef_run_context_menu_callback_t; + +/// +/// Callback structure used for continuation of custom quick menu display. +/// +typedef struct _cef_run_quick_menu_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Complete quick menu display by selecting the specified |command_id| and + /// |event_flags|. + /// + void(CEF_CALLBACK* cont)(struct _cef_run_quick_menu_callback_t* self, + int command_id, + cef_event_flags_t event_flags); + + /// + /// Cancel quick menu display. + /// + void(CEF_CALLBACK* cancel)(struct _cef_run_quick_menu_callback_t* self); +} cef_run_quick_menu_callback_t; + +/// +/// Implement this structure to handle context menu events. The functions of +/// this structure will be called on the UI thread. +/// +typedef struct _cef_context_menu_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called before a context menu is displayed. |params| provides information + /// about the context menu state. |model| initially contains the default + /// context menu. The |model| can be cleared to show no context menu or + /// modified to show a custom menu. Do not keep references to |params| or + /// |model| outside of this callback. + /// + void(CEF_CALLBACK* on_before_context_menu)( + struct _cef_context_menu_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_context_menu_params_t* params, + struct _cef_menu_model_t* model); + + /// + /// Called to allow custom display of the context menu. |params| provides + /// information about the context menu state. |model| contains the context + /// menu model resulting from OnBeforeContextMenu. For custom display return + /// true (1) and execute |callback| either synchronously or asynchronously + /// with the selected command ID. For default display return false (0). Do not + /// keep references to |params| or |model| outside of this callback. + /// + int(CEF_CALLBACK* run_context_menu)( + struct _cef_context_menu_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_context_menu_params_t* params, + struct _cef_menu_model_t* model, + struct _cef_run_context_menu_callback_t* callback); + + /// + /// Called to execute a command selected from the context menu. Return true + /// (1) if the command was handled or false (0) for the default + /// implementation. See cef_menu_id_t for the command ids that have default + /// implementations. All user-defined command ids should be between + /// MENU_ID_USER_FIRST and MENU_ID_USER_LAST. |params| will have the same + /// values as what was passed to on_before_context_menu(). Do not keep a + /// reference to |params| outside of this callback. + /// + int(CEF_CALLBACK* on_context_menu_command)( + struct _cef_context_menu_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_context_menu_params_t* params, + int command_id, + cef_event_flags_t event_flags); + + /// + /// Called when the context menu is dismissed irregardless of whether the menu + /// was canceled or a command was selected. + /// + void(CEF_CALLBACK* on_context_menu_dismissed)( + struct _cef_context_menu_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame); + + /// + /// Called to allow custom display of the quick menu for a windowless browser. + /// |location| is the top left corner of the selected region. |size| is the + /// size of the selected region. |edit_state_flags| is a combination of flags + /// that represent the state of the quick menu. Return true (1) if the menu + /// will be handled and execute |callback| either synchronously or + /// asynchronously with the selected command ID. Return false (0) to cancel + /// the menu. + /// + int(CEF_CALLBACK* run_quick_menu)( + struct _cef_context_menu_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + const cef_point_t* location, + const cef_size_t* size, + cef_quick_menu_edit_state_flags_t edit_state_flags, + struct _cef_run_quick_menu_callback_t* callback); + + /// + /// Called to execute a command selected from the quick menu for a windowless + /// browser. Return true (1) if the command was handled or false (0) for the + /// default implementation. See cef_menu_id_t for command IDs that have + /// default implementations. + /// + int(CEF_CALLBACK* on_quick_menu_command)( + struct _cef_context_menu_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + int command_id, + cef_event_flags_t event_flags); + + /// + /// Called when the quick menu for a windowless browser is dismissed + /// irregardless of whether the menu was canceled or a command was selected. + /// + void(CEF_CALLBACK* on_quick_menu_dismissed)( + struct _cef_context_menu_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame); +} cef_context_menu_handler_t; + +/// +/// Provides information about the context menu state. The functions of this +/// structure can only be accessed on browser process the UI thread. +/// +typedef struct _cef_context_menu_params_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the X coordinate of the mouse where the context menu was invoked. + /// Coords are relative to the associated RenderView's origin. + /// + int(CEF_CALLBACK* get_xcoord)(struct _cef_context_menu_params_t* self); + + /// + /// Returns the Y coordinate of the mouse where the context menu was invoked. + /// Coords are relative to the associated RenderView's origin. + /// + int(CEF_CALLBACK* get_ycoord)(struct _cef_context_menu_params_t* self); + + /// + /// Returns flags representing the type of node that the context menu was + /// invoked on. + /// + cef_context_menu_type_flags_t(CEF_CALLBACK* get_type_flags)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the URL of the link, if any, that encloses the node that the + /// context menu was invoked on. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_link_url)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the link URL, if any, to be used ONLY for "copy link address". We + /// don't validate this field in the frontend process. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_unfiltered_link_url)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the source URL, if any, for the element that the context menu was + /// invoked on. Example of elements with source URLs are img, audio, and + /// video. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_source_url)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns true (1) if the context menu was invoked on an image which has + /// non-NULL contents. + /// + int(CEF_CALLBACK* has_image_contents)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the title text or the alt text if the context menu was invoked on + /// an image. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_title_text)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the URL of the top level page that the context menu was invoked + /// on. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_page_url)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the URL of the subframe that the context menu was invoked on. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_frame_url)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the character encoding of the subframe that the context menu was + /// invoked on. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_frame_charset)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the type of context node that the context menu was invoked on. + /// + cef_context_menu_media_type_t(CEF_CALLBACK* get_media_type)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns flags representing the actions supported by the media element, if + /// any, that the context menu was invoked on. + /// + cef_context_menu_media_state_flags_t(CEF_CALLBACK* get_media_state_flags)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the text of the selection, if any, that the context menu was + /// invoked on. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_selection_text)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns the text of the misspelled word, if any, that the context menu was + /// invoked on. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_misspelled_word)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns true (1) if suggestions exist, false (0) otherwise. Fills in + /// |suggestions| from the spell check service for the misspelled word if + /// there is one. + /// + int(CEF_CALLBACK* get_dictionary_suggestions)( + struct _cef_context_menu_params_t* self, + cef_string_list_t suggestions); + + /// + /// Returns true (1) if the context menu was invoked on an editable node. + /// + int(CEF_CALLBACK* is_editable)(struct _cef_context_menu_params_t* self); + + /// + /// Returns true (1) if the context menu was invoked on an editable node where + /// spell-check is enabled. + /// + int(CEF_CALLBACK* is_spell_check_enabled)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns flags representing the actions supported by the editable node, if + /// any, that the context menu was invoked on. + /// + cef_context_menu_edit_state_flags_t(CEF_CALLBACK* get_edit_state_flags)( + struct _cef_context_menu_params_t* self); + + /// + /// Returns true (1) if the context menu contains items specified by the + /// renderer process. + /// + int(CEF_CALLBACK* is_custom_menu)(struct _cef_context_menu_params_t* self); +} cef_context_menu_params_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_ diff --git a/include/capi/cef_cookie_capi.h b/include/capi/cef_cookie_capi.h new file mode 100644 index 00000000..1be978bf --- /dev/null +++ b/include/capi/cef_cookie_capi.h @@ -0,0 +1,199 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=598c6f530b2e2553197d8c6a72ad9e2bf72b5443$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_callback_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_cookie_visitor_t; +struct _cef_delete_cookies_callback_t; +struct _cef_set_cookie_callback_t; + +/// +/// Structure used for managing cookies. The functions of this structure may be +/// called on any thread unless otherwise indicated. +/// +typedef struct _cef_cookie_manager_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Visit all cookies on the UI thread. The returned cookies are ordered by + /// longest path, then by earliest creation date. Returns false (0) if cookies + /// cannot be accessed. + /// + int(CEF_CALLBACK* visit_all_cookies)(struct _cef_cookie_manager_t* self, + struct _cef_cookie_visitor_t* visitor); + + /// + /// Visit a subset of cookies on the UI thread. The results are filtered by + /// the given url scheme, host, domain and path. If |includeHttpOnly| is true + /// (1) HTTP-only cookies will also be included in the results. The returned + /// cookies are ordered by longest path, then by earliest creation date. + /// Returns false (0) if cookies cannot be accessed. + /// + int(CEF_CALLBACK* visit_url_cookies)(struct _cef_cookie_manager_t* self, + const cef_string_t* url, + int includeHttpOnly, + struct _cef_cookie_visitor_t* visitor); + + /// + /// Sets a cookie given a valid URL and explicit user-provided cookie + /// attributes. This function expects each attribute to be well-formed. It + /// will check for disallowed characters (e.g. the ';' character is disallowed + /// within the cookie value attribute) and fail without setting the cookie if + /// such characters are found. If |callback| is non-NULL it will be executed + /// asnychronously on the UI thread after the cookie has been set. Returns + /// false (0) if an invalid URL is specified or if cookies cannot be accessed. + /// + int(CEF_CALLBACK* set_cookie)(struct _cef_cookie_manager_t* self, + const cef_string_t* url, + const struct _cef_cookie_t* cookie, + struct _cef_set_cookie_callback_t* callback); + + /// + /// Delete all cookies that match the specified parameters. If both |url| and + /// |cookie_name| values are specified all host and domain cookies matching + /// both will be deleted. If only |url| is specified all host cookies (but not + /// domain cookies) irrespective of path will be deleted. If |url| is NULL all + /// cookies for all hosts and domains will be deleted. If |callback| is non- + /// NULL it will be executed asnychronously on the UI thread after the cookies + /// have been deleted. Returns false (0) if a non-NULL invalid URL is + /// specified or if cookies cannot be accessed. Cookies can alternately be + /// deleted using the Visit*Cookies() functions. + /// + int(CEF_CALLBACK* delete_cookies)( + struct _cef_cookie_manager_t* self, + const cef_string_t* url, + const cef_string_t* cookie_name, + struct _cef_delete_cookies_callback_t* callback); + + /// + /// Flush the backing store (if any) to disk. If |callback| is non-NULL it + /// will be executed asnychronously on the UI thread after the flush is + /// complete. Returns false (0) if cookies cannot be accessed. + /// + int(CEF_CALLBACK* flush_store)(struct _cef_cookie_manager_t* self, + struct _cef_completion_callback_t* callback); +} cef_cookie_manager_t; + +/// +/// Returns the global cookie manager. By default data will be stored at +/// cef_settings_t.cache_path if specified or in memory otherwise. If |callback| +/// is non-NULL it will be executed asnychronously on the UI thread after the +/// manager's storage has been initialized. Using this function is equivalent to +/// calling cef_request_context_t::cef_request_context_get_global_context()->Get +/// DefaultCookieManager(). +/// +CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager( + struct _cef_completion_callback_t* callback); + +/// +/// Structure to implement for visiting cookie values. The functions of this +/// structure will always be called on the UI thread. +/// +typedef struct _cef_cookie_visitor_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be called once for each cookie. |count| is the 0-based + /// index for the current cookie. |total| is the total number of cookies. Set + /// |deleteCookie| to true (1) to delete the cookie currently being visited. + /// Return false (0) to stop visiting cookies. This function may never be + /// called if no cookies are found. + /// + int(CEF_CALLBACK* visit)(struct _cef_cookie_visitor_t* self, + const struct _cef_cookie_t* cookie, + int count, + int total, + int* deleteCookie); +} cef_cookie_visitor_t; + +/// +/// Structure to implement to be notified of asynchronous completion via +/// cef_cookie_manager_t::set_cookie(). +/// +typedef struct _cef_set_cookie_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be called upon completion. |success| will be true (1) if + /// the cookie was set successfully. + /// + void(CEF_CALLBACK* on_complete)(struct _cef_set_cookie_callback_t* self, + int success); +} cef_set_cookie_callback_t; + +/// +/// Structure to implement to be notified of asynchronous completion via +/// cef_cookie_manager_t::delete_cookies(). +/// +typedef struct _cef_delete_cookies_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be called upon completion. |num_deleted| will be the + /// number of cookies that were deleted. + /// + void(CEF_CALLBACK* on_complete)(struct _cef_delete_cookies_callback_t* self, + int num_deleted); +} cef_delete_cookies_callback_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_ diff --git a/include/capi/cef_crash_util_capi.h b/include/capi/cef_crash_util_capi.h new file mode 100644 index 00000000..f6272ab0 --- /dev/null +++ b/include/capi/cef_crash_util_capi.h @@ -0,0 +1,154 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=5c6e0b9e37b8103a182f200fccdf5973104fcd70$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Crash reporting is configured using an INI-style config file named +/// "crash_reporter.cfg". On Windows and Linux this file must be placed next to +/// the main application executable. On macOS this file must be placed in the +/// top-level app bundle Resources directory (e.g. +/// "<appname>.app/Contents/Resources"). File contents are as follows: +/// +/// <pre> +/// # Comments start with a hash character and must be on their own line. +/// +/// [Config] +/// ProductName=<Value of the "prod" crash key; defaults to "cef"> +/// ProductVersion=<Value of the "ver" crash key; defaults to the CEF version> +/// AppName=<Windows only; App-specific folder name component for storing crash +/// information; default to "CEF"> +/// ExternalHandler=<Windows only; Name of the external handler exe to use +/// instead of re-launching the main exe; default to empty> +/// BrowserCrashForwardingEnabled=<macOS only; True if browser process crashes +/// should be forwarded to the system crash +/// reporter; default to false> +/// ServerURL=<crash server URL; default to empty> +/// RateLimitEnabled=<True if uploads should be rate limited; default to true> +/// MaxUploadsPerDay=<Max uploads per 24 hours, used if rate limit is enabled; +/// default to 5> +/// MaxDatabaseSizeInMb=<Total crash report disk usage greater than this value +/// will cause older reports to be deleted; default to 20> +/// MaxDatabaseAgeInDays=<Crash reports older than this value will be deleted; +/// default to 5> +/// +/// [CrashKeys] +/// my_key1=<small|medium|large> +/// my_key2=<small|medium|large> +/// </pre> +/// +/// <b>Config section:</b> +/// +/// If "ProductName" and/or "ProductVersion" are set then the specified values +/// will be included in the crash dump metadata. On macOS if these values are +/// set to NULL then they will be retrieved from the Info.plist file using the +/// "CFBundleName" and "CFBundleShortVersionString" keys respectively. +/// +/// If "AppName" is set on Windows then crash report information (metrics, +/// database and dumps) will be stored locally on disk under the +/// "C:\Users\[CurrentUser]\AppData\Local\[AppName]\User Data" folder. On other +/// platforms the cef_settings_t.user_data_path value will be used. +/// +/// If "ExternalHandler" is set on Windows then the specified exe will be +/// launched as the crashpad-handler instead of re-launching the main process +/// exe. The value can be an absolute path or a path relative to the main exe +/// directory. On Linux the cef_settings_t.browser_subprocess_path value will be +/// used. On macOS the existing subprocess app bundle will be used. +/// +/// If "BrowserCrashForwardingEnabled" is set to true (1) on macOS then browser +/// process crashes will be forwarded to the system crash reporter. This results +/// in the crash UI dialog being displayed to the user and crash reports being +/// logged under "~/Library/Logs/DiagnosticReports". Forwarding of crash reports +/// from non-browser processes and Debug builds is always disabled. +/// +/// If "ServerURL" is set then crashes will be uploaded as a multi-part POST +/// request to the specified URL. Otherwise, reports will only be stored locally +/// on disk. +/// +/// If "RateLimitEnabled" is set to true (1) then crash report uploads will be +/// rate limited as follows: +/// 1. If "MaxUploadsPerDay" is set to a positive value then at most the +/// specified number of crashes will be uploaded in each 24 hour period. +/// 2. If crash upload fails due to a network or server error then an +/// incremental backoff delay up to a maximum of 24 hours will be applied +/// for retries. +/// 3. If a backoff delay is applied and "MaxUploadsPerDay" is > 1 then the +/// "MaxUploadsPerDay" value will be reduced to 1 until the client is +/// restarted. This helps to avoid an upload flood when the network or +/// server error is resolved. +/// Rate limiting is not supported on Linux. +/// +/// If "MaxDatabaseSizeInMb" is set to a positive value then crash report +/// storage on disk will be limited to that size in megabytes. For example, on +/// Windows each dump is about 600KB so a "MaxDatabaseSizeInMb" value of 20 +/// equates to about 34 crash reports stored on disk. Not supported on Linux. +/// +/// If "MaxDatabaseAgeInDays" is set to a positive value then crash reports +/// older than the specified age in days will be deleted. Not supported on +/// Linux. +/// +/// <b>CrashKeys section:</b> +/// +/// A maximum of 26 crash keys of each size can be specified for use by the +/// application. Crash key values will be truncated based on the specified size +/// (small = 64 bytes, medium = 256 bytes, large = 1024 bytes). The value of +/// crash keys can be set from any thread or process using the +/// CefSetCrashKeyValue function. These key/value pairs will be sent to the +/// crash server along with the crash dump file. +/// +CEF_EXPORT int cef_crash_reporting_enabled(void); + +/// +/// Sets or clears a specific key-value pair from the crash metadata. +/// +CEF_EXPORT void cef_set_crash_key_value(const cef_string_t* key, + const cef_string_t* value); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_ diff --git a/include/capi/cef_devtools_message_observer_capi.h b/include/capi/cef_devtools_message_observer_capi.h new file mode 100644 index 00000000..ee61835f --- /dev/null +++ b/include/capi/cef_devtools_message_observer_capi.h @@ -0,0 +1,148 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=777485120b9a9df0f890579ee698d33f273819c5$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_browser_t; + +/// +/// Callback structure for cef_browser_host_t::AddDevToolsMessageObserver. The +/// functions of this structure will be called on the browser process UI thread. +/// +typedef struct _cef_dev_tools_message_observer_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be called on receipt of a DevTools protocol message. + /// |browser| is the originating browser instance. |message| is a UTF8-encoded + /// JSON dictionary representing either a function result or an event. + /// |message| is only valid for the scope of this callback and should be + /// copied if necessary. Return true (1) if the message was handled or false + /// (0) if the message should be further processed and passed to the + /// OnDevToolsMethodResult or OnDevToolsEvent functions as appropriate. + /// + /// Method result dictionaries include an "id" (int) value that identifies the + /// orginating function call sent from + /// cef_browser_host_t::SendDevToolsMessage, and optionally either a "result" + /// (dictionary) or "error" (dictionary) value. The "error" dictionary will + /// contain "code" (int) and "message" (string) values. Event dictionaries + /// include a "function" (string) value and optionally a "params" (dictionary) + /// value. See the DevTools protocol documentation at + /// https://chromedevtools.github.io/devtools-protocol/ for details of + /// supported function calls and the expected "result" or "params" dictionary + /// contents. JSON dictionaries can be parsed using the CefParseJSON function + /// if desired, however be aware of performance considerations when parsing + /// large messages (some of which may exceed 1MB in size). + /// + int(CEF_CALLBACK* on_dev_tools_message)( + struct _cef_dev_tools_message_observer_t* self, + struct _cef_browser_t* browser, + const void* message, + size_t message_size); + + /// + /// Method that will be called after attempted execution of a DevTools + /// protocol function. |browser| is the originating browser instance. + /// |message_id| is the "id" value that identifies the originating function + /// call message. If the function succeeded |success| will be true (1) and + /// |result| will be the UTF8-encoded JSON "result" dictionary value (which + /// may be NULL). If the function failed |success| will be false (0) and + /// |result| will be the UTF8-encoded JSON "error" dictionary value. |result| + /// is only valid for the scope of this callback and should be copied if + /// necessary. See the OnDevToolsMessage documentation for additional details + /// on |result| contents. + /// + void(CEF_CALLBACK* on_dev_tools_method_result)( + struct _cef_dev_tools_message_observer_t* self, + struct _cef_browser_t* browser, + int message_id, + int success, + const void* result, + size_t result_size); + + /// + /// Method that will be called on receipt of a DevTools protocol event. + /// |browser| is the originating browser instance. |function| is the + /// "function" value. |params| is the UTF8-encoded JSON "params" dictionary + /// value (which may be NULL). |params| is only valid for the scope of this + /// callback and should be copied if necessary. See the OnDevToolsMessage + /// documentation for additional details on |params| contents. + /// + void(CEF_CALLBACK* on_dev_tools_event)( + struct _cef_dev_tools_message_observer_t* self, + struct _cef_browser_t* browser, + const cef_string_t* method, + const void* params, + size_t params_size); + + /// + /// Method that will be called when the DevTools agent has attached. |browser| + /// is the originating browser instance. This will generally occur in response + /// to the first message sent while the agent is detached. + /// + void(CEF_CALLBACK* on_dev_tools_agent_attached)( + struct _cef_dev_tools_message_observer_t* self, + struct _cef_browser_t* browser); + + /// + /// Method that will be called when the DevTools agent has detached. |browser| + /// is the originating browser instance. Any function results that were + /// pending before the agent became detached will not be delivered, and any + /// active event subscriptions will be canceled. + /// + void(CEF_CALLBACK* on_dev_tools_agent_detached)( + struct _cef_dev_tools_message_observer_t* self, + struct _cef_browser_t* browser); +} cef_dev_tools_message_observer_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_ diff --git a/include/capi/cef_dialog_handler_capi.h b/include/capi/cef_dialog_handler_capi.h new file mode 100644 index 00000000..82281ad9 --- /dev/null +++ b/include/capi/cef_dialog_handler_capi.h @@ -0,0 +1,111 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=69545645f079f4593d9cbb6d8a36535c209245f7$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Callback structure for asynchronous continuation of file dialog requests. +/// +typedef struct _cef_file_dialog_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Continue the file selection. |file_paths| should be a single value or a + /// list of values depending on the dialog mode. An NULL |file_paths| value is + /// treated the same as calling cancel(). + /// + void(CEF_CALLBACK* cont)(struct _cef_file_dialog_callback_t* self, + cef_string_list_t file_paths); + + /// + /// Cancel the file selection. + /// + void(CEF_CALLBACK* cancel)(struct _cef_file_dialog_callback_t* self); +} cef_file_dialog_callback_t; + +/// +/// Implement this structure to handle dialog events. The functions of this +/// structure will be called on the browser process UI thread. +/// +typedef struct _cef_dialog_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called to run a file chooser dialog. |mode| represents the type of dialog + /// to display. |title| to the title to be used for the dialog and may be NULL + /// to show the default title ("Open" or "Save" depending on the mode). + /// |default_file_path| is the path with optional directory and/or file name + /// component that should be initially selected in the dialog. + /// |accept_filters| are used to restrict the selectable file types and may + /// any combination of (a) valid lower-cased MIME types (e.g. "text/*" or + /// "image/*"), (b) individual file extensions (e.g. ".txt" or ".png"), or (c) + /// combined description and file extension delimited using "|" and ";" (e.g. + /// "Image Types|.png;.gif;.jpg"). To display a custom dialog return true (1) + /// and execute |callback| either inline or at a later time. To display the + /// default dialog return false (0). + /// + int(CEF_CALLBACK* on_file_dialog)( + struct _cef_dialog_handler_t* self, + struct _cef_browser_t* browser, + cef_file_dialog_mode_t mode, + const cef_string_t* title, + const cef_string_t* default_file_path, + cef_string_list_t accept_filters, + struct _cef_file_dialog_callback_t* callback); +} cef_dialog_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_ diff --git a/include/capi/cef_display_handler_capi.h b/include/capi/cef_display_handler_capi.h new file mode 100644 index 00000000..b93421de --- /dev/null +++ b/include/capi/cef_display_handler_capi.h @@ -0,0 +1,173 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=1de3354bd0a042cc28199f1f56753b1df9e279a2$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_frame_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events related to browser display state. +/// The functions of this structure will be called on the UI thread. +/// +typedef struct _cef_display_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when a frame's address has changed. + /// + void(CEF_CALLBACK* on_address_change)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + const cef_string_t* url); + + /// + /// Called when the page title changes. + /// + void(CEF_CALLBACK* on_title_change)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* title); + + /// + /// Called when the page icon changes. + /// + void(CEF_CALLBACK* on_favicon_urlchange)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + cef_string_list_t icon_urls); + + /// + /// Called when web content in the page has toggled fullscreen mode. If + /// |fullscreen| is true (1) the content will automatically be sized to fill + /// the browser content area. If |fullscreen| is false (0) the content will + /// automatically return to its original size and position. The client is + /// responsible for resizing the browser if desired. + /// + void(CEF_CALLBACK* on_fullscreen_mode_change)( + struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + int fullscreen); + + /// + /// Called when the browser is about to display a tooltip. |text| contains the + /// text that will be displayed in the tooltip. To handle the display of the + /// tooltip yourself return true (1). Otherwise, you can optionally modify + /// |text| and then return false (0) to allow the browser to display the + /// tooltip. When window rendering is disabled the application is responsible + /// for drawing tooltips and the return value is ignored. + /// + int(CEF_CALLBACK* on_tooltip)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + cef_string_t* text); + + /// + /// Called when the browser receives a status message. |value| contains the + /// text that will be displayed in the status message. + /// + void(CEF_CALLBACK* on_status_message)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* value); + + /// + /// Called to display a console message. Return true (1) to stop the message + /// from being output to the console. + /// + int(CEF_CALLBACK* on_console_message)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + cef_log_severity_t level, + const cef_string_t* message, + const cef_string_t* source, + int line); + + /// + /// Called when auto-resize is enabled via + /// cef_browser_host_t::SetAutoResizeEnabled and the contents have auto- + /// resized. |new_size| will be the desired size in view coordinates. Return + /// true (1) if the resize was handled or false (0) for default handling. + /// + int(CEF_CALLBACK* on_auto_resize)(struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + const cef_size_t* new_size); + + /// + /// Called when the overall page loading progress has changed. |progress| + /// ranges from 0.0 to 1.0. + /// + void(CEF_CALLBACK* on_loading_progress_change)( + struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + double progress); + + /// + /// Called when the browser's cursor has changed. If |type| is CT_CUSTOM then + /// |custom_cursor_info| will be populated with the custom cursor information. + /// Return true (1) if the cursor change was handled or false (0) for default + /// handling. + /// + int(CEF_CALLBACK* on_cursor_change)( + struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + cef_cursor_handle_t cursor, + cef_cursor_type_t type, + const cef_cursor_info_t* custom_cursor_info); + + /// + /// Called when the browser's access to an audio and/or video source has + /// changed. + /// + void(CEF_CALLBACK* on_media_access_change)( + struct _cef_display_handler_t* self, + struct _cef_browser_t* browser, + int has_video_access, + int has_audio_access); +} cef_display_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_ diff --git a/include/capi/cef_dom_capi.h b/include/capi/cef_dom_capi.h new file mode 100644 index 00000000..c895e3b7 --- /dev/null +++ b/include/capi/cef_dom_capi.h @@ -0,0 +1,346 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=d703b8af664ed9dfac8ad935616ef43fafc062e2$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_domdocument_t; +struct _cef_domnode_t; + +/// +/// Structure to implement for visiting the DOM. The functions of this structure +/// will be called on the render process main thread. +/// +typedef struct _cef_domvisitor_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method executed for visiting the DOM. The document object passed to this + /// function represents a snapshot of the DOM at the time this function is + /// executed. DOM objects are only valid for the scope of this function. Do + /// not keep references to or attempt to access any DOM objects outside the + /// scope of this function. + /// + void(CEF_CALLBACK* visit)(struct _cef_domvisitor_t* self, + struct _cef_domdocument_t* document); +} cef_domvisitor_t; + +/// +/// Structure used to represent a DOM document. The functions of this structure +/// should only be called on the render process main thread thread. +/// +typedef struct _cef_domdocument_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the document type. + /// + cef_dom_document_type_t(CEF_CALLBACK* get_type)( + struct _cef_domdocument_t* self); + + /// + /// Returns the root document node. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_document)( + struct _cef_domdocument_t* self); + + /// + /// Returns the BODY node of an HTML document. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_body)( + struct _cef_domdocument_t* self); + + /// + /// Returns the HEAD node of an HTML document. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_head)( + struct _cef_domdocument_t* self); + + /// + /// Returns the title of an HTML document. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_title)( + struct _cef_domdocument_t* self); + + /// + /// Returns the document element with the specified ID value. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_element_by_id)( + struct _cef_domdocument_t* self, + const cef_string_t* id); + + /// + /// Returns the node that currently has keyboard focus. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_focused_node)( + struct _cef_domdocument_t* self); + + /// + /// Returns true (1) if a portion of the document is selected. + /// + int(CEF_CALLBACK* has_selection)(struct _cef_domdocument_t* self); + + /// + /// Returns the selection offset within the start node. + /// + int(CEF_CALLBACK* get_selection_start_offset)( + struct _cef_domdocument_t* self); + + /// + /// Returns the selection offset within the end node. + /// + int(CEF_CALLBACK* get_selection_end_offset)(struct _cef_domdocument_t* self); + + /// + /// Returns the contents of this selection as markup. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_selection_as_markup)( + struct _cef_domdocument_t* self); + + /// + /// Returns the contents of this selection as text. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_selection_as_text)( + struct _cef_domdocument_t* self); + + /// + /// Returns the base URL for the document. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_base_url)( + struct _cef_domdocument_t* self); + + /// + /// Returns a complete URL based on the document base URL and the specified + /// partial URL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_complete_url)( + struct _cef_domdocument_t* self, + const cef_string_t* partialURL); +} cef_domdocument_t; + +/// +/// Structure used to represent a DOM node. The functions of this structure +/// should only be called on the render process main thread. +/// +typedef struct _cef_domnode_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the type for this node. + /// + cef_dom_node_type_t(CEF_CALLBACK* get_type)(struct _cef_domnode_t* self); + + /// + /// Returns true (1) if this is a text node. + /// + int(CEF_CALLBACK* is_text)(struct _cef_domnode_t* self); + + /// + /// Returns true (1) if this is an element node. + /// + int(CEF_CALLBACK* is_element)(struct _cef_domnode_t* self); + + /// + /// Returns true (1) if this is an editable node. + /// + int(CEF_CALLBACK* is_editable)(struct _cef_domnode_t* self); + + /// + /// Returns true (1) if this is a form control element node. + /// + int(CEF_CALLBACK* is_form_control_element)(struct _cef_domnode_t* self); + + /// + /// Returns the type of this form control element node. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_form_control_element_type)( + struct _cef_domnode_t* self); + + /// + /// Returns true (1) if this object is pointing to the same handle as |that| + /// object. + /// + int(CEF_CALLBACK* is_same)(struct _cef_domnode_t* self, + struct _cef_domnode_t* that); + + /// + /// Returns the name of this node. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_name)(struct _cef_domnode_t* self); + + /// + /// Returns the value of this node. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_value)(struct _cef_domnode_t* self); + + /// + /// Set the value of this node. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_value)(struct _cef_domnode_t* self, + const cef_string_t* value); + + /// + /// Returns the contents of this node as markup. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_as_markup)( + struct _cef_domnode_t* self); + + /// + /// Returns the document associated with this node. + /// + struct _cef_domdocument_t*(CEF_CALLBACK* get_document)( + struct _cef_domnode_t* self); + + /// + /// Returns the parent node. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_parent)(struct _cef_domnode_t* self); + + /// + /// Returns the previous sibling node. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_previous_sibling)( + struct _cef_domnode_t* self); + + /// + /// Returns the next sibling node. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_next_sibling)( + struct _cef_domnode_t* self); + + /// + /// Returns true (1) if this node has child nodes. + /// + int(CEF_CALLBACK* has_children)(struct _cef_domnode_t* self); + + /// + /// Return the first child node. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_first_child)( + struct _cef_domnode_t* self); + + /// + /// Returns the last child node. + /// + struct _cef_domnode_t*(CEF_CALLBACK* get_last_child)( + struct _cef_domnode_t* self); + + /// + /// Returns the tag name of this element. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_element_tag_name)( + struct _cef_domnode_t* self); + + /// + /// Returns true (1) if this element has attributes. + /// + int(CEF_CALLBACK* has_element_attributes)(struct _cef_domnode_t* self); + + /// + /// Returns true (1) if this element has an attribute named |attrName|. + /// + int(CEF_CALLBACK* has_element_attribute)(struct _cef_domnode_t* self, + const cef_string_t* attrName); + + /// + /// Returns the element attribute named |attrName|. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_element_attribute)( + struct _cef_domnode_t* self, + const cef_string_t* attrName); + + /// + /// Returns a map of all element attributes. + /// + void(CEF_CALLBACK* get_element_attributes)(struct _cef_domnode_t* self, + cef_string_map_t attrMap); + + /// + /// Set the value for the element attribute named |attrName|. Returns true (1) + /// on success. + /// + int(CEF_CALLBACK* set_element_attribute)(struct _cef_domnode_t* self, + const cef_string_t* attrName, + const cef_string_t* value); + + /// + /// Returns the inner text of the element. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_element_inner_text)( + struct _cef_domnode_t* self); + + /// + /// Returns the bounds of the element in device pixels. Use + /// "window.devicePixelRatio" to convert to/from CSS pixels. + /// + cef_rect_t(CEF_CALLBACK* get_element_bounds)(struct _cef_domnode_t* self); +} cef_domnode_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_ diff --git a/include/capi/cef_download_handler_capi.h b/include/capi/cef_download_handler_capi.h new file mode 100644 index 00000000..59795134 --- /dev/null +++ b/include/capi/cef_download_handler_capi.h @@ -0,0 +1,150 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=f1f6a110a7ce15611a7062b3d7fe8b5c630f2980$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_download_item_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Callback structure used to asynchronously continue a download. +/// +typedef struct _cef_before_download_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Call to continue the download. Set |download_path| to the full file path + /// for the download including the file name or leave blank to use the + /// suggested name and the default temp directory. Set |show_dialog| to true + /// (1) if you do wish to show the default "Save As" dialog. + /// + void(CEF_CALLBACK* cont)(struct _cef_before_download_callback_t* self, + const cef_string_t* download_path, + int show_dialog); +} cef_before_download_callback_t; + +/// +/// Callback structure used to asynchronously cancel a download. +/// +typedef struct _cef_download_item_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Call to cancel the download. + /// + void(CEF_CALLBACK* cancel)(struct _cef_download_item_callback_t* self); + + /// + /// Call to pause the download. + /// + void(CEF_CALLBACK* pause)(struct _cef_download_item_callback_t* self); + + /// + /// Call to resume the download. + /// + void(CEF_CALLBACK* resume)(struct _cef_download_item_callback_t* self); +} cef_download_item_callback_t; + +/// +/// Structure used to handle file downloads. The functions of this structure +/// will called on the browser process UI thread. +/// +typedef struct _cef_download_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called before a download begins in response to a user-initiated action + /// (e.g. alt + link click or link click that returns a `Content-Disposition: + /// attachment` response from the server). |url| is the target download URL + /// and |request_function| is the target function (GET, POST, etc). Return + /// true (1) to proceed with the download or false (0) to cancel the download. + /// + int(CEF_CALLBACK* can_download)(struct _cef_download_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* url, + const cef_string_t* request_method); + + /// + /// Called before a download begins. |suggested_name| is the suggested name + /// for the download file. By default the download will be canceled. Execute + /// |callback| either asynchronously or in this function to continue the + /// download if desired. Do not keep a reference to |download_item| outside of + /// this function. + /// + void(CEF_CALLBACK* on_before_download)( + struct _cef_download_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_download_item_t* download_item, + const cef_string_t* suggested_name, + struct _cef_before_download_callback_t* callback); + + /// + /// Called when a download's status or progress information has been updated. + /// This may be called multiple times before and after on_before_download(). + /// Execute |callback| either asynchronously or in this function to cancel the + /// download if desired. Do not keep a reference to |download_item| outside of + /// this function. + /// + void(CEF_CALLBACK* on_download_updated)( + struct _cef_download_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_download_item_t* download_item, + struct _cef_download_item_callback_t* callback); +} cef_download_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_ diff --git a/include/capi/cef_download_item_capi.h b/include/capi/cef_download_item_capi.h new file mode 100644 index 00000000..d6986eb0 --- /dev/null +++ b/include/capi/cef_download_item_capi.h @@ -0,0 +1,163 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=332b9cb62b9c85573dc705aba4c9db3b34177e20$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used to represent a download item. +/// +typedef struct _cef_download_item_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. Do not call any other functions + /// if this function returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_download_item_t* self); + + /// + /// Returns true (1) if the download is in progress. + /// + int(CEF_CALLBACK* is_in_progress)(struct _cef_download_item_t* self); + + /// + /// Returns true (1) if the download is complete. + /// + int(CEF_CALLBACK* is_complete)(struct _cef_download_item_t* self); + + /// + /// Returns true (1) if the download has been canceled or interrupted. + /// + int(CEF_CALLBACK* is_canceled)(struct _cef_download_item_t* self); + + /// + /// Returns a simple speed estimate in bytes/s. + /// + int64(CEF_CALLBACK* get_current_speed)(struct _cef_download_item_t* self); + + /// + /// Returns the rough percent complete or -1 if the receive total size is + /// unknown. + /// + int(CEF_CALLBACK* get_percent_complete)(struct _cef_download_item_t* self); + + /// + /// Returns the total number of bytes. + /// + int64(CEF_CALLBACK* get_total_bytes)(struct _cef_download_item_t* self); + + /// + /// Returns the number of received bytes. + /// + int64(CEF_CALLBACK* get_received_bytes)(struct _cef_download_item_t* self); + + /// + /// Returns the time that the download started. + /// + cef_basetime_t(CEF_CALLBACK* get_start_time)( + struct _cef_download_item_t* self); + + /// + /// Returns the time that the download ended. + /// + cef_basetime_t(CEF_CALLBACK* get_end_time)(struct _cef_download_item_t* self); + + /// + /// Returns the full path to the downloaded or downloading file. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_full_path)( + struct _cef_download_item_t* self); + + /// + /// Returns the unique identifier for this download. + /// + uint32(CEF_CALLBACK* get_id)(struct _cef_download_item_t* self); + + /// + /// Returns the URL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_url)( + struct _cef_download_item_t* self); + + /// + /// Returns the original URL before any redirections. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_original_url)( + struct _cef_download_item_t* self); + + /// + /// Returns the suggested file name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_suggested_file_name)( + struct _cef_download_item_t* self); + + /// + /// Returns the content disposition. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_content_disposition)( + struct _cef_download_item_t* self); + + /// + /// Returns the mime type. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_mime_type)( + struct _cef_download_item_t* self); +} cef_download_item_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_ diff --git a/include/capi/cef_drag_data_capi.h b/include/capi/cef_drag_data_capi.h new file mode 100644 index 00000000..32eed2fe --- /dev/null +++ b/include/capi/cef_drag_data_capi.h @@ -0,0 +1,233 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=a1ce746f0dd97d21973d4c80d8ef46391c0fd463$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_image_capi.h" +#include "include/capi/cef_stream_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used to represent drag data. The functions of this structure may +/// be called on any thread. +/// +typedef struct _cef_drag_data_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns a copy of the current object. + /// + struct _cef_drag_data_t*(CEF_CALLBACK* clone)(struct _cef_drag_data_t* self); + + /// + /// Returns true (1) if this object is read-only. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_drag_data_t* self); + + /// + /// Returns true (1) if the drag data is a link. + /// + int(CEF_CALLBACK* is_link)(struct _cef_drag_data_t* self); + + /// + /// Returns true (1) if the drag data is a text or html fragment. + /// + int(CEF_CALLBACK* is_fragment)(struct _cef_drag_data_t* self); + + /// + /// Returns true (1) if the drag data is a file. + /// + int(CEF_CALLBACK* is_file)(struct _cef_drag_data_t* self); + + /// + /// Return the link URL that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_link_url)( + struct _cef_drag_data_t* self); + + /// + /// Return the title associated with the link being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_link_title)( + struct _cef_drag_data_t* self); + + /// + /// Return the metadata, if any, associated with the link being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_link_metadata)( + struct _cef_drag_data_t* self); + + /// + /// Return the plain text fragment that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_fragment_text)( + struct _cef_drag_data_t* self); + + /// + /// Return the text/html fragment that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_fragment_html)( + struct _cef_drag_data_t* self); + + /// + /// Return the base URL that the fragment came from. This value is used for + /// resolving relative URLs and may be NULL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_fragment_base_url)( + struct _cef_drag_data_t* self); + + /// + /// Return the name of the file being dragged out of the browser window. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_file_name)( + struct _cef_drag_data_t* self); + + /// + /// Write the contents of the file being dragged out of the web view into + /// |writer|. Returns the number of bytes sent to |writer|. If |writer| is + /// NULL this function will return the size of the file contents in bytes. + /// Call get_file_name() to get a suggested name for the file. + /// + size_t(CEF_CALLBACK* get_file_contents)(struct _cef_drag_data_t* self, + struct _cef_stream_writer_t* writer); + + /// + /// Retrieve the list of file names that are being dragged into the browser + /// window. + /// + int(CEF_CALLBACK* get_file_names)(struct _cef_drag_data_t* self, + cef_string_list_t names); + + /// + /// Set the link URL that is being dragged. + /// + void(CEF_CALLBACK* set_link_url)(struct _cef_drag_data_t* self, + const cef_string_t* url); + + /// + /// Set the title associated with the link being dragged. + /// + void(CEF_CALLBACK* set_link_title)(struct _cef_drag_data_t* self, + const cef_string_t* title); + + /// + /// Set the metadata associated with the link being dragged. + /// + void(CEF_CALLBACK* set_link_metadata)(struct _cef_drag_data_t* self, + const cef_string_t* data); + + /// + /// Set the plain text fragment that is being dragged. + /// + void(CEF_CALLBACK* set_fragment_text)(struct _cef_drag_data_t* self, + const cef_string_t* text); + + /// + /// Set the text/html fragment that is being dragged. + /// + void(CEF_CALLBACK* set_fragment_html)(struct _cef_drag_data_t* self, + const cef_string_t* html); + + /// + /// Set the base URL that the fragment came from. + /// + void(CEF_CALLBACK* set_fragment_base_url)(struct _cef_drag_data_t* self, + const cef_string_t* base_url); + + /// + /// Reset the file contents. You should do this before calling + /// cef_browser_host_t::DragTargetDragEnter as the web view does not allow us + /// to drag in this kind of data. + /// + void(CEF_CALLBACK* reset_file_contents)(struct _cef_drag_data_t* self); + + /// + /// Add a file that is being dragged into the webview. + /// + void(CEF_CALLBACK* add_file)(struct _cef_drag_data_t* self, + const cef_string_t* path, + const cef_string_t* display_name); + + /// + /// Clear list of filenames. + /// + void(CEF_CALLBACK* clear_filenames)(struct _cef_drag_data_t* self); + + /// + /// Get the image representation of drag data. May return NULL if no image + /// representation is available. + /// + struct _cef_image_t*(CEF_CALLBACK* get_image)(struct _cef_drag_data_t* self); + + /// + /// Get the image hotspot (drag start location relative to image dimensions). + /// + cef_point_t(CEF_CALLBACK* get_image_hotspot)(struct _cef_drag_data_t* self); + + /// + /// Returns true (1) if an image representation of drag data is available. + /// + int(CEF_CALLBACK* has_image)(struct _cef_drag_data_t* self); +} cef_drag_data_t; + +/// +/// Create a new cef_drag_data_t object. +/// +CEF_EXPORT cef_drag_data_t* cef_drag_data_create(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_ diff --git a/include/capi/cef_drag_handler_capi.h b/include/capi/cef_drag_handler_capi.h new file mode 100644 index 00000000..a5023e00 --- /dev/null +++ b/include/capi/cef_drag_handler_capi.h @@ -0,0 +1,92 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=ad16b0f4320d7b363efb152a65e3ce142882b9d9$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_drag_data_capi.h" +#include "include/capi/cef_frame_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events related to dragging. The functions +/// of this structure will be called on the UI thread. +/// +typedef struct _cef_drag_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when an external drag event enters the browser window. |dragData| + /// contains the drag event data and |mask| represents the type of drag + /// operation. Return false (0) for default drag handling behavior or true (1) + /// to cancel the drag event. + /// + int(CEF_CALLBACK* on_drag_enter)(struct _cef_drag_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_drag_data_t* dragData, + cef_drag_operations_mask_t mask); + + /// + /// Called whenever draggable regions for the browser window change. These can + /// be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If + /// draggable regions are never defined in a document this function will also + /// never be called. If the last draggable region is removed from a document + /// this function will be called with an NULL vector. + /// + void(CEF_CALLBACK* on_draggable_regions_changed)( + struct _cef_drag_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + size_t regionsCount, + cef_draggable_region_t const* regions); +} cef_drag_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_ diff --git a/include/capi/cef_extension_capi.h b/include/capi/cef_extension_capi.h new file mode 100644 index 00000000..a945b9bf --- /dev/null +++ b/include/capi/cef_extension_capi.h @@ -0,0 +1,130 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=c81a74622b987483e5fcd2c508aec5c13e12389b$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_extension_handler_t; +struct _cef_request_context_t; + +/// +/// Object representing an extension. Methods may be called on any thread unless +/// otherwise indicated. +/// +typedef struct _cef_extension_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the unique extension identifier. This is calculated based on the + /// extension public key, if available, or on the extension path. See + /// https://developer.chrome.com/extensions/manifest/key for details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_identifier)( + struct _cef_extension_t* self); + + /// + /// Returns the absolute path to the extension directory on disk. This value + /// will be prefixed with PK_DIR_RESOURCES if a relative path was passed to + /// cef_request_context_t::LoadExtension. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_path)(struct _cef_extension_t* self); + + /// + /// Returns the extension manifest contents as a cef_dictionary_value_t + /// object. See https://developer.chrome.com/extensions/manifest for details. + /// + struct _cef_dictionary_value_t*(CEF_CALLBACK* get_manifest)( + struct _cef_extension_t* self); + + /// + /// Returns true (1) if this object is the same extension as |that| object. + /// Extensions are considered the same if identifier, path and loader context + /// match. + /// + int(CEF_CALLBACK* is_same)(struct _cef_extension_t* self, + struct _cef_extension_t* that); + + /// + /// Returns the handler for this extension. Will return NULL for internal + /// extensions or if no handler was passed to + /// cef_request_context_t::LoadExtension. + /// + struct _cef_extension_handler_t*(CEF_CALLBACK* get_handler)( + struct _cef_extension_t* self); + + /// + /// Returns the request context that loaded this extension. Will return NULL + /// for internal extensions or if the extension has been unloaded. See the + /// cef_request_context_t::LoadExtension documentation for more information + /// about loader contexts. Must be called on the browser process UI thread. + /// + struct _cef_request_context_t*(CEF_CALLBACK* get_loader_context)( + struct _cef_extension_t* self); + + /// + /// Returns true (1) if this extension is currently loaded. Must be called on + /// the browser process UI thread. + /// + int(CEF_CALLBACK* is_loaded)(struct _cef_extension_t* self); + + /// + /// Unload this extension if it is not an internal extension and is currently + /// loaded. Will result in a call to + /// cef_extension_handler_t::OnExtensionUnloaded on success. + /// + void(CEF_CALLBACK* unload)(struct _cef_extension_t* self); +} cef_extension_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_ diff --git a/include/capi/cef_extension_handler_capi.h b/include/capi/cef_extension_handler_capi.h new file mode 100644 index 00000000..ab29f349 --- /dev/null +++ b/include/capi/cef_extension_handler_capi.h @@ -0,0 +1,212 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=ad6d3845b150f22b88a71dafa601ef01c9579824$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_extension_capi.h" +#include "include/capi/cef_stream_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_client_t; + +/// +/// Callback structure used for asynchronous continuation of +/// cef_extension_handler_t::GetExtensionResource. +/// +typedef struct _cef_get_extension_resource_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Continue the request. Read the resource contents from |stream|. + /// + void(CEF_CALLBACK* cont)(struct _cef_get_extension_resource_callback_t* self, + struct _cef_stream_reader_t* stream); + + /// + /// Cancel the request. + /// + void(CEF_CALLBACK* cancel)( + struct _cef_get_extension_resource_callback_t* self); +} cef_get_extension_resource_callback_t; + +/// +/// Implement this structure to handle events related to browser extensions. The +/// functions of this structure will be called on the UI thread. See +/// cef_request_context_t::LoadExtension for information about extension +/// loading. +/// +typedef struct _cef_extension_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called if the cef_request_context_t::LoadExtension request fails. |result| + /// will be the error code. + /// + void(CEF_CALLBACK* on_extension_load_failed)( + struct _cef_extension_handler_t* self, + cef_errorcode_t result); + + /// + /// Called if the cef_request_context_t::LoadExtension request succeeds. + /// |extension| is the loaded extension. + /// + void(CEF_CALLBACK* on_extension_loaded)(struct _cef_extension_handler_t* self, + struct _cef_extension_t* extension); + + /// + /// Called after the cef_extension_t::Unload request has completed. + /// + void(CEF_CALLBACK* on_extension_unloaded)( + struct _cef_extension_handler_t* self, + struct _cef_extension_t* extension); + + /// + /// Called when an extension needs a browser to host a background script + /// specified via the "background" manifest key. The browser will have no + /// visible window and cannot be displayed. |extension| is the extension that + /// is loading the background script. |url| is an internally generated + /// reference to an HTML page that will be used to load the background script + /// via a "<script>" src attribute. To allow creation of the browser + /// optionally modify |client| and |settings| and return false (0). To cancel + /// creation of the browser (and consequently cancel load of the background + /// script) return true (1). Successful creation will be indicated by a call + /// to cef_life_span_handler_t::OnAfterCreated, and + /// cef_browser_host_t::IsBackgroundHost will return true (1) for the + /// resulting browser. See https://developer.chrome.com/extensions/event_pages + /// for more information about extension background script usage. + /// + int(CEF_CALLBACK* on_before_background_browser)( + struct _cef_extension_handler_t* self, + struct _cef_extension_t* extension, + const cef_string_t* url, + struct _cef_client_t** client, + struct _cef_browser_settings_t* settings); + + /// + /// Called when an extension API (e.g. chrome.tabs.create) requests creation + /// of a new browser. |extension| and |browser| are the source of the API + /// call. |active_browser| may optionally be specified via the windowId + /// property or returned via the get_active_browser() callback and provides + /// the default |client| and |settings| values for the new browser. |index| is + /// the position value optionally specified via the index property. |url| is + /// the URL that will be loaded in the browser. |active| is true (1) if the + /// new browser should be active when opened. To allow creation of the + /// browser optionally modify |windowInfo|, |client| and |settings| and return + /// false (0). To cancel creation of the browser return true (1). Successful + /// creation will be indicated by a call to + /// cef_life_span_handler_t::OnAfterCreated. Any modifications to |windowInfo| + /// will be ignored if |active_browser| is wrapped in a cef_browser_view_t. + /// + int(CEF_CALLBACK* on_before_browser)( + struct _cef_extension_handler_t* self, + struct _cef_extension_t* extension, + struct _cef_browser_t* browser, + struct _cef_browser_t* active_browser, + int index, + const cef_string_t* url, + int active, + struct _cef_window_info_t* windowInfo, + struct _cef_client_t** client, + struct _cef_browser_settings_t* settings); + + /// + /// Called when no tabId is specified to an extension API call that accepts a + /// tabId parameter (e.g. chrome.tabs.*). |extension| and |browser| are the + /// source of the API call. Return the browser that will be acted on by the + /// API call or return NULL to act on |browser|. The returned browser must + /// share the same cef_request_context_t as |browser|. Incognito browsers + /// should not be considered unless the source extension has incognito access + /// enabled, in which case |include_incognito| will be true (1). + /// + struct _cef_browser_t*(CEF_CALLBACK* get_active_browser)( + struct _cef_extension_handler_t* self, + struct _cef_extension_t* extension, + struct _cef_browser_t* browser, + int include_incognito); + + /// + /// Called when the tabId associated with |target_browser| is specified to an + /// extension API call that accepts a tabId parameter (e.g. chrome.tabs.*). + /// |extension| and |browser| are the source of the API call. Return true (1) + /// to allow access of false (0) to deny access. Access to incognito browsers + /// should not be allowed unless the source extension has incognito access + /// enabled, in which case |include_incognito| will be true (1). + /// + int(CEF_CALLBACK* can_access_browser)(struct _cef_extension_handler_t* self, + struct _cef_extension_t* extension, + struct _cef_browser_t* browser, + int include_incognito, + struct _cef_browser_t* target_browser); + + /// + /// Called to retrieve an extension resource that would normally be loaded + /// from disk (e.g. if a file parameter is specified to + /// chrome.tabs.executeScript). |extension| and |browser| are the source of + /// the resource request. |file| is the requested relative file path. To + /// handle the resource request return true (1) and execute |callback| either + /// synchronously or asynchronously. For the default behavior which reads the + /// resource from the extension directory on disk return false (0). + /// Localization substitutions will not be applied to resources handled via + /// this function. + /// + int(CEF_CALLBACK* get_extension_resource)( + struct _cef_extension_handler_t* self, + struct _cef_extension_t* extension, + struct _cef_browser_t* browser, + const cef_string_t* file, + struct _cef_get_extension_resource_callback_t* callback); +} cef_extension_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_ diff --git a/include/capi/cef_file_util_capi.h b/include/capi/cef_file_util_capi.h new file mode 100644 index 00000000..daad7a52 --- /dev/null +++ b/include/capi/cef_file_util_capi.h @@ -0,0 +1,132 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=4e0e0abcb72327998df950e618b147b196e76b60$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Creates a directory and all parent directories if they don't already exist. +/// Returns true (1) on successful creation or if the directory already exists. +/// The directory is only readable by the current user. Calling this function on +/// the browser process UI or IO threads is not allowed. +/// +CEF_EXPORT int cef_create_directory(const cef_string_t* full_path); + +/// +/// Get the temporary directory provided by the system. +/// +/// WARNING: In general, you should use the temp directory variants below +/// instead of this function. Those variants will ensure that the proper +/// permissions are set so that other users on the system can't edit them while +/// they're open (which could lead to security issues). +/// +CEF_EXPORT int cef_get_temp_directory(cef_string_t* temp_dir); + +/// +/// Creates a new directory. On Windows if |prefix| is provided the new +/// directory name is in the format of "prefixyyyy". Returns true (1) on success +/// and sets |new_temp_path| to the full path of the directory that was created. +/// The directory is only readable by the current user. Calling this function on +/// the browser process UI or IO threads is not allowed. +/// +CEF_EXPORT int cef_create_new_temp_directory(const cef_string_t* prefix, + cef_string_t* new_temp_path); + +/// +/// Creates a directory within another directory. Extra characters will be +/// appended to |prefix| to ensure that the new directory does not have the same +/// name as an existing directory. Returns true (1) on success and sets +/// |new_dir| to the full path of the directory that was created. The directory +/// is only readable by the current user. Calling this function on the browser +/// process UI or IO threads is not allowed. +/// +CEF_EXPORT int cef_create_temp_directory_in_directory( + const cef_string_t* base_dir, + const cef_string_t* prefix, + cef_string_t* new_dir); + +/// +/// Returns true (1) if the given path exists and is a directory. Calling this +/// function on the browser process UI or IO threads is not allowed. +/// +CEF_EXPORT int cef_directory_exists(const cef_string_t* path); + +/// +/// Deletes the given path whether it's a file or a directory. If |path| is a +/// directory all contents will be deleted. If |recursive| is true (1) any sub- +/// directories and their contents will also be deleted (equivalent to executing +/// "rm -rf", so use with caution). On POSIX environments if |path| is a +/// symbolic link then only the symlink will be deleted. Returns true (1) on +/// successful deletion or if |path| does not exist. Calling this function on +/// the browser process UI or IO threads is not allowed. +/// +CEF_EXPORT int cef_delete_file(const cef_string_t* path, int recursive); + +/// +/// Writes the contents of |src_dir| into a zip archive at |dest_file|. If +/// |include_hidden_files| is true (1) files starting with "." will be included. +/// Returns true (1) on success. Calling this function on the browser process +/// UI or IO threads is not allowed. +/// +CEF_EXPORT int cef_zip_directory(const cef_string_t* src_dir, + const cef_string_t* dest_file, + int include_hidden_files); + +/// +/// Loads the existing "Certificate Revocation Lists" file that is managed by +/// Google Chrome. This file can generally be found in Chrome's User Data +/// directory (e.g. "C:\Users\[User]\AppData\Local\Google\Chrome\User Data\" on +/// Windows) and is updated periodically by Chrome's component updater service. +/// Must be called in the browser process after the context has been +/// initialized. See https://dev.chromium.org/Home/chromium-security/crlsets for +/// background. +/// +CEF_EXPORT void cef_load_crlsets_file(const cef_string_t* path); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_ diff --git a/include/capi/cef_find_handler_capi.h b/include/capi/cef_find_handler_capi.h new file mode 100644 index 00000000..94450d29 --- /dev/null +++ b/include/capi/cef_find_handler_capi.h @@ -0,0 +1,82 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=8149c82dd6671d676ee62cb6749bf30b32a5832c$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events related to find results. The +/// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_find_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called to report find results returned by cef_browser_host_t::find(). + /// |identifer| is a unique incremental identifier for the currently active + /// search, |count| is the number of matches currently identified, + /// |selectionRect| is the location of where the match was found (in window + /// coordinates), |activeMatchOrdinal| is the current position in the search + /// results, and |finalUpdate| is true (1) if this is the last find + /// notification. + /// + void(CEF_CALLBACK* on_find_result)(struct _cef_find_handler_t* self, + struct _cef_browser_t* browser, + int identifier, + int count, + const cef_rect_t* selectionRect, + int activeMatchOrdinal, + int finalUpdate); +} cef_find_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_ diff --git a/include/capi/cef_focus_handler_capi.h b/include/capi/cef_focus_handler_capi.h new file mode 100644 index 00000000..f7b699dc --- /dev/null +++ b/include/capi/cef_focus_handler_capi.h @@ -0,0 +1,93 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=53ec33c8937c735f646f9e0a14a416218e32887c$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_dom_capi.h" +#include "include/capi/cef_frame_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events related to focus. The functions of +/// this structure will be called on the UI thread. +/// +typedef struct _cef_focus_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when the browser component is about to loose focus. For instance, + /// if focus was on the last HTML element and the user pressed the TAB key. + /// |next| will be true (1) if the browser is giving focus to the next + /// component and false (0) if the browser is giving focus to the previous + /// component. + /// + void(CEF_CALLBACK* on_take_focus)(struct _cef_focus_handler_t* self, + struct _cef_browser_t* browser, + int next); + + /// + /// Called when the browser component is requesting focus. |source| indicates + /// where the focus request is originating from. Return false (0) to allow the + /// focus to be set or true (1) to cancel setting the focus. + /// + int(CEF_CALLBACK* on_set_focus)(struct _cef_focus_handler_t* self, + struct _cef_browser_t* browser, + cef_focus_source_t source); + + /// + /// Called when the browser component has received focus. + /// + void(CEF_CALLBACK* on_got_focus)(struct _cef_focus_handler_t* self, + struct _cef_browser_t* browser); +} cef_focus_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_ diff --git a/include/capi/cef_frame_capi.h b/include/capi/cef_frame_capi.h new file mode 100644 index 00000000..94069ced --- /dev/null +++ b/include/capi/cef_frame_capi.h @@ -0,0 +1,263 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=b9b1308311999efcfd2aa678472f934ca783492c$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_dom_capi.h" +#include "include/capi/cef_process_message_capi.h" +#include "include/capi/cef_request_capi.h" +#include "include/capi/cef_stream_capi.h" +#include "include/capi/cef_string_visitor_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_browser_t; +struct _cef_urlrequest_client_t; +struct _cef_urlrequest_t; +struct _cef_v8context_t; + +/// +/// Structure used to represent a frame in the browser window. When used in the +/// browser process the functions of this structure may be called on any thread +/// unless otherwise indicated in the comments. When used in the render process +/// the functions of this structure may only be called on the main thread. +/// +typedef struct _cef_frame_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// True if this object is currently attached to a valid frame. + /// + int(CEF_CALLBACK* is_valid)(struct _cef_frame_t* self); + + /// + /// Execute undo in this frame. + /// + void(CEF_CALLBACK* undo)(struct _cef_frame_t* self); + + /// + /// Execute redo in this frame. + /// + void(CEF_CALLBACK* redo)(struct _cef_frame_t* self); + + /// + /// Execute cut in this frame. + /// + void(CEF_CALLBACK* cut)(struct _cef_frame_t* self); + + /// + /// Execute copy in this frame. + /// + void(CEF_CALLBACK* copy)(struct _cef_frame_t* self); + + /// + /// Execute paste in this frame. + /// + void(CEF_CALLBACK* paste)(struct _cef_frame_t* self); + + /// + /// Execute delete in this frame. + /// + void(CEF_CALLBACK* del)(struct _cef_frame_t* self); + + /// + /// Execute select all in this frame. + /// + void(CEF_CALLBACK* select_all)(struct _cef_frame_t* self); + + /// + /// Save this frame's HTML source to a temporary file and open it in the + /// default text viewing application. This function can only be called from + /// the browser process. + /// + void(CEF_CALLBACK* view_source)(struct _cef_frame_t* self); + + /// + /// Retrieve this frame's HTML source as a string sent to the specified + /// visitor. + /// + void(CEF_CALLBACK* get_source)(struct _cef_frame_t* self, + struct _cef_string_visitor_t* visitor); + + /// + /// Retrieve this frame's display text as a string sent to the specified + /// visitor. + /// + void(CEF_CALLBACK* get_text)(struct _cef_frame_t* self, + struct _cef_string_visitor_t* visitor); + + /// + /// Load the request represented by the |request| object. + /// + /// WARNING: This function will fail with "bad IPC message" reason + /// INVALID_INITIATOR_ORIGIN (213) unless you first navigate to the request + /// origin using some other mechanism (LoadURL, link click, etc). + /// + void(CEF_CALLBACK* load_request)(struct _cef_frame_t* self, + struct _cef_request_t* request); + + /// + /// Load the specified |url|. + /// + void(CEF_CALLBACK* load_url)(struct _cef_frame_t* self, + const cef_string_t* url); + + /// + /// Execute a string of JavaScript code in this frame. The |script_url| + /// parameter is the URL where the script in question can be found, if any. + /// The renderer may request this URL to show the developer the source of the + /// error. The |start_line| parameter is the base line number to use for + /// error reporting. + /// + void(CEF_CALLBACK* execute_java_script)(struct _cef_frame_t* self, + const cef_string_t* code, + const cef_string_t* script_url, + int start_line); + + /// + /// Returns true (1) if this is the main (top-level) frame. + /// + int(CEF_CALLBACK* is_main)(struct _cef_frame_t* self); + + /// + /// Returns true (1) if this is the focused frame. + /// + int(CEF_CALLBACK* is_focused)(struct _cef_frame_t* self); + + /// + /// Returns the name for this frame. If the frame has an assigned name (for + /// example, set via the iframe "name" attribute) then that value will be + /// returned. Otherwise a unique name will be constructed based on the frame + /// parent hierarchy. The main (top-level) frame will always have an NULL name + /// value. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_name)(struct _cef_frame_t* self); + + /// + /// Returns the globally unique identifier for this frame or < 0 if the + /// underlying frame does not yet exist. + /// + int64(CEF_CALLBACK* get_identifier)(struct _cef_frame_t* self); + + /// + /// Returns the parent of this frame or NULL if this is the main (top-level) + /// frame. + /// + struct _cef_frame_t*(CEF_CALLBACK* get_parent)(struct _cef_frame_t* self); + + /// + /// Returns the URL currently loaded in this frame. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_url)(struct _cef_frame_t* self); + + /// + /// Returns the browser that this frame belongs to. + /// + struct _cef_browser_t*(CEF_CALLBACK* get_browser)(struct _cef_frame_t* self); + + /// + /// Get the V8 context associated with the frame. This function can only be + /// called from the render process. + /// + struct _cef_v8context_t*(CEF_CALLBACK* get_v8context)( + struct _cef_frame_t* self); + + /// + /// Visit the DOM document. This function can only be called from the render + /// process. + /// + void(CEF_CALLBACK* visit_dom)(struct _cef_frame_t* self, + struct _cef_domvisitor_t* visitor); + + /// + /// Create a new URL request that will be treated as originating from this + /// frame and the associated browser. This request may be intercepted by the + /// client via cef_resource_request_handler_t or cef_scheme_handler_factory_t. + /// Use cef_urlrequest_t::Create instead if you do not want the request to + /// have this association, in which case it may be handled differently (see + /// documentation on that function). Requests may originate from both the + /// browser process and the render process. + /// + /// For requests originating from the browser process: + /// - POST data may only contain a single element of type PDE_TYPE_FILE or + /// PDE_TYPE_BYTES. + /// + /// For requests originating from the render process: + /// - POST data may only contain a single element of type PDE_TYPE_BYTES. + /// - If the response contains Content-Disposition or Mime-Type header + /// values that would not normally be rendered then the response may + /// receive special handling inside the browser (for example, via the + /// file download code path instead of the URL request code path). + /// + /// The |request| object will be marked as read-only after calling this + /// function. + /// + struct _cef_urlrequest_t*(CEF_CALLBACK* create_urlrequest)( + struct _cef_frame_t* self, + struct _cef_request_t* request, + struct _cef_urlrequest_client_t* client); + + /// + /// Send a message to the specified |target_process|. Ownership of the message + /// contents will be transferred and the |message| reference will be + /// invalidated. Message delivery is not guaranteed in all cases (for example, + /// if the browser is closing, navigating, or if the target process crashes). + /// Send an ACK message back from the target process if confirmation is + /// required. + /// + void(CEF_CALLBACK* send_process_message)( + struct _cef_frame_t* self, + cef_process_id_t target_process, + struct _cef_process_message_t* message); +} cef_frame_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_ diff --git a/include/capi/cef_frame_handler_capi.h b/include/capi/cef_frame_handler_capi.h new file mode 100644 index 00000000..94b3b882 --- /dev/null +++ b/include/capi/cef_frame_handler_capi.h @@ -0,0 +1,202 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=4cdadeb6439415d60ec32249c3a0b6457dd586f7$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_FRAME_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_frame_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events related to cef_frame_t life span. +/// The order of callbacks is: +/// +/// (1) During initial cef_browser_host_t creation and navigation of the main +/// frame: - cef_frame_handler_t::OnFrameCreated => The initial main frame +/// object has been +/// created. Any commands will be queued until the frame is attached. +/// - cef_frame_handler_t::OnMainFrameChanged => The initial main frame object +/// has +/// been assigned to the browser. +/// - cef_life_span_handler_t::OnAfterCreated => The browser is now valid and +/// can be +/// used. +/// - cef_frame_handler_t::OnFrameAttached => The initial main frame object is +/// now +/// connected to its peer in the renderer process. Commands can be routed. +/// +/// (2) During further cef_browser_host_t navigation/loading of the main frame +/// and/or sub-frames: +/// - cef_frame_handler_t::OnFrameCreated => A new main frame or sub-frame +/// object +/// has been created. Any commands will be queued until the frame is attached. +/// - cef_frame_handler_t::OnFrameAttached => A new main frame or sub-frame +/// object +/// is now connected to its peer in the renderer process. Commands can be +/// routed. +/// - cef_frame_handler_t::OnFrameDetached => An existing main frame or sub- +/// frame +/// object has lost its connection to the renderer process. If multiple +/// objects are detached at the same time then notifications will be sent for +/// any sub-frame objects before the main frame object. Commands can no longer +/// be routed and will be discarded. +/// - cef_frame_handler_t::OnMainFrameChanged => A new main frame object has +/// been +/// assigned to the browser. This will only occur with cross-origin navigation +/// or re-navigation after renderer process termination (due to crashes, etc). +/// +/// (3) During final cef_browser_host_t destruction of the main frame: - +/// cef_frame_handler_t::OnFrameDetached => Any sub-frame objects have lost +/// their +/// connection to the renderer process. Commands can no longer be routed and +/// will be discarded. +/// - cef_life_span_handler_t::OnBeforeClose => The browser has been destroyed. +/// - cef_frame_handler_t::OnFrameDetached => The main frame object have lost +/// its +/// connection to the renderer process. Notifications will be sent for any +/// sub-frame objects before the main frame object. Commands can no longer be +/// routed and will be discarded. +/// - cef_frame_handler_t::OnMainFrameChanged => The final main frame object has +/// been removed from the browser. +/// +/// Cross-origin navigation and/or loading receives special handling. +/// +/// When the main frame navigates to a different origin the OnMainFrameChanged +/// callback (2) will be executed with the old and new main frame objects. +/// +/// When a new sub-frame is loaded in, or an existing sub-frame is navigated to, +/// a different origin from the parent frame, a temporary sub-frame object will +/// first be created in the parent's renderer process. That temporary sub-frame +/// will then be discarded after the real cross-origin sub-frame is created in +/// the new/target renderer process. The client will receive cross-origin +/// navigation callbacks (2) for the transition from the temporary sub-frame to +/// the real sub-frame. The temporary sub-frame will not recieve or execute +/// commands during this transitional period (any sent commands will be +/// discarded). +/// +/// When a new popup browser is created in a different origin from the parent +/// browser, a temporary main frame object for the popup will first be created +/// in the parent's renderer process. That temporary main frame will then be +/// discarded after the real cross-origin main frame is created in the +/// new/target renderer process. The client will recieve creation and initial +/// navigation callbacks (1) for the temporary main frame, followed by cross- +/// origin navigation callbacks (2) for the transition from the temporary main +/// frame to the real main frame. The temporary main frame may receive and +/// execute commands during this transitional period (any sent commands may be +/// executed, but the behavior is potentially undesirable since they execute in +/// the parent browser's renderer process and not the new/target renderer +/// process). +/// +/// Callbacks will not be executed for placeholders that may be created during +/// pre-commit navigation for sub-frames that do not yet exist in the renderer +/// process. Placeholders will have cef_frame_t::get_identifier() == -4. +/// +/// The functions of this structure will be called on the UI thread unless +/// otherwise indicated. +/// +typedef struct _cef_frame_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when a new frame is created. This will be the first notification + /// that references |frame|. Any commands that require transport to the + /// associated renderer process (LoadRequest, SendProcessMessage, GetSource, + /// etc.) will be queued until OnFrameAttached is called for |frame|. + /// + void(CEF_CALLBACK* on_frame_created)(struct _cef_frame_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame); + + /// + /// Called when a frame can begin routing commands to/from the associated + /// renderer process. |reattached| will be true (1) if the frame was re- + /// attached after exiting the BackForwardCache. Any commands that were queued + /// have now been dispatched. + /// + void(CEF_CALLBACK* on_frame_attached)(struct _cef_frame_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + int reattached); + + /// + /// Called when a frame loses its connection to the renderer process and will + /// be destroyed. Any pending or future commands will be discarded and + /// cef_frame_t::is_valid() will now return false (0) for |frame|. If called + /// after cef_life_span_handler_t::on_before_close() during browser + /// destruction then cef_browser_t::is_valid() will return false (0) for + /// |browser|. + /// + void(CEF_CALLBACK* on_frame_detached)(struct _cef_frame_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame); + + /// + /// Called when the main frame changes due to (a) initial browser creation, + /// (b) final browser destruction, (c) cross-origin navigation or (d) re- + /// navigation after renderer process termination (due to crashes, etc). + /// |old_frame| will be NULL and |new_frame| will be non-NULL when a main + /// frame is assigned to |browser| for the first time. |old_frame| will be + /// non-NULL and |new_frame| will be NULL and when a main frame is removed + /// from |browser| for the last time. Both |old_frame| and |new_frame| will be + /// non-NULL for cross-origin navigations or re-navigation after renderer + /// process termination. This function will be called after on_frame_created() + /// for |new_frame| and/or after on_frame_detached() for |old_frame|. If + /// called after cef_life_span_handler_t::on_before_close() during browser + /// destruction then cef_browser_t::is_valid() will return false (0) for + /// |browser|. + /// + void(CEF_CALLBACK* on_main_frame_changed)(struct _cef_frame_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* old_frame, + struct _cef_frame_t* new_frame); +} cef_frame_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_FRAME_HANDLER_CAPI_H_ diff --git a/include/capi/cef_i18n_util_capi.h b/include/capi/cef_i18n_util_capi.h new file mode 100644 index 00000000..3aab714e --- /dev/null +++ b/include/capi/cef_i18n_util_capi.h @@ -0,0 +1,58 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=c564ee1f32a0ef05fe49fc779af5bc0b0e1b36d6$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Returns true (1) if the application text direction is right-to-left. +/// +CEF_EXPORT int cef_is_rtl(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_ diff --git a/include/capi/cef_image_capi.h b/include/capi/cef_image_capi.h new file mode 100644 index 00000000..9d4a0a9c --- /dev/null +++ b/include/capi/cef_image_capi.h @@ -0,0 +1,206 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=99c94b208f9b184985220493bba4ea08e6786046$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Container for a single image represented at different scale factors. All +/// image representations should be the same size in density independent pixel +/// (DIP) units. For example, if the image at scale factor 1.0 is 100x100 pixels +/// then the image at scale factor 2.0 should be 200x200 pixels -- both images +/// will display with a DIP size of 100x100 units. The functions of this +/// structure can be called on any browser process thread. +/// +typedef struct _cef_image_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this Image is NULL. + /// + int(CEF_CALLBACK* is_empty)(struct _cef_image_t* self); + + /// + /// Returns true (1) if this Image and |that| Image share the same underlying + /// storage. Will also return true (1) if both images are NULL. + /// + int(CEF_CALLBACK* is_same)(struct _cef_image_t* self, + struct _cef_image_t* that); + + /// + /// Add a bitmap image representation for |scale_factor|. Only 32-bit + /// RGBA/BGRA formats are supported. |pixel_width| and |pixel_height| are the + /// bitmap representation size in pixel coordinates. |pixel_data| is the array + /// of pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in + /// size. |color_type| and |alpha_type| values specify the pixel format. + /// + int(CEF_CALLBACK* add_bitmap)(struct _cef_image_t* self, + float scale_factor, + int pixel_width, + int pixel_height, + cef_color_type_t color_type, + cef_alpha_type_t alpha_type, + const void* pixel_data, + size_t pixel_data_size); + + /// + /// Add a PNG image representation for |scale_factor|. |png_data| is the image + /// data of size |png_data_size|. Any alpha transparency in the PNG data will + /// be maintained. + /// + int(CEF_CALLBACK* add_png)(struct _cef_image_t* self, + float scale_factor, + const void* png_data, + size_t png_data_size); + + /// + /// Create a JPEG image representation for |scale_factor|. |jpeg_data| is the + /// image data of size |jpeg_data_size|. The JPEG format does not support + /// transparency so the alpha byte will be set to 0xFF for all pixels. + /// + int(CEF_CALLBACK* add_jpeg)(struct _cef_image_t* self, + float scale_factor, + const void* jpeg_data, + size_t jpeg_data_size); + + /// + /// Returns the image width in density independent pixel (DIP) units. + /// + size_t(CEF_CALLBACK* get_width)(struct _cef_image_t* self); + + /// + /// Returns the image height in density independent pixel (DIP) units. + /// + size_t(CEF_CALLBACK* get_height)(struct _cef_image_t* self); + + /// + /// Returns true (1) if this image contains a representation for + /// |scale_factor|. + /// + int(CEF_CALLBACK* has_representation)(struct _cef_image_t* self, + float scale_factor); + + /// + /// Removes the representation for |scale_factor|. Returns true (1) on + /// success. + /// + int(CEF_CALLBACK* remove_representation)(struct _cef_image_t* self, + float scale_factor); + + /// + /// Returns information for the representation that most closely matches + /// |scale_factor|. |actual_scale_factor| is the actual scale factor for the + /// representation. |pixel_width| and |pixel_height| are the representation + /// size in pixel coordinates. Returns true (1) on success. + /// + int(CEF_CALLBACK* get_representation_info)(struct _cef_image_t* self, + float scale_factor, + float* actual_scale_factor, + int* pixel_width, + int* pixel_height); + + /// + /// Returns the bitmap representation that most closely matches + /// |scale_factor|. Only 32-bit RGBA/BGRA formats are supported. |color_type| + /// and |alpha_type| values specify the desired output pixel format. + /// |pixel_width| and |pixel_height| are the output representation size in + /// pixel coordinates. Returns a cef_binary_value_t containing the pixel data + /// on success or NULL on failure. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_as_bitmap)( + struct _cef_image_t* self, + float scale_factor, + cef_color_type_t color_type, + cef_alpha_type_t alpha_type, + int* pixel_width, + int* pixel_height); + + /// + /// Returns the PNG representation that most closely matches |scale_factor|. + /// If |with_transparency| is true (1) any alpha transparency in the image + /// will be represented in the resulting PNG data. |pixel_width| and + /// |pixel_height| are the output representation size in pixel coordinates. + /// Returns a cef_binary_value_t containing the PNG image data on success or + /// NULL on failure. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_as_png)( + struct _cef_image_t* self, + float scale_factor, + int with_transparency, + int* pixel_width, + int* pixel_height); + + /// + /// Returns the JPEG representation that most closely matches |scale_factor|. + /// |quality| determines the compression level with 0 == lowest and 100 == + /// highest. The JPEG format does not support alpha transparency and the alpha + /// channel, if any, will be discarded. |pixel_width| and |pixel_height| are + /// the output representation size in pixel coordinates. Returns a + /// cef_binary_value_t containing the JPEG image data on success or NULL on + /// failure. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_as_jpeg)( + struct _cef_image_t* self, + float scale_factor, + int quality, + int* pixel_width, + int* pixel_height); +} cef_image_t; + +/// +/// Create a new cef_image_t. It will initially be NULL. Use the Add*() +/// functions to add representations at different scale factors. +/// +CEF_EXPORT cef_image_t* cef_image_create(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_ diff --git a/include/capi/cef_jsdialog_handler_capi.h b/include/capi/cef_jsdialog_handler_capi.h new file mode 100644 index 00000000..a490ddd8 --- /dev/null +++ b/include/capi/cef_jsdialog_handler_capi.h @@ -0,0 +1,141 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=e9fb0354243611f3a4de508923a4e01dab42f82d$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Callback structure used for asynchronous continuation of JavaScript dialog +/// requests. +/// +typedef struct _cef_jsdialog_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Continue the JS dialog request. Set |success| to true (1) if the OK button + /// was pressed. The |user_input| value should be specified for prompt + /// dialogs. + /// + void(CEF_CALLBACK* cont)(struct _cef_jsdialog_callback_t* self, + int success, + const cef_string_t* user_input); +} cef_jsdialog_callback_t; + +/// +/// Implement this structure to handle events related to JavaScript dialogs. The +/// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_jsdialog_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called to run a JavaScript dialog. If |origin_url| is non-NULL it can be + /// passed to the CefFormatUrlForSecurityDisplay function to retrieve a secure + /// and user-friendly display string. The |default_prompt_text| value will be + /// specified for prompt dialogs only. Set |suppress_message| to true (1) and + /// return false (0) to suppress the message (suppressing messages is + /// preferable to immediately executing the callback as this is used to detect + /// presumably malicious behavior like spamming alert messages in + /// onbeforeunload). Set |suppress_message| to false (0) and return false (0) + /// to use the default implementation (the default implementation will show + /// one modal dialog at a time and suppress any additional dialog requests + /// until the displayed dialog is dismissed). Return true (1) if the + /// application will use a custom dialog or if the callback has been executed + /// immediately. Custom dialogs may be either modal or modeless. If a custom + /// dialog is used the application must execute |callback| once the custom + /// dialog is dismissed. + /// + int(CEF_CALLBACK* on_jsdialog)(struct _cef_jsdialog_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* origin_url, + cef_jsdialog_type_t dialog_type, + const cef_string_t* message_text, + const cef_string_t* default_prompt_text, + struct _cef_jsdialog_callback_t* callback, + int* suppress_message); + + /// + /// Called to run a dialog asking the user if they want to leave a page. + /// Return false (0) to use the default dialog implementation. Return true (1) + /// if the application will use a custom dialog or if the callback has been + /// executed immediately. Custom dialogs may be either modal or modeless. If a + /// custom dialog is used the application must execute |callback| once the + /// custom dialog is dismissed. + /// + int(CEF_CALLBACK* on_before_unload_dialog)( + struct _cef_jsdialog_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* message_text, + int is_reload, + struct _cef_jsdialog_callback_t* callback); + + /// + /// Called to cancel any pending dialogs and reset any saved dialog state. + /// Will be called due to events like page navigation irregardless of whether + /// any dialogs are currently pending. + /// + void(CEF_CALLBACK* on_reset_dialog_state)( + struct _cef_jsdialog_handler_t* self, + struct _cef_browser_t* browser); + + /// + /// Called when the dialog is closed. + /// + void(CEF_CALLBACK* on_dialog_closed)(struct _cef_jsdialog_handler_t* self, + struct _cef_browser_t* browser); +} cef_jsdialog_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_ diff --git a/include/capi/cef_keyboard_handler_capi.h b/include/capi/cef_keyboard_handler_capi.h new file mode 100644 index 00000000..7ff37b46 --- /dev/null +++ b/include/capi/cef_keyboard_handler_capi.h @@ -0,0 +1,90 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=10fb708c5f550403205a976924abf1886bf3dfa7$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events related to keyboard input. The +/// functions of this structure will be called on the UI thread. +/// +typedef struct _cef_keyboard_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called before a keyboard event is sent to the renderer. |event| contains + /// information about the keyboard event. |os_event| is the operating system + /// event message, if any. Return true (1) if the event was handled or false + /// (0) otherwise. If the event will be handled in on_key_event() as a + /// keyboard shortcut set |is_keyboard_shortcut| to true (1) and return false + /// (0). + /// + int(CEF_CALLBACK* on_pre_key_event)(struct _cef_keyboard_handler_t* self, + struct _cef_browser_t* browser, + const cef_key_event_t* event, + cef_event_handle_t os_event, + int* is_keyboard_shortcut); + + /// + /// Called after the renderer and JavaScript in the page has had a chance to + /// handle the event. |event| contains information about the keyboard event. + /// |os_event| is the operating system event message, if any. Return true (1) + /// if the keyboard event was handled or false (0) otherwise. + /// + int(CEF_CALLBACK* on_key_event)(struct _cef_keyboard_handler_t* self, + struct _cef_browser_t* browser, + const cef_key_event_t* event, + cef_event_handle_t os_event); +} cef_keyboard_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_ diff --git a/include/capi/cef_life_span_handler_capi.h b/include/capi/cef_life_span_handler_capi.h new file mode 100644 index 00000000..f02ea6a4 --- /dev/null +++ b/include/capi/cef_life_span_handler_capi.h @@ -0,0 +1,225 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=1c807597b96889f44a1e5199e860e8db4948b473$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_client_t; + +/// +/// Implement this structure to handle events related to browser life span. The +/// functions of this structure will be called on the UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_life_span_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called on the UI thread before a new popup browser is created. The + /// |browser| and |frame| values represent the source of the popup request. + /// The |target_url| and |target_frame_name| values indicate where the popup + /// browser should navigate and may be NULL if not specified with the request. + /// The |target_disposition| value indicates where the user intended to open + /// the popup (e.g. current tab, new tab, etc). The |user_gesture| value will + /// be true (1) if the popup was opened via explicit user gesture (e.g. + /// clicking a link) or false (0) if the popup opened automatically (e.g. via + /// the DomContentLoaded event). The |popupFeatures| structure contains + /// additional information about the requested popup window. To allow creation + /// of the popup browser optionally modify |windowInfo|, |client|, |settings| + /// and |no_javascript_access| and return false (0). To cancel creation of the + /// popup browser return true (1). The |client| and |settings| values will + /// default to the source browser's values. If the |no_javascript_access| + /// value is set to false (0) the new browser will not be scriptable and may + /// not be hosted in the same renderer process as the source browser. Any + /// modifications to |windowInfo| will be ignored if the parent browser is + /// wrapped in a cef_browser_view_t. Popup browser creation will be canceled + /// if the parent browser is destroyed before the popup browser creation + /// completes (indicated by a call to OnAfterCreated for the popup browser). + /// The |extra_info| parameter provides an opportunity to specify extra + /// information specific to the created popup browser that will be passed to + /// cef_render_process_handler_t::on_browser_created() in the render process. + /// + int(CEF_CALLBACK* on_before_popup)( + struct _cef_life_span_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + const cef_string_t* target_url, + const cef_string_t* target_frame_name, + cef_window_open_disposition_t target_disposition, + int user_gesture, + const cef_popup_features_t* popupFeatures, + struct _cef_window_info_t* windowInfo, + struct _cef_client_t** client, + struct _cef_browser_settings_t* settings, + struct _cef_dictionary_value_t** extra_info, + int* no_javascript_access); + + /// + /// Called after a new browser is created. It is now safe to begin performing + /// actions with |browser|. cef_frame_handler_t callbacks related to initial + /// main frame creation will arrive before this callback. See + /// cef_frame_handler_t documentation for additional usage information. + /// + void(CEF_CALLBACK* on_after_created)(struct _cef_life_span_handler_t* self, + struct _cef_browser_t* browser); + + /// + /// Called when a browser has recieved a request to close. This may result + /// directly from a call to cef_browser_host_t::*close_browser() or indirectly + /// if the browser is parented to a top-level window created by CEF and the + /// user attempts to close that window (by clicking the 'X', for example). The + /// do_close() function will be called after the JavaScript 'onunload' event + /// has been fired. + /// + /// An application should handle top-level owner window close notifications by + /// calling cef_browser_host_t::try_close_browser() or + /// cef_browser_host_t::CloseBrowser(false (0)) instead of allowing the window + /// to close immediately (see the examples below). This gives CEF an + /// opportunity to process the 'onbeforeunload' event and optionally cancel + /// the close before do_close() is called. + /// + /// When windowed rendering is enabled CEF will internally create a window or + /// view to host the browser. In that case returning false (0) from do_close() + /// will send the standard close notification to the browser's top-level owner + /// window (e.g. WM_CLOSE on Windows, performClose: on OS X, "delete_event" on + /// Linux or cef_window_delegate_t::can_close() callback from Views). If the + /// browser's host window/view has already been destroyed (via view hierarchy + /// tear-down, for example) then do_close() will not be called for that + /// browser since is no longer possible to cancel the close. + /// + /// When windowed rendering is disabled returning false (0) from do_close() + /// will cause the browser object to be destroyed immediately. + /// + /// If the browser's top-level owner window requires a non-standard close + /// notification then send that notification from do_close() and return true + /// (1). + /// + /// The cef_life_span_handler_t::on_before_close() function will be called + /// after do_close() (if do_close() is called) and immediately before the + /// browser object is destroyed. The application should only exit after + /// on_before_close() has been called for all existing browsers. + /// + /// The below examples describe what should happen during window close when + /// the browser is parented to an application-provided top-level window. + /// + /// Example 1: Using cef_browser_host_t::try_close_browser(). This is + /// recommended for clients using standard close handling and windows created + /// on the browser process UI thread. 1. User clicks the window close button + /// which sends a close notification + /// to the application's top-level window. + /// 2. Application's top-level window receives the close notification and + /// calls TryCloseBrowser() (which internally calls CloseBrowser(false)). + /// TryCloseBrowser() returns false so the client cancels the window + /// close. + /// 3. JavaScript 'onbeforeunload' handler executes and shows the close + /// confirmation dialog (which can be overridden via + /// CefJSDialogHandler::OnBeforeUnloadDialog()). + /// 4. User approves the close. 5. JavaScript 'onunload' handler executes. + /// 6. CEF sends a close notification to the application's top-level window + /// (because DoClose() returned false by default). + /// 7. Application's top-level window receives the close notification and + /// calls TryCloseBrowser(). TryCloseBrowser() returns true so the client + /// allows the window close. + /// 8. Application's top-level window is destroyed. 9. Application's + /// on_before_close() handler is called and the browser object + /// is destroyed. + /// 10. Application exits by calling cef_quit_message_loop() if no other + /// browsers + /// exist. + /// + /// Example 2: Using cef_browser_host_t::CloseBrowser(false (0)) and + /// implementing the do_close() callback. This is recommended for clients + /// using non-standard close handling or windows that were not created on the + /// browser process UI thread. 1. User clicks the window close button which + /// sends a close notification + /// to the application's top-level window. + /// 2. Application's top-level window receives the close notification and: + /// A. Calls CefBrowserHost::CloseBrowser(false). + /// B. Cancels the window close. + /// 3. JavaScript 'onbeforeunload' handler executes and shows the close + /// confirmation dialog (which can be overridden via + /// CefJSDialogHandler::OnBeforeUnloadDialog()). + /// 4. User approves the close. 5. JavaScript 'onunload' handler executes. + /// 6. Application's do_close() handler is called. Application will: + /// A. Set a flag to indicate that the next close attempt will be allowed. + /// B. Return false. + /// 7. CEF sends an close notification to the application's top-level window. + /// 8. Application's top-level window receives the close notification and + /// allows the window to close based on the flag from #6B. + /// 9. Application's top-level window is destroyed. 10. Application's + /// on_before_close() handler is called and the browser object + /// is destroyed. + /// 11. Application exits by calling cef_quit_message_loop() if no other + /// browsers + /// exist. + /// + int(CEF_CALLBACK* do_close)(struct _cef_life_span_handler_t* self, + struct _cef_browser_t* browser); + + /// + /// Called just before a browser is destroyed. Release all references to the + /// browser object and do not attempt to execute any functions on the browser + /// object (other than IsValid, GetIdentifier or IsSame) after this callback + /// returns. cef_frame_handler_t callbacks related to final main frame + /// destruction will arrive after this callback and cef_browser_t::IsValid + /// will return false (0) at that time. Any in-progress network requests + /// associated with |browser| will be aborted when the browser is destroyed, + /// and cef_resource_request_handler_t callbacks related to those requests may + /// still arrive on the IO thread after this callback. See cef_frame_handler_t + /// and do_close() documentation for additional usage information. + /// + void(CEF_CALLBACK* on_before_close)(struct _cef_life_span_handler_t* self, + struct _cef_browser_t* browser); +} cef_life_span_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_ diff --git a/include/capi/cef_load_handler_capi.h b/include/capi/cef_load_handler_capi.h new file mode 100644 index 00000000..3667b868 --- /dev/null +++ b/include/capi/cef_load_handler_capi.h @@ -0,0 +1,126 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=1ee684174554f7d1cf8899992705d072c1c56ae7$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_frame_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events related to browser load status. +/// The functions of this structure will be called on the browser process UI +/// thread or render process main thread (TID_RENDERER). +/// +typedef struct _cef_load_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when the loading state has changed. This callback will be executed + /// twice -- once when loading is initiated either programmatically or by user + /// action, and once when loading is terminated due to completion, + /// cancellation of failure. It will be called before any calls to OnLoadStart + /// and after all calls to OnLoadError and/or OnLoadEnd. + /// + void(CEF_CALLBACK* on_loading_state_change)(struct _cef_load_handler_t* self, + struct _cef_browser_t* browser, + int isLoading, + int canGoBack, + int canGoForward); + + /// + /// Called after a navigation has been committed and before the browser begins + /// loading contents in the frame. The |frame| value will never be NULL -- + /// call the is_main() function to check if this frame is the main frame. + /// |transition_type| provides information about the source of the navigation + /// and an accurate value is only available in the browser process. Multiple + /// frames may be loading at the same time. Sub-frames may start or continue + /// loading after the main frame load has ended. This function will not be + /// called for same page navigations (fragments, history state, etc.) or for + /// navigations that fail or are canceled before commit. For notification of + /// overall browser load status use OnLoadingStateChange instead. + /// + void(CEF_CALLBACK* on_load_start)(struct _cef_load_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + cef_transition_type_t transition_type); + + /// + /// Called when the browser is done loading a frame. The |frame| value will + /// never be NULL -- call the is_main() function to check if this frame is the + /// main frame. Multiple frames may be loading at the same time. Sub-frames + /// may start or continue loading after the main frame load has ended. This + /// function will not be called for same page navigations (fragments, history + /// state, etc.) or for navigations that fail or are canceled before commit. + /// For notification of overall browser load status use OnLoadingStateChange + /// instead. + /// + void(CEF_CALLBACK* on_load_end)(struct _cef_load_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + int httpStatusCode); + + /// + /// Called when a navigation fails or is canceled. This function may be called + /// by itself if before commit or in combination with OnLoadStart/OnLoadEnd if + /// after commit. |errorCode| is the error code number, |errorText| is the + /// error text and |failedUrl| is the URL that failed to load. See + /// net\base\net_error_list.h for complete descriptions of the error codes. + /// + void(CEF_CALLBACK* on_load_error)(struct _cef_load_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + cef_errorcode_t errorCode, + const cef_string_t* errorText, + const cef_string_t* failedUrl); +} cef_load_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_ diff --git a/include/capi/cef_media_access_handler_capi.h b/include/capi/cef_media_access_handler_capi.h new file mode 100644 index 00000000..3b8c9a82 --- /dev/null +++ b/include/capi/cef_media_access_handler_capi.h @@ -0,0 +1,108 @@ +// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=91101808168ec0faf1f39b1924579e31478a6616$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_MEDIA_ACCESS_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_MEDIA_ACCESS_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +// Callback structure used for asynchronous continuation of media access +// permission requests. +/// +typedef struct _cef_media_access_callback_t { + /// + // Base structure. + /// + cef_base_ref_counted_t base; + + /// + // Call to allow or deny media access. If this callback was initiated in + // response to a getUserMedia (indicated by + // CEF_MEDIA_PERMISSION_DEVICE_AUDIO_CAPTURE and/or + // CEF_MEDIA_PERMISSION_DEVICE_VIDEO_CAPTURE being set) the + // |allowed_permissions| are required to match those given in + // |required_permissions| in the OnRequestMediaAccessPermission. + /// + void(CEF_CALLBACK* cont)(struct _cef_media_access_callback_t* self, + int allowed_permissions); + + /// + // Cancel the media access request. + /// + void(CEF_CALLBACK* cancel)(struct _cef_media_access_callback_t* self); +} cef_media_access_callback_t; + +/// +// Implement this structure to handle events related to media access permission +// requests. The functions of this structure will be called on the browser +// process UI thread. +/// +typedef struct _cef_media_access_handler_t { + /// + // Base structure. + /// + cef_base_ref_counted_t base; + + /// + // Called when a page requests permission to access media. |requesting_url| is + // the URL requesting permission. Return true (1) and call + // cef_media_access_callback_t::cont() either in this function or at a later + // time to continue or cancel the request. Return false (0) to cancel the + // request immediately. + /// + int(CEF_CALLBACK* on_request_media_access_permission)( + struct _cef_media_access_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + const cef_string_t* requesting_url, + int32_t requested_permissions, + struct _cef_media_access_callback_t* callback); +} cef_media_access_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_MEDIA_ACCESS_HANDLER_CAPI_H_ diff --git a/include/capi/cef_media_router_capi.h b/include/capi/cef_media_router_capi.h new file mode 100644 index 00000000..27f9d0e1 --- /dev/null +++ b/include/capi/cef_media_router_capi.h @@ -0,0 +1,342 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=de4a9b856c6951231f446991a9b1efb89096ad3b$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_callback_capi.h" +#include "include/capi/cef_registration_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_media_observer_t; +struct _cef_media_route_create_callback_t; +struct _cef_media_route_t; +struct _cef_media_sink_device_info_callback_t; +struct _cef_media_sink_t; +struct _cef_media_source_t; + +/// +/// Supports discovery of and communication with media devices on the local +/// network via the Cast and DIAL protocols. The functions of this structure may +/// be called on any browser process thread unless otherwise indicated. +/// +typedef struct _cef_media_router_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Add an observer for MediaRouter events. The observer will remain + /// registered until the returned Registration object is destroyed. + /// + struct _cef_registration_t*(CEF_CALLBACK* add_observer)( + struct _cef_media_router_t* self, + struct _cef_media_observer_t* observer); + + /// + /// Returns a MediaSource object for the specified media source URN. Supported + /// URN schemes include "cast:" and "dial:", and will be already known by the + /// client application (e.g. "cast:<appId>?clientId=<clientId>"). + /// + struct _cef_media_source_t*(CEF_CALLBACK* get_source)( + struct _cef_media_router_t* self, + const cef_string_t* urn); + + /// + /// Trigger an asynchronous call to cef_media_observer_t::OnSinks on all + /// registered observers. + /// + void(CEF_CALLBACK* notify_current_sinks)(struct _cef_media_router_t* self); + + /// + /// Create a new route between |source| and |sink|. Source and sink must be + /// valid, compatible (as reported by cef_media_sink_t::IsCompatibleWith), and + /// a route between them must not already exist. |callback| will be executed + /// on success or failure. If route creation succeeds it will also trigger an + /// asynchronous call to cef_media_observer_t::OnRoutes on all registered + /// observers. + /// + void(CEF_CALLBACK* create_route)( + struct _cef_media_router_t* self, + struct _cef_media_source_t* source, + struct _cef_media_sink_t* sink, + struct _cef_media_route_create_callback_t* callback); + + /// + /// Trigger an asynchronous call to cef_media_observer_t::OnRoutes on all + /// registered observers. + /// + void(CEF_CALLBACK* notify_current_routes)(struct _cef_media_router_t* self); +} cef_media_router_t; + +/// +/// Returns the MediaRouter object associated with the global request context. +/// If |callback| is non-NULL it will be executed asnychronously on the UI +/// thread after the manager's storage has been initialized. Equivalent to +/// calling cef_request_context_t::cef_request_context_get_global_context()->get +/// _media_router(). +/// +CEF_EXPORT cef_media_router_t* cef_media_router_get_global( + struct _cef_completion_callback_t* callback); + +/// +/// Implemented by the client to observe MediaRouter events and registered via +/// cef_media_router_t::AddObserver. The functions of this structure will be +/// called on the browser process UI thread. +/// +typedef struct _cef_media_observer_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// The list of available media sinks has changed or + /// cef_media_router_t::NotifyCurrentSinks was called. + /// + void(CEF_CALLBACK* on_sinks)(struct _cef_media_observer_t* self, + size_t sinksCount, + struct _cef_media_sink_t* const* sinks); + + /// + /// The list of available media routes has changed or + /// cef_media_router_t::NotifyCurrentRoutes was called. + /// + void(CEF_CALLBACK* on_routes)(struct _cef_media_observer_t* self, + size_t routesCount, + struct _cef_media_route_t* const* routes); + + /// + /// The connection state of |route| has changed. + /// + void(CEF_CALLBACK* on_route_state_changed)( + struct _cef_media_observer_t* self, + struct _cef_media_route_t* route, + cef_media_route_connection_state_t state); + + /// + /// A message was recieved over |route|. |message| is only valid for the scope + /// of this callback and should be copied if necessary. + /// + void(CEF_CALLBACK* on_route_message_received)( + struct _cef_media_observer_t* self, + struct _cef_media_route_t* route, + const void* message, + size_t message_size); +} cef_media_observer_t; + +/// +/// Represents the route between a media source and sink. Instances of this +/// object are created via cef_media_router_t::CreateRoute and retrieved via +/// cef_media_observer_t::OnRoutes. Contains the status and metadata of a +/// routing operation. The functions of this structure may be called on any +/// browser process thread unless otherwise indicated. +/// +typedef struct _cef_media_route_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the ID for this route. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_id)(struct _cef_media_route_t* self); + + /// + /// Returns the source associated with this route. + /// + struct _cef_media_source_t*(CEF_CALLBACK* get_source)( + struct _cef_media_route_t* self); + + /// + /// Returns the sink associated with this route. + /// + struct _cef_media_sink_t*(CEF_CALLBACK* get_sink)( + struct _cef_media_route_t* self); + + /// + /// Send a message over this route. |message| will be copied if necessary. + /// + void(CEF_CALLBACK* send_route_message)(struct _cef_media_route_t* self, + const void* message, + size_t message_size); + + /// + /// Terminate this route. Will result in an asynchronous call to + /// cef_media_observer_t::OnRoutes on all registered observers. + /// + void(CEF_CALLBACK* terminate)(struct _cef_media_route_t* self); +} cef_media_route_t; + +/// +/// Callback structure for cef_media_router_t::CreateRoute. The functions of +/// this structure will be called on the browser process UI thread. +/// +typedef struct _cef_media_route_create_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be executed when the route creation has finished. + /// |result| will be CEF_MRCR_OK if the route creation succeeded. |error| will + /// be a description of the error if the route creation failed. |route| is the + /// resulting route, or NULL if the route creation failed. + /// + void(CEF_CALLBACK* on_media_route_create_finished)( + struct _cef_media_route_create_callback_t* self, + cef_media_route_create_result_t result, + const cef_string_t* error, + struct _cef_media_route_t* route); +} cef_media_route_create_callback_t; + +/// +/// Represents a sink to which media can be routed. Instances of this object are +/// retrieved via cef_media_observer_t::OnSinks. The functions of this structure +/// may be called on any browser process thread unless otherwise indicated. +/// +typedef struct _cef_media_sink_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the ID for this sink. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_id)(struct _cef_media_sink_t* self); + + /// + /// Returns the name of this sink. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_name)(struct _cef_media_sink_t* self); + + /// + /// Returns the icon type for this sink. + /// + cef_media_sink_icon_type_t(CEF_CALLBACK* get_icon_type)( + struct _cef_media_sink_t* self); + + /// + /// Asynchronously retrieves device info. + /// + void(CEF_CALLBACK* get_device_info)( + struct _cef_media_sink_t* self, + struct _cef_media_sink_device_info_callback_t* callback); + + /// + /// Returns true (1) if this sink accepts content via Cast. + /// + int(CEF_CALLBACK* is_cast_sink)(struct _cef_media_sink_t* self); + + /// + /// Returns true (1) if this sink accepts content via DIAL. + /// + int(CEF_CALLBACK* is_dial_sink)(struct _cef_media_sink_t* self); + + /// + /// Returns true (1) if this sink is compatible with |source|. + /// + int(CEF_CALLBACK* is_compatible_with)(struct _cef_media_sink_t* self, + struct _cef_media_source_t* source); +} cef_media_sink_t; + +/// +/// Callback structure for cef_media_sink_t::GetDeviceInfo. The functions of +/// this structure will be called on the browser process UI thread. +/// +typedef struct _cef_media_sink_device_info_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be executed asyncronously once device information has + /// been retrieved. + /// + void(CEF_CALLBACK* on_media_sink_device_info)( + struct _cef_media_sink_device_info_callback_t* self, + const struct _cef_media_sink_device_info_t* device_info); +} cef_media_sink_device_info_callback_t; + +/// +/// Represents a source from which media can be routed. Instances of this object +/// are retrieved via cef_media_router_t::GetSource. The functions of this +/// structure may be called on any browser process thread unless otherwise +/// indicated. +/// +typedef struct _cef_media_source_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the ID (media source URN or URL) for this source. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_id)(struct _cef_media_source_t* self); + + /// + /// Returns true (1) if this source outputs its content via Cast. + /// + int(CEF_CALLBACK* is_cast_source)(struct _cef_media_source_t* self); + + /// + /// Returns true (1) if this source outputs its content via DIAL. + /// + int(CEF_CALLBACK* is_dial_source)(struct _cef_media_source_t* self); +} cef_media_source_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_ diff --git a/include/capi/cef_menu_model_capi.h b/include/capi/cef_menu_model_capi.h new file mode 100644 index 00000000..8b5bd663 --- /dev/null +++ b/include/capi/cef_menu_model_capi.h @@ -0,0 +1,517 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=d70b78b8108bb08b4f53b2627ed4ebfdffece7c1$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_menu_model_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Supports creation and modification of menus. See cef_menu_id_t for the +/// command ids that have default implementations. All user-defined command ids +/// should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The functions of +/// this structure can only be accessed on the browser process the UI thread. +/// +typedef struct _cef_menu_model_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this menu is a submenu. + /// + int(CEF_CALLBACK* is_sub_menu)(struct _cef_menu_model_t* self); + + /// + /// Clears the menu. Returns true (1) on success. + /// + int(CEF_CALLBACK* clear)(struct _cef_menu_model_t* self); + + /// + /// Returns the number of items in this menu. + /// + size_t(CEF_CALLBACK* get_count)(struct _cef_menu_model_t* self); + + /// + /// Add a separator to the menu. Returns true (1) on success. + /// + int(CEF_CALLBACK* add_separator)(struct _cef_menu_model_t* self); + + /// + /// Add an item to the menu. Returns true (1) on success. + /// + int(CEF_CALLBACK* add_item)(struct _cef_menu_model_t* self, + int command_id, + const cef_string_t* label); + + /// + /// Add a check item to the menu. Returns true (1) on success. + /// + int(CEF_CALLBACK* add_check_item)(struct _cef_menu_model_t* self, + int command_id, + const cef_string_t* label); + + /// + /// Add a radio item to the menu. Only a single item with the specified + /// |group_id| can be checked at a time. Returns true (1) on success. + /// + int(CEF_CALLBACK* add_radio_item)(struct _cef_menu_model_t* self, + int command_id, + const cef_string_t* label, + int group_id); + + /// + /// Add a sub-menu to the menu. The new sub-menu is returned. + /// + struct _cef_menu_model_t*(CEF_CALLBACK* add_sub_menu)( + struct _cef_menu_model_t* self, + int command_id, + const cef_string_t* label); + + /// + /// Insert a separator in the menu at the specified |index|. Returns true (1) + /// on success. + /// + int(CEF_CALLBACK* insert_separator_at)(struct _cef_menu_model_t* self, + size_t index); + + /// + /// Insert an item in the menu at the specified |index|. Returns true (1) on + /// success. + /// + int(CEF_CALLBACK* insert_item_at)(struct _cef_menu_model_t* self, + size_t index, + int command_id, + const cef_string_t* label); + + /// + /// Insert a check item in the menu at the specified |index|. Returns true (1) + /// on success. + /// + int(CEF_CALLBACK* insert_check_item_at)(struct _cef_menu_model_t* self, + size_t index, + int command_id, + const cef_string_t* label); + + /// + /// Insert a radio item in the menu at the specified |index|. Only a single + /// item with the specified |group_id| can be checked at a time. Returns true + /// (1) on success. + /// + int(CEF_CALLBACK* insert_radio_item_at)(struct _cef_menu_model_t* self, + size_t index, + int command_id, + const cef_string_t* label, + int group_id); + + /// + /// Insert a sub-menu in the menu at the specified |index|. The new sub-menu + /// is returned. + /// + struct _cef_menu_model_t*(CEF_CALLBACK* insert_sub_menu_at)( + struct _cef_menu_model_t* self, + size_t index, + int command_id, + const cef_string_t* label); + + /// + /// Removes the item with the specified |command_id|. Returns true (1) on + /// success. + /// + int(CEF_CALLBACK* remove)(struct _cef_menu_model_t* self, int command_id); + + /// + /// Removes the item at the specified |index|. Returns true (1) on success. + /// + int(CEF_CALLBACK* remove_at)(struct _cef_menu_model_t* self, size_t index); + + /// + /// Returns the index associated with the specified |command_id| or -1 if not + /// found due to the command id not existing in the menu. + /// + int(CEF_CALLBACK* get_index_of)(struct _cef_menu_model_t* self, + int command_id); + + /// + /// Returns the command id at the specified |index| or -1 if not found due to + /// invalid range or the index being a separator. + /// + int(CEF_CALLBACK* get_command_id_at)(struct _cef_menu_model_t* self, + size_t index); + + /// + /// Sets the command id at the specified |index|. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_command_id_at)(struct _cef_menu_model_t* self, + size_t index, + int command_id); + + /// + /// Returns the label for the specified |command_id| or NULL if not found. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_label)(struct _cef_menu_model_t* self, + int command_id); + + /// + /// Returns the label at the specified |index| or NULL if not found due to + /// invalid range or the index being a separator. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t( + CEF_CALLBACK* get_label_at)(struct _cef_menu_model_t* self, size_t index); + + /// + /// Sets the label for the specified |command_id|. Returns true (1) on + /// success. + /// + int(CEF_CALLBACK* set_label)(struct _cef_menu_model_t* self, + int command_id, + const cef_string_t* label); + + /// + /// Set the label at the specified |index|. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_label_at)(struct _cef_menu_model_t* self, + size_t index, + const cef_string_t* label); + + /// + /// Returns the item type for the specified |command_id|. + /// + cef_menu_item_type_t(CEF_CALLBACK* get_type)(struct _cef_menu_model_t* self, + int command_id); + + /// + /// Returns the item type at the specified |index|. + /// + cef_menu_item_type_t( + CEF_CALLBACK* get_type_at)(struct _cef_menu_model_t* self, size_t index); + + /// + /// Returns the group id for the specified |command_id| or -1 if invalid. + /// + int(CEF_CALLBACK* get_group_id)(struct _cef_menu_model_t* self, + int command_id); + + /// + /// Returns the group id at the specified |index| or -1 if invalid. + /// + int(CEF_CALLBACK* get_group_id_at)(struct _cef_menu_model_t* self, + size_t index); + + /// + /// Sets the group id for the specified |command_id|. Returns true (1) on + /// success. + /// + int(CEF_CALLBACK* set_group_id)(struct _cef_menu_model_t* self, + int command_id, + int group_id); + + /// + /// Sets the group id at the specified |index|. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_group_id_at)(struct _cef_menu_model_t* self, + size_t index, + int group_id); + + /// + /// Returns the submenu for the specified |command_id| or NULL if invalid. + /// + struct _cef_menu_model_t*(CEF_CALLBACK* get_sub_menu)( + struct _cef_menu_model_t* self, + int command_id); + + /// + /// Returns the submenu at the specified |index| or NULL if invalid. + /// + struct _cef_menu_model_t*(CEF_CALLBACK* get_sub_menu_at)( + struct _cef_menu_model_t* self, + size_t index); + + /// + /// Returns true (1) if the specified |command_id| is visible. + /// + int(CEF_CALLBACK* is_visible)(struct _cef_menu_model_t* self, int command_id); + + /// + /// Returns true (1) if the specified |index| is visible. + /// + int(CEF_CALLBACK* is_visible_at)(struct _cef_menu_model_t* self, + size_t index); + + /// + /// Change the visibility of the specified |command_id|. Returns true (1) on + /// success. + /// + int(CEF_CALLBACK* set_visible)(struct _cef_menu_model_t* self, + int command_id, + int visible); + + /// + /// Change the visibility at the specified |index|. Returns true (1) on + /// success. + /// + int(CEF_CALLBACK* set_visible_at)(struct _cef_menu_model_t* self, + size_t index, + int visible); + + /// + /// Returns true (1) if the specified |command_id| is enabled. + /// + int(CEF_CALLBACK* is_enabled)(struct _cef_menu_model_t* self, int command_id); + + /// + /// Returns true (1) if the specified |index| is enabled. + /// + int(CEF_CALLBACK* is_enabled_at)(struct _cef_menu_model_t* self, + size_t index); + + /// + /// Change the enabled status of the specified |command_id|. Returns true (1) + /// on success. + /// + int(CEF_CALLBACK* set_enabled)(struct _cef_menu_model_t* self, + int command_id, + int enabled); + + /// + /// Change the enabled status at the specified |index|. Returns true (1) on + /// success. + /// + int(CEF_CALLBACK* set_enabled_at)(struct _cef_menu_model_t* self, + size_t index, + int enabled); + + /// + /// Returns true (1) if the specified |command_id| is checked. Only applies to + /// check and radio items. + /// + int(CEF_CALLBACK* is_checked)(struct _cef_menu_model_t* self, int command_id); + + /// + /// Returns true (1) if the specified |index| is checked. Only applies to + /// check and radio items. + /// + int(CEF_CALLBACK* is_checked_at)(struct _cef_menu_model_t* self, + size_t index); + + /// + /// Check the specified |command_id|. Only applies to check and radio items. + /// Returns true (1) on success. + /// + int(CEF_CALLBACK* set_checked)(struct _cef_menu_model_t* self, + int command_id, + int checked); + + /// + /// Check the specified |index|. Only applies to check and radio items. + /// Returns true (1) on success. + /// + int(CEF_CALLBACK* set_checked_at)(struct _cef_menu_model_t* self, + size_t index, + int checked); + + /// + /// Returns true (1) if the specified |command_id| has a keyboard accelerator + /// assigned. + /// + int(CEF_CALLBACK* has_accelerator)(struct _cef_menu_model_t* self, + int command_id); + + /// + /// Returns true (1) if the specified |index| has a keyboard accelerator + /// assigned. + /// + int(CEF_CALLBACK* has_accelerator_at)(struct _cef_menu_model_t* self, + size_t index); + + /// + /// Set the keyboard accelerator for the specified |command_id|. |key_code| + /// can be any virtual key or character value. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_accelerator)(struct _cef_menu_model_t* self, + int command_id, + int key_code, + int shift_pressed, + int ctrl_pressed, + int alt_pressed); + + /// + /// Set the keyboard accelerator at the specified |index|. |key_code| can be + /// any virtual key or character value. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_accelerator_at)(struct _cef_menu_model_t* self, + size_t index, + int key_code, + int shift_pressed, + int ctrl_pressed, + int alt_pressed); + + /// + /// Remove the keyboard accelerator for the specified |command_id|. Returns + /// true (1) on success. + /// + int(CEF_CALLBACK* remove_accelerator)(struct _cef_menu_model_t* self, + int command_id); + + /// + /// Remove the keyboard accelerator at the specified |index|. Returns true (1) + /// on success. + /// + int(CEF_CALLBACK* remove_accelerator_at)(struct _cef_menu_model_t* self, + size_t index); + + /// + /// Retrieves the keyboard accelerator for the specified |command_id|. Returns + /// true (1) on success. + /// + int(CEF_CALLBACK* get_accelerator)(struct _cef_menu_model_t* self, + int command_id, + int* key_code, + int* shift_pressed, + int* ctrl_pressed, + int* alt_pressed); + + /// + /// Retrieves the keyboard accelerator for the specified |index|. Returns true + /// (1) on success. + /// + int(CEF_CALLBACK* get_accelerator_at)(struct _cef_menu_model_t* self, + size_t index, + int* key_code, + int* shift_pressed, + int* ctrl_pressed, + int* alt_pressed); + + /// + /// Set the explicit color for |command_id| and |color_type| to |color|. + /// Specify a |color| value of 0 to remove the explicit color. If no explicit + /// color or default color is set for |color_type| then the system color will + /// be used. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_color)(struct _cef_menu_model_t* self, + int command_id, + cef_menu_color_type_t color_type, + cef_color_t color); + + /// + /// Set the explicit color for |command_id| and |index| to |color|. Specify a + /// |color| value of 0 to remove the explicit color. Specify an |index| value + /// of -1 to set the default color for items that do not have an explicit + /// color set. If no explicit color or default color is set for |color_type| + /// then the system color will be used. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_color_at)(struct _cef_menu_model_t* self, + int index, + cef_menu_color_type_t color_type, + cef_color_t color); + + /// + /// Returns in |color| the color that was explicitly set for |command_id| and + /// |color_type|. If a color was not set then 0 will be returned in |color|. + /// Returns true (1) on success. + /// + int(CEF_CALLBACK* get_color)(struct _cef_menu_model_t* self, + int command_id, + cef_menu_color_type_t color_type, + cef_color_t* color); + + /// + /// Returns in |color| the color that was explicitly set for |command_id| and + /// |color_type|. Specify an |index| value of -1 to return the default color + /// in |color|. If a color was not set then 0 will be returned in |color|. + /// Returns true (1) on success. + /// + int(CEF_CALLBACK* get_color_at)(struct _cef_menu_model_t* self, + int index, + cef_menu_color_type_t color_type, + cef_color_t* color); + + /// + /// Sets the font list for the specified |command_id|. If |font_list| is NULL + /// the system font will be used. Returns true (1) on success. The format is + /// "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where: - FONT_FAMILY_LIST is a + /// comma-separated list of font family names, - STYLES is an optional space- + /// separated list of style names + /// (case-sensitive "Bold" and "Italic" are supported), and + /// - SIZE is an integer font size in pixels with the suffix "px". + /// + /// Here are examples of valid font description strings: - "Arial, Helvetica, + /// Bold Italic 14px" - "Arial, 14px" + /// + int(CEF_CALLBACK* set_font_list)(struct _cef_menu_model_t* self, + int command_id, + const cef_string_t* font_list); + + /// + /// Sets the font list for the specified |index|. Specify an |index| value of + /// -1 to set the default font. If |font_list| is NULL the system font will be + /// used. Returns true (1) on success. The format is + /// "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where: - FONT_FAMILY_LIST is a + /// comma-separated list of font family names, - STYLES is an optional space- + /// separated list of style names + /// (case-sensitive "Bold" and "Italic" are supported), and + /// - SIZE is an integer font size in pixels with the suffix "px". + /// + /// Here are examples of valid font description strings: - "Arial, Helvetica, + /// Bold Italic 14px" - "Arial, 14px" + /// + int(CEF_CALLBACK* set_font_list_at)(struct _cef_menu_model_t* self, + int index, + const cef_string_t* font_list); +} cef_menu_model_t; + +/// +/// Create a new MenuModel with the specified |delegate|. +/// +CEF_EXPORT cef_menu_model_t* cef_menu_model_create( + struct _cef_menu_model_delegate_t* delegate); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_ diff --git a/include/capi/cef_menu_model_delegate_capi.h b/include/capi/cef_menu_model_delegate_capi.h new file mode 100644 index 00000000..dd339c19 --- /dev/null +++ b/include/capi/cef_menu_model_delegate_capi.h @@ -0,0 +1,123 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=933a90dfb7b94a3aba7f2944e4540662dc8c79d7$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_menu_model_t; + +/// +/// Implement this structure to handle menu model events. The functions of this +/// structure will be called on the browser process UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_menu_model_delegate_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Perform the action associated with the specified |command_id| and optional + /// |event_flags|. + /// + void(CEF_CALLBACK* execute_command)(struct _cef_menu_model_delegate_t* self, + struct _cef_menu_model_t* menu_model, + int command_id, + cef_event_flags_t event_flags); + + /// + /// Called when the user moves the mouse outside the menu and over the owning + /// window. + /// + void(CEF_CALLBACK* mouse_outside_menu)( + struct _cef_menu_model_delegate_t* self, + struct _cef_menu_model_t* menu_model, + const cef_point_t* screen_point); + + /// + /// Called on unhandled open submenu keyboard commands. |is_rtl| will be true + /// (1) if the menu is displaying a right-to-left language. + /// + void(CEF_CALLBACK* unhandled_open_submenu)( + struct _cef_menu_model_delegate_t* self, + struct _cef_menu_model_t* menu_model, + int is_rtl); + + /// + /// Called on unhandled close submenu keyboard commands. |is_rtl| will be true + /// (1) if the menu is displaying a right-to-left language. + /// + void(CEF_CALLBACK* unhandled_close_submenu)( + struct _cef_menu_model_delegate_t* self, + struct _cef_menu_model_t* menu_model, + int is_rtl); + + /// + /// The menu is about to show. + /// + void(CEF_CALLBACK* menu_will_show)(struct _cef_menu_model_delegate_t* self, + struct _cef_menu_model_t* menu_model); + + /// + /// The menu has closed. + /// + void(CEF_CALLBACK* menu_closed)(struct _cef_menu_model_delegate_t* self, + struct _cef_menu_model_t* menu_model); + + /// + /// Optionally modify a menu item label. Return true (1) if |label| was + /// modified. + /// + int(CEF_CALLBACK* format_label)(struct _cef_menu_model_delegate_t* self, + struct _cef_menu_model_t* menu_model, + cef_string_t* label); +} cef_menu_model_delegate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_ diff --git a/include/capi/cef_navigation_entry_capi.h b/include/capi/cef_navigation_entry_capi.h new file mode 100644 index 00000000..863c11d4 --- /dev/null +++ b/include/capi/cef_navigation_entry_capi.h @@ -0,0 +1,133 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=d33771c31b7b0964aa2ccf1c2bc2ca1226194977$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_ssl_status_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used to represent an entry in navigation history. +/// +typedef struct _cef_navigation_entry_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. Do not call any other functions + /// if this function returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_navigation_entry_t* self); + + /// + /// Returns the actual URL of the page. For some pages this may be data: URL + /// or similar. Use get_display_url() to return a display-friendly version. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_url)( + struct _cef_navigation_entry_t* self); + + /// + /// Returns a display-friendly version of the URL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_display_url)( + struct _cef_navigation_entry_t* self); + + /// + /// Returns the original URL that was entered by the user before any + /// redirects. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_original_url)( + struct _cef_navigation_entry_t* self); + + /// + /// Returns the title set by the page. This value may be NULL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_title)( + struct _cef_navigation_entry_t* self); + + /// + /// Returns the transition type which indicates what the user did to move to + /// this page from the previous page. + /// + cef_transition_type_t(CEF_CALLBACK* get_transition_type)( + struct _cef_navigation_entry_t* self); + + /// + /// Returns true (1) if this navigation includes post data. + /// + int(CEF_CALLBACK* has_post_data)(struct _cef_navigation_entry_t* self); + + /// + /// Returns the time for the last known successful navigation completion. A + /// navigation may be completed more than once if the page is reloaded. May be + /// 0 if the navigation has not yet completed. + /// + cef_basetime_t(CEF_CALLBACK* get_completion_time)( + struct _cef_navigation_entry_t* self); + + /// + /// Returns the HTTP status code for the last known successful navigation + /// response. May be 0 if the response has not yet been received or if the + /// navigation has not yet completed. + /// + int(CEF_CALLBACK* get_http_status_code)(struct _cef_navigation_entry_t* self); + + /// + /// Returns the SSL information for this navigation entry. + /// + struct _cef_sslstatus_t*(CEF_CALLBACK* get_sslstatus)( + struct _cef_navigation_entry_t* self); +} cef_navigation_entry_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_ diff --git a/include/capi/cef_origin_whitelist_capi.h b/include/capi/cef_origin_whitelist_capi.h new file mode 100644 index 00000000..9b57f38d --- /dev/null +++ b/include/capi/cef_origin_whitelist_capi.h @@ -0,0 +1,112 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=b564dfe24017a0805e393854d12791a71c46c454$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Add an entry to the cross-origin access whitelist. +/// +/// The same-origin policy restricts how scripts hosted from different origins +/// (scheme + domain + port) can communicate. By default, scripts can only +/// access resources with the same origin. Scripts hosted on the HTTP and HTTPS +/// schemes (but no other schemes) can use the "Access-Control-Allow-Origin" +/// header to allow cross-origin requests. For example, +/// https://source.example.com can make XMLHttpRequest requests on +/// http://target.example.com if the http://target.example.com request returns +/// an "Access-Control-Allow-Origin: https://source.example.com" response +/// header. +/// +/// Scripts in separate frames or iframes and hosted from the same protocol and +/// domain suffix can execute cross-origin JavaScript if both pages set the +/// document.domain value to the same domain suffix. For example, +/// scheme://foo.example.com and scheme://bar.example.com can communicate using +/// JavaScript if both domains set document.domain="example.com". +/// +/// This function is used to allow access to origins that would otherwise +/// violate the same-origin policy. Scripts hosted underneath the fully +/// qualified |source_origin| URL (like http://www.example.com) will be allowed +/// access to all resources hosted on the specified |target_protocol| and +/// |target_domain|. If |target_domain| is non-NULL and +/// |allow_target_subdomains| if false (0) only exact domain matches will be +/// allowed. If |target_domain| contains a top- level domain component (like +/// "example.com") and |allow_target_subdomains| is true (1) sub-domain matches +/// will be allowed. If |target_domain| is NULL and |allow_target_subdomains| if +/// true (1) all domains and IP addresses will be allowed. +/// +/// This function cannot be used to bypass the restrictions on local or display +/// isolated schemes. See the comments on CefRegisterCustomScheme for more +/// information. +/// +/// This function may be called on any thread. Returns false (0) if +/// |source_origin| is invalid or the whitelist cannot be accessed. +/// +CEF_EXPORT int cef_add_cross_origin_whitelist_entry( + const cef_string_t* source_origin, + const cef_string_t* target_protocol, + const cef_string_t* target_domain, + int allow_target_subdomains); + +/// +/// Remove an entry from the cross-origin access whitelist. Returns false (0) if +/// |source_origin| is invalid or the whitelist cannot be accessed. +/// +CEF_EXPORT int cef_remove_cross_origin_whitelist_entry( + const cef_string_t* source_origin, + const cef_string_t* target_protocol, + const cef_string_t* target_domain, + int allow_target_subdomains); + +/// +/// Remove all entries from the cross-origin access whitelist. Returns false (0) +/// if the whitelist cannot be accessed. +/// +CEF_EXPORT int cef_clear_cross_origin_whitelist(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_ diff --git a/include/capi/cef_parser_capi.h b/include/capi/cef_parser_capi.h new file mode 100644 index 00000000..a6410c29 --- /dev/null +++ b/include/capi/cef_parser_capi.h @@ -0,0 +1,184 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=5d6dad4bfaeef0117d068b6e67a8da7490fe7c2d$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Combines specified |base_url| and |relative_url| into |resolved_url|. +/// Returns false (0) if one of the URLs is NULL or invalid. +/// +CEF_EXPORT int cef_resolve_url(const cef_string_t* base_url, + const cef_string_t* relative_url, + cef_string_t* resolved_url); + +/// +/// Parse the specified |url| into its component parts. Returns false (0) if the +/// URL is NULL or invalid. +/// +CEF_EXPORT int cef_parse_url(const cef_string_t* url, + struct _cef_urlparts_t* parts); + +/// +/// Creates a URL from the specified |parts|, which must contain a non-NULL spec +/// or a non-NULL host and path (at a minimum), but not both. Returns false (0) +/// if |parts| isn't initialized as described. +/// +CEF_EXPORT int cef_create_url(const struct _cef_urlparts_t* parts, + cef_string_t* url); + +/// +/// This is a convenience function for formatting a URL in a concise and human- +/// friendly way to help users make security-related decisions (or in other +/// circumstances when people need to distinguish sites, origins, or otherwise- +/// simplified URLs from each other). Internationalized domain names (IDN) may +/// be presented in Unicode if the conversion is considered safe. The returned +/// value will (a) omit the path for standard schemes, excepting file and +/// filesystem, and (b) omit the port if it is the default for the scheme. Do +/// not use this for URLs which will be parsed or sent to other applications. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t +cef_format_url_for_security_display(const cef_string_t* origin_url); + +/// +/// Returns the mime type for the specified file extension or an NULL string if +/// unknown. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t +cef_get_mime_type(const cef_string_t* extension); + +/// +/// Get the extensions associated with the given mime type. This should be +/// passed in lower case. There could be multiple extensions for a given mime +/// type, like "html,htm" for "text/html", or "txt,text,html,..." for "text/*". +/// Any existing elements in the provided vector will not be erased. +/// +CEF_EXPORT void cef_get_extensions_for_mime_type(const cef_string_t* mime_type, + cef_string_list_t extensions); + +/// +/// Encodes |data| as a base64 string. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t cef_base64encode(const void* data, + size_t data_size); + +/// +/// Decodes the base64 encoded string |data|. The returned value will be NULL if +/// the decoding fails. +/// +CEF_EXPORT struct _cef_binary_value_t* cef_base64decode( + const cef_string_t* data); + +/// +/// Escapes characters in |text| which are unsuitable for use as a query +/// parameter value. Everything except alphanumerics and -_.!~*'() will be +/// converted to "%XX". If |use_plus| is true (1) spaces will change to "+". The +/// result is basically the same as encodeURIComponent in Javacript. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t cef_uriencode(const cef_string_t* text, + int use_plus); + +/// +/// Unescapes |text| and returns the result. Unescaping consists of looking for +/// the exact pattern "%XX" where each X is a hex digit and converting to the +/// character with the numerical value of those digits (e.g. "i%20=%203%3b" +/// unescapes to "i = 3;"). If |convert_to_utf8| is true (1) this function will +/// attempt to interpret the initial decoded result as UTF-8. If the result is +/// convertable into UTF-8 it will be returned as converted. Otherwise the +/// initial decoded result will be returned. The |unescape_rule| parameter +/// supports further customization the decoding process. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t +cef_uridecode(const cef_string_t* text, + int convert_to_utf8, + cef_uri_unescape_rule_t unescape_rule); + +/// +/// Parses the specified |json_string| and returns a dictionary or list +/// representation. If JSON parsing fails this function returns NULL. +/// +CEF_EXPORT struct _cef_value_t* cef_parse_json( + const cef_string_t* json_string, + cef_json_parser_options_t options); + +/// +/// Parses the specified UTF8-encoded |json| buffer of size |json_size| and +/// returns a dictionary or list representation. If JSON parsing fails this +/// function returns NULL. +/// +CEF_EXPORT struct _cef_value_t* cef_parse_json_buffer( + const void* json, + size_t json_size, + cef_json_parser_options_t options); + +/// +/// Parses the specified |json_string| and returns a dictionary or list +/// representation. If JSON parsing fails this function returns NULL and +/// populates |error_msg_out| with a formatted error message. +/// +CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error( + const cef_string_t* json_string, + cef_json_parser_options_t options, + cef_string_t* error_msg_out); + +/// +/// Generates a JSON string from the specified root |node| which should be a +/// dictionary or list value. Returns an NULL string on failure. This function +/// requires exclusive access to |node| including any underlying data. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t +cef_write_json(struct _cef_value_t* node, cef_json_writer_options_t options); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_ diff --git a/include/capi/cef_path_util_capi.h b/include/capi/cef_path_util_capi.h new file mode 100644 index 00000000..5706b839 --- /dev/null +++ b/include/capi/cef_path_util_capi.h @@ -0,0 +1,59 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=70b306534b9cb8334c9ea260feacfd8f2f503292$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Retrieve the path associated with the specified |key|. Returns true (1) on +/// success. Can be called on any thread in the browser process. +/// +CEF_EXPORT int cef_get_path(cef_path_key_t key, cef_string_t* path); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_ diff --git a/include/capi/cef_permission_handler_capi.h b/include/capi/cef_permission_handler_capi.h new file mode 100644 index 00000000..67d8f0b9 --- /dev/null +++ b/include/capi/cef_permission_handler_capi.h @@ -0,0 +1,164 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=bc44eb70b7f0b48e0646825e919cb9996ac99781$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Callback structure used for asynchronous continuation of media access +/// permission requests. +/// +typedef struct _cef_media_access_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Call to allow or deny media access. If this callback was initiated in + /// response to a getUserMedia (indicated by + /// CEF_MEDIA_PERMISSION_DEVICE_AUDIO_CAPTURE and/or + /// CEF_MEDIA_PERMISSION_DEVICE_VIDEO_CAPTURE being set) then + /// |allowed_permissions| must match |required_permissions| passed to + /// OnRequestMediaAccessPermission. + /// + void(CEF_CALLBACK* cont)(struct _cef_media_access_callback_t* self, + uint32 allowed_permissions); + + /// + /// Cancel the media access request. + /// + void(CEF_CALLBACK* cancel)(struct _cef_media_access_callback_t* self); +} cef_media_access_callback_t; + +/// +/// Callback structure used for asynchronous continuation of permission prompts. +/// +typedef struct _cef_permission_prompt_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Complete the permissions request with the specified |result|. + /// + void(CEF_CALLBACK* cont)(struct _cef_permission_prompt_callback_t* self, + cef_permission_request_result_t result); +} cef_permission_prompt_callback_t; + +/// +/// Implement this structure to handle events related to permission requests. +/// The functions of this structure will be called on the browser process UI +/// thread. +/// +typedef struct _cef_permission_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when a page requests permission to access media. + /// |requesting_origin| is the URL origin requesting permission. + /// |requested_permissions| is a combination of values from + /// cef_media_access_permission_types_t that represent the requested + /// permissions. Return true (1) and call cef_media_access_callback_t + /// functions either in this function or at a later time to continue or cancel + /// the request. Return false (0) to proceed with default handling. With the + /// Chrome runtime, default handling will display the permission request UI. + /// With the Alloy runtime, default handling will deny the request. This + /// function will not be called if the "--enable-media-stream" command-line + /// switch is used to grant all permissions. + /// + int(CEF_CALLBACK* on_request_media_access_permission)( + struct _cef_permission_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + const cef_string_t* requesting_origin, + uint32 requested_permissions, + struct _cef_media_access_callback_t* callback); + + /// + /// Called when a page should show a permission prompt. |prompt_id| uniquely + /// identifies the prompt. |requesting_origin| is the URL origin requesting + /// permission. |requested_permissions| is a combination of values from + /// cef_permission_request_types_t that represent the requested permissions. + /// Return true (1) and call cef_permission_prompt_callback_t::Continue either + /// in this function or at a later time to continue or cancel the request. + /// Return false (0) to proceed with default handling. With the Chrome + /// runtime, default handling will display the permission prompt UI. With the + /// Alloy runtime, default handling is CEF_PERMISSION_RESULT_IGNORE. + /// + int(CEF_CALLBACK* on_show_permission_prompt)( + struct _cef_permission_handler_t* self, + struct _cef_browser_t* browser, + uint64 prompt_id, + const cef_string_t* requesting_origin, + uint32 requested_permissions, + struct _cef_permission_prompt_callback_t* callback); + + /// + /// Called when a permission prompt handled via OnShowPermissionPrompt is + /// dismissed. |prompt_id| will match the value that was passed to + /// OnShowPermissionPrompt. |result| will be the value passed to + /// cef_permission_prompt_callback_t::Continue or CEF_PERMISSION_RESULT_IGNORE + /// if the dialog was dismissed for other reasons such as navigation, browser + /// closure, etc. This function will not be called if OnShowPermissionPrompt + /// returned false (0) for |prompt_id|. + /// + void(CEF_CALLBACK* on_dismiss_permission_prompt)( + struct _cef_permission_handler_t* self, + struct _cef_browser_t* browser, + uint64 prompt_id, + cef_permission_request_result_t result); +} cef_permission_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_ diff --git a/include/capi/cef_preference_capi.h b/include/capi/cef_preference_capi.h new file mode 100644 index 00000000..fa6d9bd3 --- /dev/null +++ b/include/capi/cef_preference_capi.h @@ -0,0 +1,148 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=922659242ea25c52d02884a7cc5918d086cbfaca$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PREFERENCE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PREFERENCE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure that manages custom preference registrations. +/// +typedef struct _cef_preference_registrar_t { + /// + /// Base structure. + /// + cef_base_scoped_t base; + + /// + /// Register a preference with the specified |name| and |default_value|. To + /// avoid conflicts with built-in preferences the |name| value should contain + /// an application-specific prefix followed by a period (e.g. "myapp.value"). + /// The contents of |default_value| will be copied. The data type for the + /// preference will be inferred from |default_value|'s type and cannot be + /// changed after registration. Returns true (1) on success. Returns false (0) + /// if |name| is already registered or if |default_value| has an invalid type. + /// This function must be called from within the scope of the + /// cef_browser_process_handler_t::OnRegisterCustomPreferences callback. + /// + int(CEF_CALLBACK* add_preference)(struct _cef_preference_registrar_t* self, + const cef_string_t* name, + struct _cef_value_t* default_value); +} cef_preference_registrar_t; + +/// +/// Manage access to preferences. Many built-in preferences are registered by +/// Chromium. Custom preferences can be registered in +/// cef_browser_process_handler_t::OnRegisterCustomPreferences. +/// +typedef struct _cef_preference_manager_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if a preference with the specified |name| exists. This + /// function must be called on the browser process UI thread. + /// + int(CEF_CALLBACK* has_preference)(struct _cef_preference_manager_t* self, + const cef_string_t* name); + + /// + /// Returns the value for the preference with the specified |name|. Returns + /// NULL if the preference does not exist. The returned object contains a copy + /// of the underlying preference value and modifications to the returned + /// object will not modify the underlying preference value. This function must + /// be called on the browser process UI thread. + /// + struct _cef_value_t*(CEF_CALLBACK* get_preference)( + struct _cef_preference_manager_t* self, + const cef_string_t* name); + + /// + /// Returns all preferences as a dictionary. If |include_defaults| is true (1) + /// then preferences currently at their default value will be included. The + /// returned object contains a copy of the underlying preference values and + /// modifications to the returned object will not modify the underlying + /// preference values. This function must be called on the browser process UI + /// thread. + /// + struct _cef_dictionary_value_t*(CEF_CALLBACK* get_all_preferences)( + struct _cef_preference_manager_t* self, + int include_defaults); + + /// + /// Returns true (1) if the preference with the specified |name| can be + /// modified using SetPreference. As one example preferences set via the + /// command-line usually cannot be modified. This function must be called on + /// the browser process UI thread. + /// + int(CEF_CALLBACK* can_set_preference)(struct _cef_preference_manager_t* self, + const cef_string_t* name); + + /// + /// Set the |value| associated with preference |name|. Returns true (1) if the + /// value is set successfully and false (0) otherwise. If |value| is NULL the + /// preference will be restored to its default value. If setting the + /// preference fails then |error| will be populated with a detailed + /// description of the problem. This function must be called on the browser + /// process UI thread. + /// + int(CEF_CALLBACK* set_preference)(struct _cef_preference_manager_t* self, + const cef_string_t* name, + struct _cef_value_t* value, + cef_string_t* error); +} cef_preference_manager_t; + +/// +/// Returns the global preference manager object. +/// +CEF_EXPORT cef_preference_manager_t* cef_preference_manager_get_global(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PREFERENCE_CAPI_H_ diff --git a/include/capi/cef_preference_manager_capi.h b/include/capi/cef_preference_manager_capi.h new file mode 100644 index 00000000..f3d979c2 --- /dev/null +++ b/include/capi/cef_preference_manager_capi.h @@ -0,0 +1,116 @@ +// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=1f5dd49cfc5aeb4b673c10750de01768f5cd2694$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PREFERENCE_MANAGER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PREFERENCE_MANAGER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Manage access to preferences. +/// +typedef struct _cef_preference_manager_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if a preference with the specified |name| exists. This + /// function must be called on the browser process UI thread. + /// + int(CEF_CALLBACK* has_preference)(struct _cef_preference_manager_t* self, + const cef_string_t* name); + + /// + /// Returns the value for the preference with the specified |name|. Returns + /// NULL if the preference does not exist. The returned object contains a copy + /// of the underlying preference value and modifications to the returned + /// object will not modify the underlying preference value. This function must + /// be called on the browser process UI thread. + /// + struct _cef_value_t*(CEF_CALLBACK* get_preference)( + struct _cef_preference_manager_t* self, + const cef_string_t* name); + + /// + /// Returns all preferences as a dictionary. If |include_defaults| is true (1) + /// then preferences currently at their default value will be included. The + /// returned object contains a copy of the underlying preference values and + /// modifications to the returned object will not modify the underlying + /// preference values. This function must be called on the browser process UI + /// thread. + /// + struct _cef_dictionary_value_t*(CEF_CALLBACK* get_all_preferences)( + struct _cef_preference_manager_t* self, + int include_defaults); + + /// + /// Returns true (1) if the preference with the specified |name| can be + /// modified using SetPreference. As one example preferences set via the + /// command-line usually cannot be modified. This function must be called on + /// the browser process UI thread. + /// + int(CEF_CALLBACK* can_set_preference)(struct _cef_preference_manager_t* self, + const cef_string_t* name); + + /// + /// Set the |value| associated with preference |name|. Returns true (1) if the + /// value is set successfully and false (0) otherwise. If |value| is NULL the + /// preference will be restored to its default value. If setting the + /// preference fails then |error| will be populated with a detailed + /// description of the problem. This function must be called on the browser + /// process UI thread. + /// + int(CEF_CALLBACK* set_preference)(struct _cef_preference_manager_t* self, + const cef_string_t* name, + struct _cef_value_t* value, + cef_string_t* error); +} cef_preference_manager_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PREFERENCE_MANAGER_CAPI_H_ diff --git a/include/capi/cef_print_handler_capi.h b/include/capi/cef_print_handler_capi.h new file mode 100644 index 00000000..47e69b1d --- /dev/null +++ b/include/capi/cef_print_handler_capi.h @@ -0,0 +1,160 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=d09937fb047debd9da39c4072a434659b3c5682c$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_print_settings_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Callback structure for asynchronous continuation of print dialog requests. +/// +typedef struct _cef_print_dialog_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Continue printing with the specified |settings|. + /// + void(CEF_CALLBACK* cont)(struct _cef_print_dialog_callback_t* self, + struct _cef_print_settings_t* settings); + + /// + /// Cancel the printing. + /// + void(CEF_CALLBACK* cancel)(struct _cef_print_dialog_callback_t* self); +} cef_print_dialog_callback_t; + +/// +/// Callback structure for asynchronous continuation of print job requests. +/// +typedef struct _cef_print_job_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Indicate completion of the print job. + /// + void(CEF_CALLBACK* cont)(struct _cef_print_job_callback_t* self); +} cef_print_job_callback_t; + +/// +/// Implement this structure to handle printing on Linux. Each browser will have +/// only one print job in progress at a time. The functions of this structure +/// will be called on the browser process UI thread. +/// +typedef struct _cef_print_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when printing has started for the specified |browser|. This + /// function will be called before the other OnPrint*() functions and + /// irrespective of how printing was initiated (e.g. + /// cef_browser_host_t::print(), JavaScript window.print() or PDF extension + /// print button). + /// + void(CEF_CALLBACK* on_print_start)(struct _cef_print_handler_t* self, + struct _cef_browser_t* browser); + + /// + /// Synchronize |settings| with client state. If |get_defaults| is true (1) + /// then populate |settings| with the default print settings. Do not keep a + /// reference to |settings| outside of this callback. + /// + void(CEF_CALLBACK* on_print_settings)(struct _cef_print_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_print_settings_t* settings, + int get_defaults); + + /// + /// Show the print dialog. Execute |callback| once the dialog is dismissed. + /// Return true (1) if the dialog will be displayed or false (0) to cancel the + /// printing immediately. + /// + int(CEF_CALLBACK* on_print_dialog)( + struct _cef_print_handler_t* self, + struct _cef_browser_t* browser, + int has_selection, + struct _cef_print_dialog_callback_t* callback); + + /// + /// Send the print job to the printer. Execute |callback| once the job is + /// completed. Return true (1) if the job will proceed or false (0) to cancel + /// the job immediately. + /// + int(CEF_CALLBACK* on_print_job)(struct _cef_print_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* document_name, + const cef_string_t* pdf_file_path, + struct _cef_print_job_callback_t* callback); + + /// + /// Reset client state related to printing. + /// + void(CEF_CALLBACK* on_print_reset)(struct _cef_print_handler_t* self, + struct _cef_browser_t* browser); + + /// + /// Return the PDF paper size in device units. Used in combination with + /// cef_browser_host_t::print_to_pdf(). + /// + cef_size_t(CEF_CALLBACK* get_pdf_paper_size)( + struct _cef_print_handler_t* self, + struct _cef_browser_t* browser, + int device_units_per_inch); +} cef_print_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_ diff --git a/include/capi/cef_print_settings_capi.h b/include/capi/cef_print_settings_capi.h new file mode 100644 index 00000000..14a52f30 --- /dev/null +++ b/include/capi/cef_print_settings_capi.h @@ -0,0 +1,202 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=46508464579e797d4684f4a7facdb39f9bdb312b$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure representing print settings. +/// +typedef struct _cef_print_settings_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. Do not call any other functions + /// if this function returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_print_settings_t* self); + + /// + /// Returns true (1) if the values of this object are read-only. Some APIs may + /// expose read-only objects. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_print_settings_t* self); + + /// + /// Set the page orientation. + /// + void(CEF_CALLBACK* set_orientation)(struct _cef_print_settings_t* self, + int landscape); + + /// + /// Returns true (1) if the orientation is landscape. + /// + int(CEF_CALLBACK* is_landscape)(struct _cef_print_settings_t* self); + + /// + /// Set the printer printable area in device units. Some platforms already + /// provide flipped area. Set |landscape_needs_flip| to false (0) on those + /// platforms to avoid double flipping. + /// + void(CEF_CALLBACK* set_printer_printable_area)( + struct _cef_print_settings_t* self, + const cef_size_t* physical_size_device_units, + const cef_rect_t* printable_area_device_units, + int landscape_needs_flip); + + /// + /// Set the device name. + /// + void(CEF_CALLBACK* set_device_name)(struct _cef_print_settings_t* self, + const cef_string_t* name); + + /// + /// Get the device name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_device_name)( + struct _cef_print_settings_t* self); + + /// + /// Set the DPI (dots per inch). + /// + void(CEF_CALLBACK* set_dpi)(struct _cef_print_settings_t* self, int dpi); + + /// + /// Get the DPI (dots per inch). + /// + int(CEF_CALLBACK* get_dpi)(struct _cef_print_settings_t* self); + + /// + /// Set the page ranges. + /// + void(CEF_CALLBACK* set_page_ranges)(struct _cef_print_settings_t* self, + size_t rangesCount, + cef_range_t const* ranges); + + /// + /// Returns the number of page ranges that currently exist. + /// + size_t(CEF_CALLBACK* get_page_ranges_count)( + struct _cef_print_settings_t* self); + + /// + /// Retrieve the page ranges. + /// + void(CEF_CALLBACK* get_page_ranges)(struct _cef_print_settings_t* self, + size_t* rangesCount, + cef_range_t* ranges); + + /// + /// Set whether only the selection will be printed. + /// + void(CEF_CALLBACK* set_selection_only)(struct _cef_print_settings_t* self, + int selection_only); + + /// + /// Returns true (1) if only the selection will be printed. + /// + int(CEF_CALLBACK* is_selection_only)(struct _cef_print_settings_t* self); + + /// + /// Set whether pages will be collated. + /// + void(CEF_CALLBACK* set_collate)(struct _cef_print_settings_t* self, + int collate); + + /// + /// Returns true (1) if pages will be collated. + /// + int(CEF_CALLBACK* will_collate)(struct _cef_print_settings_t* self); + + /// + /// Set the color model. + /// + void(CEF_CALLBACK* set_color_model)(struct _cef_print_settings_t* self, + cef_color_model_t model); + + /// + /// Get the color model. + /// + cef_color_model_t(CEF_CALLBACK* get_color_model)( + struct _cef_print_settings_t* self); + + /// + /// Set the number of copies. + /// + void(CEF_CALLBACK* set_copies)(struct _cef_print_settings_t* self, + int copies); + + /// + /// Get the number of copies. + /// + int(CEF_CALLBACK* get_copies)(struct _cef_print_settings_t* self); + + /// + /// Set the duplex mode. + /// + void(CEF_CALLBACK* set_duplex_mode)(struct _cef_print_settings_t* self, + cef_duplex_mode_t mode); + + /// + /// Get the duplex mode. + /// + cef_duplex_mode_t(CEF_CALLBACK* get_duplex_mode)( + struct _cef_print_settings_t* self); +} cef_print_settings_t; + +/// +/// Create a new cef_print_settings_t object. +/// +CEF_EXPORT cef_print_settings_t* cef_print_settings_create(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_ diff --git a/include/capi/cef_process_message_capi.h b/include/capi/cef_process_message_capi.h new file mode 100644 index 00000000..586014c3 --- /dev/null +++ b/include/capi/cef_process_message_capi.h @@ -0,0 +1,111 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=e20a8d6a5803dae5ba156adde40c8b964899b176$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_shared_memory_region_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure representing a message. Can be used on any process and thread. +/// +typedef struct _cef_process_message_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. Do not call any other functions + /// if this function returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_process_message_t* self); + + /// + /// Returns true (1) if the values of this object are read-only. Some APIs may + /// expose read-only objects. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_process_message_t* self); + + /// + /// Returns a writable copy of this object. Returns nullptr when message + /// contains a shared memory region. + /// + struct _cef_process_message_t*(CEF_CALLBACK* copy)( + struct _cef_process_message_t* self); + + /// + /// Returns the message name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_name)( + struct _cef_process_message_t* self); + + /// + /// Returns the list of arguments. Returns nullptr when message contains a + /// shared memory region. + /// + struct _cef_list_value_t*(CEF_CALLBACK* get_argument_list)( + struct _cef_process_message_t* self); + + /// + /// Returns the shared memory region. Returns nullptr when message contains an + /// argument list. + /// + struct _cef_shared_memory_region_t*(CEF_CALLBACK* get_shared_memory_region)( + struct _cef_process_message_t* self); +} cef_process_message_t; + +/// +/// Create a new cef_process_message_t object with the specified name. +/// +CEF_EXPORT cef_process_message_t* cef_process_message_create( + const cef_string_t* name); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_ diff --git a/include/capi/cef_process_util_capi.h b/include/capi/cef_process_util_capi.h new file mode 100644 index 00000000..2ae2c57c --- /dev/null +++ b/include/capi/cef_process_util_capi.h @@ -0,0 +1,65 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=88c42c5f216798304b07bfe985296014cf65996c$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Launches the process specified via |command_line|. Returns true (1) upon +/// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread. +/// +/// Unix-specific notes: - All file descriptors open in the parent process will +/// be closed in the +/// child process except for stdin, stdout, and stderr. +/// - If the first argument on the command line does not contain a slash, +/// PATH will be searched. (See man execvp.) +/// +CEF_EXPORT int cef_launch_process(struct _cef_command_line_t* command_line); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_ diff --git a/include/capi/cef_registration_capi.h b/include/capi/cef_registration_capi.h new file mode 100644 index 00000000..4ac84d67 --- /dev/null +++ b/include/capi/cef_registration_capi.h @@ -0,0 +1,63 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=b1b38a3171dd3626029e70e75b482dfa3531215b$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Generic callback structure used for managing the lifespan of a registration. +/// +typedef struct _cef_registration_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; +} cef_registration_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_ diff --git a/include/capi/cef_render_handler_capi.h b/include/capi/cef_render_handler_capi.h new file mode 100644 index 00000000..ccd3d238 --- /dev/null +++ b/include/capi/cef_render_handler_capi.h @@ -0,0 +1,261 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=32d8176f39b05487bae048990b2dee3212ae3b78$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_accessibility_handler_capi.h" +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_drag_data_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle events when window rendering is disabled. +/// The functions of this structure will be called on the UI thread. +/// +typedef struct _cef_render_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Return the handler for accessibility notifications. If no handler is + /// provided the default implementation will be used. + /// + struct _cef_accessibility_handler_t*(CEF_CALLBACK* get_accessibility_handler)( + struct _cef_render_handler_t* self); + + /// + /// Called to retrieve the root window rectangle in screen DIP coordinates. + /// Return true (1) if the rectangle was provided. If this function returns + /// false (0) the rectangle from GetViewRect will be used. + /// + int(CEF_CALLBACK* get_root_screen_rect)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + cef_rect_t* rect); + + /// + /// Called to retrieve the view rectangle in screen DIP coordinates. This + /// function must always provide a non-NULL rectangle. + /// + void(CEF_CALLBACK* get_view_rect)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + cef_rect_t* rect); + + /// + /// Called to retrieve the translation from view DIP coordinates to screen + /// coordinates. Windows/Linux should provide screen device (pixel) + /// coordinates and MacOS should provide screen DIP coordinates. Return true + /// (1) if the requested coordinates were provided. + /// + int(CEF_CALLBACK* get_screen_point)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + int viewX, + int viewY, + int* screenX, + int* screenY); + + /// + /// Called to allow the client to fill in the CefScreenInfo object with + /// appropriate values. Return true (1) if the |screen_info| structure has + /// been modified. + /// + /// If the screen info rectangle is left NULL the rectangle from GetViewRect + /// will be used. If the rectangle is still NULL or invalid popups may not be + /// drawn correctly. + /// + int(CEF_CALLBACK* get_screen_info)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + cef_screen_info_t* screen_info); + + /// + /// Called when the browser wants to show or hide the popup widget. The popup + /// should be shown if |show| is true (1) and hidden if |show| is false (0). + /// + void(CEF_CALLBACK* on_popup_show)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + int show); + + /// + /// Called when the browser wants to move or resize the popup widget. |rect| + /// contains the new location and size in view coordinates. + /// + void(CEF_CALLBACK* on_popup_size)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + const cef_rect_t* rect); + + /// + /// Called when an element should be painted. Pixel values passed to this + /// function are scaled relative to view coordinates based on the value of + /// CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type| + /// indicates whether the element is the view or the popup widget. |buffer| + /// contains the pixel data for the whole image. |dirtyRects| contains the set + /// of rectangles in pixel coordinates that need to be repainted. |buffer| + /// will be |width|*|height|*4 bytes in size and represents a BGRA image with + /// an upper-left origin. This function is only called when + /// cef_window_tInfo::shared_texture_enabled is set to false (0). + /// + void(CEF_CALLBACK* on_paint)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + cef_paint_element_type_t type, + size_t dirtyRectsCount, + cef_rect_t const* dirtyRects, + const void* buffer, + int width, + int height); + + /// + /// Called when an element has been rendered to the shared texture handle. + /// |type| indicates whether the element is the view or the popup widget. + /// |dirtyRects| contains the set of rectangles in pixel coordinates that need + /// to be repainted. |shared_handle| is the handle for a D3D11 Texture2D that + /// can be accessed via ID3D11Device using the OpenSharedResource function. + /// This function is only called when cef_window_tInfo::shared_texture_enabled + /// is set to true (1), and is currently only supported on Windows. + /// + void(CEF_CALLBACK* on_accelerated_paint)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + cef_paint_element_type_t type, + size_t dirtyRectsCount, + cef_rect_t const* dirtyRects, + void* shared_handle); + + /// + /// Called to retrieve the size of the touch handle for the specified + /// |orientation|. + /// + void(CEF_CALLBACK* get_touch_handle_size)( + struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + cef_horizontal_alignment_t orientation, + cef_size_t* size); + + /// + /// Called when touch handle state is updated. The client is responsible for + /// rendering the touch handles. + /// + void(CEF_CALLBACK* on_touch_handle_state_changed)( + struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + const cef_touch_handle_state_t* state); + + /// + /// Called when the user starts dragging content in the web view. Contextual + /// information about the dragged content is supplied by |drag_data|. (|x|, + /// |y|) is the drag start location in screen coordinates. OS APIs that run a + /// system message loop may be used within the StartDragging call. + /// + /// Return false (0) to abort the drag operation. Don't call any of + /// cef_browser_host_t::DragSource*Ended* functions after returning false (0). + /// + /// Return true (1) to handle the drag operation. Call + /// cef_browser_host_t::DragSourceEndedAt and DragSourceSystemDragEnded either + /// synchronously or asynchronously to inform the web view that the drag + /// operation has ended. + /// + int(CEF_CALLBACK* start_dragging)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_drag_data_t* drag_data, + cef_drag_operations_mask_t allowed_ops, + int x, + int y); + + /// + /// Called when the web view wants to update the mouse cursor during a drag & + /// drop operation. |operation| describes the allowed operation (none, move, + /// copy, link). + /// + void(CEF_CALLBACK* update_drag_cursor)(struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + cef_drag_operations_mask_t operation); + + /// + /// Called when the scroll offset has changed. + /// + void(CEF_CALLBACK* on_scroll_offset_changed)( + struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + double x, + double y); + + /// + /// Called when the IME composition range has changed. |selected_range| is the + /// range of characters that have been selected. |character_bounds| is the + /// bounds of each character in view coordinates. + /// + void(CEF_CALLBACK* on_ime_composition_range_changed)( + struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + const cef_range_t* selected_range, + size_t character_boundsCount, + cef_rect_t const* character_bounds); + + /// + /// Called when text selection has changed for the specified |browser|. + /// |selected_text| is the currently selected text and |selected_range| is the + /// character range. + /// + void(CEF_CALLBACK* on_text_selection_changed)( + struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* selected_text, + const cef_range_t* selected_range); + + /// + /// Called when an on-screen keyboard should be shown or hidden for the + /// specified |browser|. |input_mode| specifies what kind of keyboard should + /// be opened. If |input_mode| is CEF_TEXT_INPUT_MODE_NONE, any existing + /// keyboard for this browser should be hidden. + /// + void(CEF_CALLBACK* on_virtual_keyboard_requested)( + struct _cef_render_handler_t* self, + struct _cef_browser_t* browser, + cef_text_input_mode_t input_mode); +} cef_render_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_ diff --git a/include/capi/cef_render_process_handler_capi.h b/include/capi/cef_render_process_handler_capi.h new file mode 100644 index 00000000..f9c86c94 --- /dev/null +++ b/include/capi/cef_render_process_handler_capi.h @@ -0,0 +1,168 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=d807c7566ce3085243e9e7ea279fee7241acfc5f$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_dom_capi.h" +#include "include/capi/cef_frame_capi.h" +#include "include/capi/cef_load_handler_capi.h" +#include "include/capi/cef_process_message_capi.h" +#include "include/capi/cef_v8_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used to implement render process callbacks. The functions of this +/// structure will be called on the render process main thread (TID_RENDERER) +/// unless otherwise indicated. +/// +typedef struct _cef_render_process_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called after WebKit has been initialized. + /// + void(CEF_CALLBACK* on_web_kit_initialized)( + struct _cef_render_process_handler_t* self); + + /// + /// Called after a browser has been created. When browsing cross-origin a new + /// browser will be created before the old browser with the same identifier is + /// destroyed. |extra_info| is an optional read-only value originating from + /// cef_browser_host_t::cef_browser_host_create_browser(), + /// cef_browser_host_t::cef_browser_host_create_browser_sync(), + /// cef_life_span_handler_t::on_before_popup() or + /// cef_browser_view_t::cef_browser_view_create(). + /// + void(CEF_CALLBACK* on_browser_created)( + struct _cef_render_process_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_dictionary_value_t* extra_info); + + /// + /// Called before a browser is destroyed. + /// + void(CEF_CALLBACK* on_browser_destroyed)( + struct _cef_render_process_handler_t* self, + struct _cef_browser_t* browser); + + /// + /// Return the handler for browser load status events. + /// + struct _cef_load_handler_t*(CEF_CALLBACK* get_load_handler)( + struct _cef_render_process_handler_t* self); + + /// + /// Called immediately after the V8 context for a frame has been created. To + /// retrieve the JavaScript 'window' object use the + /// cef_v8context_t::get_global() function. V8 handles can only be accessed + /// from the thread on which they are created. A task runner for posting tasks + /// on the associated thread can be retrieved via the + /// cef_v8context_t::get_task_runner() function. + /// + void(CEF_CALLBACK* on_context_created)( + struct _cef_render_process_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_v8context_t* context); + + /// + /// Called immediately before the V8 context for a frame is released. No + /// references to the context should be kept after this function is called. + /// + void(CEF_CALLBACK* on_context_released)( + struct _cef_render_process_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_v8context_t* context); + + /// + /// Called for global uncaught exceptions in a frame. Execution of this + /// callback is disabled by default. To enable set + /// cef_settings_t.uncaught_exception_stack_size > 0. + /// + void(CEF_CALLBACK* on_uncaught_exception)( + struct _cef_render_process_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_v8context_t* context, + struct _cef_v8exception_t* exception, + struct _cef_v8stack_trace_t* stackTrace); + + /// + /// Called when a new node in the the browser gets focus. The |node| value may + /// be NULL if no specific node has gained focus. The node object passed to + /// this function represents a snapshot of the DOM at the time this function + /// is executed. DOM objects are only valid for the scope of this function. Do + /// not keep references to or attempt to access any DOM objects outside the + /// scope of this function. + /// + void(CEF_CALLBACK* on_focused_node_changed)( + struct _cef_render_process_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_domnode_t* node); + + /// + /// Called when a new message is received from a different process. Return + /// true (1) if the message was handled or false (0) otherwise. It is safe to + /// keep a reference to |message| outside of this callback. + /// + int(CEF_CALLBACK* on_process_message_received)( + struct _cef_render_process_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + cef_process_id_t source_process, + struct _cef_process_message_t* message); +} cef_render_process_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_ diff --git a/include/capi/cef_request_capi.h b/include/capi/cef_request_capi.h new file mode 100644 index 00000000..9ac91657 --- /dev/null +++ b/include/capi/cef_request_capi.h @@ -0,0 +1,355 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=3339290cad3a77c8b0b07d422f0faf902a047838$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_post_data_element_t; +struct _cef_post_data_t; + +/// +/// Structure used to represent a web request. The functions of this structure +/// may be called on any thread. +/// +typedef struct _cef_request_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is read-only. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_request_t* self); + + /// + /// Get the fully qualified URL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_url)(struct _cef_request_t* self); + + /// + /// Set the fully qualified URL. + /// + void(CEF_CALLBACK* set_url)(struct _cef_request_t* self, + const cef_string_t* url); + + /// + /// Get the request function type. The value will default to POST if post data + /// is provided and GET otherwise. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_method)(struct _cef_request_t* self); + + /// + /// Set the request function type. + /// + void(CEF_CALLBACK* set_method)(struct _cef_request_t* self, + const cef_string_t* method); + + /// + /// Set the referrer URL and policy. If non-NULL the referrer URL must be + /// fully qualified with an HTTP or HTTPS scheme component. Any username, + /// password or ref component will be removed. + /// + void(CEF_CALLBACK* set_referrer)(struct _cef_request_t* self, + const cef_string_t* referrer_url, + cef_referrer_policy_t policy); + + /// + /// Get the referrer URL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_referrer_url)( + struct _cef_request_t* self); + + /// + /// Get the referrer policy. + /// + cef_referrer_policy_t(CEF_CALLBACK* get_referrer_policy)( + struct _cef_request_t* self); + + /// + /// Get the post data. + /// + struct _cef_post_data_t*(CEF_CALLBACK* get_post_data)( + struct _cef_request_t* self); + + /// + /// Set the post data. + /// + void(CEF_CALLBACK* set_post_data)(struct _cef_request_t* self, + struct _cef_post_data_t* postData); + + /// + /// Get the header values. Will not include the Referer value if any. + /// + void(CEF_CALLBACK* get_header_map)(struct _cef_request_t* self, + cef_string_multimap_t headerMap); + + /// + /// Set the header values. If a Referer value exists in the header map it will + /// be removed and ignored. + /// + void(CEF_CALLBACK* set_header_map)(struct _cef_request_t* self, + cef_string_multimap_t headerMap); + + /// + /// Returns the first header value for |name| or an NULL string if not found. + /// Will not return the Referer value if any. Use GetHeaderMap instead if + /// |name| might have multiple values. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_header_by_name)( + struct _cef_request_t* self, + const cef_string_t* name); + + /// + /// Set the header |name| to |value|. If |overwrite| is true (1) any existing + /// values will be replaced with the new value. If |overwrite| is false (0) + /// any existing values will not be overwritten. The Referer value cannot be + /// set using this function. + /// + void(CEF_CALLBACK* set_header_by_name)(struct _cef_request_t* self, + const cef_string_t* name, + const cef_string_t* value, + int overwrite); + + /// + /// Set all values at one time. + /// + void(CEF_CALLBACK* set)(struct _cef_request_t* self, + const cef_string_t* url, + const cef_string_t* method, + struct _cef_post_data_t* postData, + cef_string_multimap_t headerMap); + + /// + /// Get the flags used in combination with cef_urlrequest_t. See + /// cef_urlrequest_flags_t for supported values. + /// + int(CEF_CALLBACK* get_flags)(struct _cef_request_t* self); + + /// + /// Set the flags used in combination with cef_urlrequest_t. See + /// cef_urlrequest_flags_t for supported values. + /// + void(CEF_CALLBACK* set_flags)(struct _cef_request_t* self, int flags); + + /// + /// Get the URL to the first party for cookies used in combination with + /// cef_urlrequest_t. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_first_party_for_cookies)( + struct _cef_request_t* self); + + /// + /// Set the URL to the first party for cookies used in combination with + /// cef_urlrequest_t. + /// + void(CEF_CALLBACK* set_first_party_for_cookies)(struct _cef_request_t* self, + const cef_string_t* url); + + /// + /// Get the resource type for this request. Only available in the browser + /// process. + /// + cef_resource_type_t(CEF_CALLBACK* get_resource_type)( + struct _cef_request_t* self); + + /// + /// Get the transition type for this request. Only available in the browser + /// process and only applies to requests that represent a main frame or sub- + /// frame navigation. + /// + cef_transition_type_t(CEF_CALLBACK* get_transition_type)( + struct _cef_request_t* self); + + /// + /// Returns the globally unique identifier for this request or 0 if not + /// specified. Can be used by cef_resource_request_handler_t implementations + /// in the browser process to track a single request across multiple + /// callbacks. + /// + uint64(CEF_CALLBACK* get_identifier)(struct _cef_request_t* self); +} cef_request_t; + +/// +/// Create a new cef_request_t object. +/// +CEF_EXPORT cef_request_t* cef_request_create(void); + +/// +/// Structure used to represent post data for a web request. The functions of +/// this structure may be called on any thread. +/// +typedef struct _cef_post_data_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is read-only. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_post_data_t* self); + + /// + /// Returns true (1) if the underlying POST data includes elements that are + /// not represented by this cef_post_data_t object (for example, multi-part + /// file upload data). Modifying cef_post_data_t objects with excluded + /// elements may result in the request failing. + /// + int(CEF_CALLBACK* has_excluded_elements)(struct _cef_post_data_t* self); + + /// + /// Returns the number of existing post data elements. + /// + size_t(CEF_CALLBACK* get_element_count)(struct _cef_post_data_t* self); + + /// + /// Retrieve the post data elements. + /// + void(CEF_CALLBACK* get_elements)(struct _cef_post_data_t* self, + size_t* elementsCount, + struct _cef_post_data_element_t** elements); + + /// + /// Remove the specified post data element. Returns true (1) if the removal + /// succeeds. + /// + int(CEF_CALLBACK* remove_element)(struct _cef_post_data_t* self, + struct _cef_post_data_element_t* element); + + /// + /// Add the specified post data element. Returns true (1) if the add + /// succeeds. + /// + int(CEF_CALLBACK* add_element)(struct _cef_post_data_t* self, + struct _cef_post_data_element_t* element); + + /// + /// Remove all existing post data elements. + /// + void(CEF_CALLBACK* remove_elements)(struct _cef_post_data_t* self); +} cef_post_data_t; + +/// +/// Create a new cef_post_data_t object. +/// +CEF_EXPORT cef_post_data_t* cef_post_data_create(void); + +/// +/// Structure used to represent a single element in the request post data. The +/// functions of this structure may be called on any thread. +/// +typedef struct _cef_post_data_element_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is read-only. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_post_data_element_t* self); + + /// + /// Remove all contents from the post data element. + /// + void(CEF_CALLBACK* set_to_empty)(struct _cef_post_data_element_t* self); + + /// + /// The post data element will represent a file. + /// + void(CEF_CALLBACK* set_to_file)(struct _cef_post_data_element_t* self, + const cef_string_t* fileName); + + /// + /// The post data element will represent bytes. The bytes passed in will be + /// copied. + /// + void(CEF_CALLBACK* set_to_bytes)(struct _cef_post_data_element_t* self, + size_t size, + const void* bytes); + + /// + /// Return the type of this post data element. + /// + cef_postdataelement_type_t(CEF_CALLBACK* get_type)( + struct _cef_post_data_element_t* self); + + /// + /// Return the file name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_file)( + struct _cef_post_data_element_t* self); + + /// + /// Return the number of bytes. + /// + size_t(CEF_CALLBACK* get_bytes_count)(struct _cef_post_data_element_t* self); + + /// + /// Read up to |size| bytes into |bytes| and return the number of bytes + /// actually read. + /// + size_t(CEF_CALLBACK* get_bytes)(struct _cef_post_data_element_t* self, + size_t size, + void* bytes); +} cef_post_data_element_t; + +/// +/// Create a new cef_post_data_element_t object. +/// +CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_ diff --git a/include/capi/cef_request_context_capi.h b/include/capi/cef_request_context_capi.h new file mode 100644 index 00000000..58f3ef2d --- /dev/null +++ b/include/capi/cef_request_context_capi.h @@ -0,0 +1,331 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=c2a6265e8e9acce475a8b5755a8c58b97b495207$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_ +#pragma once + +#include "include/capi/cef_callback_capi.h" +#include "include/capi/cef_cookie_capi.h" +#include "include/capi/cef_extension_capi.h" +#include "include/capi/cef_extension_handler_capi.h" +#include "include/capi/cef_media_router_capi.h" +#include "include/capi/cef_preference_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_request_context_handler_t; +struct _cef_scheme_handler_factory_t; + +/// +/// Callback structure for cef_request_context_t::ResolveHost. +/// +typedef struct _cef_resolve_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called on the UI thread after the ResolveHost request has completed. + /// |result| will be the result code. |resolved_ips| will be the list of + /// resolved IP addresses or NULL if the resolution failed. + /// + void(CEF_CALLBACK* on_resolve_completed)(struct _cef_resolve_callback_t* self, + cef_errorcode_t result, + cef_string_list_t resolved_ips); +} cef_resolve_callback_t; + +/// +/// A request context provides request handling for a set of related browser or +/// URL request objects. A request context can be specified when creating a new +/// browser via the cef_browser_host_t static factory functions or when creating +/// a new URL request via the cef_urlrequest_t static factory functions. Browser +/// objects with different request contexts will never be hosted in the same +/// render process. Browser objects with the same request context may or may not +/// be hosted in the same render process depending on the process model. Browser +/// objects created indirectly via the JavaScript window.open function or +/// targeted links will share the same render process and the same request +/// context as the source browser. When running in single-process mode there is +/// only a single render process (the main process) and so all browsers created +/// in single-process mode will share the same request context. This will be the +/// first request context passed into a cef_browser_host_t static factory +/// function and all other request context objects will be ignored. +/// +typedef struct _cef_request_context_t { + /// + /// Base structure. + /// + cef_preference_manager_t base; + + /// + /// Returns true (1) if this object is pointing to the same context as |that| + /// object. + /// + int(CEF_CALLBACK* is_same)(struct _cef_request_context_t* self, + struct _cef_request_context_t* other); + + /// + /// Returns true (1) if this object is sharing the same storage as |that| + /// object. + /// + int(CEF_CALLBACK* is_sharing_with)(struct _cef_request_context_t* self, + struct _cef_request_context_t* other); + + /// + /// Returns true (1) if this object is the global context. The global context + /// is used by default when creating a browser or URL request with a NULL + /// context argument. + /// + int(CEF_CALLBACK* is_global)(struct _cef_request_context_t* self); + + /// + /// Returns the handler for this context if any. + /// + struct _cef_request_context_handler_t*(CEF_CALLBACK* get_handler)( + struct _cef_request_context_t* self); + + /// + /// Returns the cache path for this object. If NULL an "incognito mode" in- + /// memory cache is being used. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_cache_path)( + struct _cef_request_context_t* self); + + /// + /// Returns the cookie manager for this object. If |callback| is non-NULL it + /// will be executed asnychronously on the UI thread after the manager's + /// storage has been initialized. + /// + struct _cef_cookie_manager_t*(CEF_CALLBACK* get_cookie_manager)( + struct _cef_request_context_t* self, + struct _cef_completion_callback_t* callback); + + /// + /// Register a scheme handler factory for the specified |scheme_name| and + /// optional |domain_name|. An NULL |domain_name| value for a standard scheme + /// will cause the factory to match all domain names. The |domain_name| value + /// will be ignored for non-standard schemes. If |scheme_name| is a built-in + /// scheme and no handler is returned by |factory| then the built-in scheme + /// handler factory will be called. If |scheme_name| is a custom scheme then + /// you must also implement the cef_app_t::on_register_custom_schemes() + /// function in all processes. This function may be called multiple times to + /// change or remove the factory that matches the specified |scheme_name| and + /// optional |domain_name|. Returns false (0) if an error occurs. This + /// function may be called on any thread in the browser process. + /// + int(CEF_CALLBACK* register_scheme_handler_factory)( + struct _cef_request_context_t* self, + const cef_string_t* scheme_name, + const cef_string_t* domain_name, + struct _cef_scheme_handler_factory_t* factory); + + /// + /// Clear all registered scheme handler factories. Returns false (0) on error. + /// This function may be called on any thread in the browser process. + /// + int(CEF_CALLBACK* clear_scheme_handler_factories)( + struct _cef_request_context_t* self); + + /// + /// Clears all certificate exceptions that were added as part of handling + /// cef_request_handler_t::on_certificate_error(). If you call this it is + /// recommended that you also call close_all_connections() or you risk not + /// being prompted again for server certificates if you reconnect quickly. If + /// |callback| is non-NULL it will be executed on the UI thread after + /// completion. + /// + void(CEF_CALLBACK* clear_certificate_exceptions)( + struct _cef_request_context_t* self, + struct _cef_completion_callback_t* callback); + + /// + /// Clears all HTTP authentication credentials that were added as part of + /// handling GetAuthCredentials. If |callback| is non-NULL it will be executed + /// on the UI thread after completion. + /// + void(CEF_CALLBACK* clear_http_auth_credentials)( + struct _cef_request_context_t* self, + struct _cef_completion_callback_t* callback); + + /// + /// Clears all active and idle connections that Chromium currently has. This + /// is only recommended if you have released all other CEF objects but don't + /// yet want to call cef_shutdown(). If |callback| is non-NULL it will be + /// executed on the UI thread after completion. + /// + void(CEF_CALLBACK* close_all_connections)( + struct _cef_request_context_t* self, + struct _cef_completion_callback_t* callback); + + /// + /// Attempts to resolve |origin| to a list of associated IP addresses. + /// |callback| will be executed on the UI thread after completion. + /// + void(CEF_CALLBACK* resolve_host)(struct _cef_request_context_t* self, + const cef_string_t* origin, + struct _cef_resolve_callback_t* callback); + + /// + /// Load an extension. + /// + /// If extension resources will be read from disk using the default load + /// implementation then |root_directory| should be the absolute path to the + /// extension resources directory and |manifest| should be NULL. If extension + /// resources will be provided by the client (e.g. via cef_request_handler_t + /// and/or cef_extension_handler_t) then |root_directory| should be a path + /// component unique to the extension (if not absolute this will be internally + /// prefixed with the PK_DIR_RESOURCES path) and |manifest| should contain the + /// contents that would otherwise be read from the "manifest.json" file on + /// disk. + /// + /// The loaded extension will be accessible in all contexts sharing the same + /// storage (HasExtension returns true (1)). However, only the context on + /// which this function was called is considered the loader (DidLoadExtension + /// returns true (1)) and only the loader will receive + /// cef_request_context_handler_t callbacks for the extension. + /// + /// cef_extension_handler_t::OnExtensionLoaded will be called on load success + /// or cef_extension_handler_t::OnExtensionLoadFailed will be called on load + /// failure. + /// + /// If the extension specifies a background script via the "background" + /// manifest key then cef_extension_handler_t::OnBeforeBackgroundBrowser will + /// be called to create the background browser. See that function for + /// additional information about background scripts. + /// + /// For visible extension views the client application should evaluate the + /// manifest to determine the correct extension URL to load and then pass that + /// URL to the cef_browser_host_t::CreateBrowser* function after the extension + /// has loaded. For example, the client can look for the "browser_action" + /// manifest key as documented at + /// https://developer.chrome.com/extensions/browserAction. Extension URLs take + /// the form "chrome-extension://<extension_id>/<path>". + /// + /// Browsers that host extensions differ from normal browsers as follows: + /// - Can access chrome.* JavaScript APIs if allowed by the manifest. Visit + /// chrome://extensions-support for the list of extension APIs currently + /// supported by CEF. + /// - Main frame navigation to non-extension content is blocked. + /// - Pinch-zooming is disabled. + /// - CefBrowserHost::GetExtension returns the hosted extension. + /// - CefBrowserHost::IsBackgroundHost returns true for background hosts. + /// + /// See https://developer.chrome.com/extensions for extension implementation + /// and usage documentation. + /// + void(CEF_CALLBACK* load_extension)(struct _cef_request_context_t* self, + const cef_string_t* root_directory, + struct _cef_dictionary_value_t* manifest, + struct _cef_extension_handler_t* handler); + + /// + /// Returns true (1) if this context was used to load the extension identified + /// by |extension_id|. Other contexts sharing the same storage will also have + /// access to the extension (see HasExtension). This function must be called + /// on the browser process UI thread. + /// + int(CEF_CALLBACK* did_load_extension)(struct _cef_request_context_t* self, + const cef_string_t* extension_id); + + /// + /// Returns true (1) if this context has access to the extension identified by + /// |extension_id|. This may not be the context that was used to load the + /// extension (see DidLoadExtension). This function must be called on the + /// browser process UI thread. + /// + int(CEF_CALLBACK* has_extension)(struct _cef_request_context_t* self, + const cef_string_t* extension_id); + + /// + /// Retrieve the list of all extensions that this context has access to (see + /// HasExtension). |extension_ids| will be populated with the list of + /// extension ID values. Returns true (1) on success. This function must be + /// called on the browser process UI thread. + /// + int(CEF_CALLBACK* get_extensions)(struct _cef_request_context_t* self, + cef_string_list_t extension_ids); + + /// + /// Returns the extension matching |extension_id| or NULL if no matching + /// extension is accessible in this context (see HasExtension). This function + /// must be called on the browser process UI thread. + /// + struct _cef_extension_t*(CEF_CALLBACK* get_extension)( + struct _cef_request_context_t* self, + const cef_string_t* extension_id); + + /// + /// Returns the MediaRouter object associated with this context. If + /// |callback| is non-NULL it will be executed asnychronously on the UI thread + /// after the manager's context has been initialized. + /// + struct _cef_media_router_t*(CEF_CALLBACK* get_media_router)( + struct _cef_request_context_t* self, + struct _cef_completion_callback_t* callback); +} cef_request_context_t; + +/// +/// Returns the global context object. +/// +CEF_EXPORT cef_request_context_t* cef_request_context_get_global_context(void); + +/// +/// Creates a new context object with the specified |settings| and optional +/// |handler|. +/// +CEF_EXPORT cef_request_context_t* cef_request_context_create_context( + const struct _cef_request_context_settings_t* settings, + struct _cef_request_context_handler_t* handler); + +/// +/// Creates a new context object that shares storage with |other| and uses an +/// optional |handler|. +/// +CEF_EXPORT cef_request_context_t* cef_create_context_shared( + cef_request_context_t* other, + struct _cef_request_context_handler_t* handler); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_ diff --git a/include/capi/cef_request_context_handler_capi.h b/include/capi/cef_request_context_handler_capi.h new file mode 100644 index 00000000..d7e06f81 --- /dev/null +++ b/include/capi/cef_request_context_handler_capi.h @@ -0,0 +1,108 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=b0b532a12106d960adc446b980affeee12b93ae3$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_frame_capi.h" +#include "include/capi/cef_preference_capi.h" +#include "include/capi/cef_request_capi.h" +#include "include/capi/cef_resource_request_handler_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to provide handler implementations. The handler +/// instance will not be released until all objects related to the context have +/// been destroyed. +/// +typedef struct _cef_request_context_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called on the browser process UI thread immediately after the request + /// context has been initialized. + /// + void(CEF_CALLBACK* on_request_context_initialized)( + struct _cef_request_context_handler_t* self, + struct _cef_request_context_t* request_context); + + /// + /// Called on the browser process IO thread before a resource request is + /// initiated. The |browser| and |frame| values represent the source of the + /// request, and may be NULL for requests originating from service workers or + /// cef_urlrequest_t. |request| represents the request contents and cannot be + /// modified in this callback. |is_navigation| will be true (1) if the + /// resource request is a navigation. |is_download| will be true (1) if the + /// resource request is a download. |request_initiator| is the origin (scheme + /// + domain) of the page that initiated the request. Set + /// |disable_default_handling| to true (1) to disable default handling of the + /// request, in which case it will need to be handled via + /// cef_resource_request_handler_t::GetResourceHandler or it will be canceled. + /// To allow the resource load to proceed with default handling return NULL. + /// To specify a handler for the resource return a + /// cef_resource_request_handler_t object. This function will not be called if + /// the client associated with |browser| returns a non-NULL value from + /// cef_request_handler_t::GetResourceRequestHandler for the same request + /// (identified by cef_request_t::GetIdentifier). + /// + struct _cef_resource_request_handler_t*( + CEF_CALLBACK* get_resource_request_handler)( + struct _cef_request_context_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + int is_navigation, + int is_download, + const cef_string_t* request_initiator, + int* disable_default_handling); +} cef_request_context_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_ diff --git a/include/capi/cef_request_handler_capi.h b/include/capi/cef_request_handler_capi.h new file mode 100644 index 00000000..9dd95a14 --- /dev/null +++ b/include/capi/cef_request_handler_capi.h @@ -0,0 +1,247 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=092d897e223273a940ed623547d82645f764519c$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_auth_callback_capi.h" +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_callback_capi.h" +#include "include/capi/cef_frame_capi.h" +#include "include/capi/cef_request_capi.h" +#include "include/capi/cef_resource_request_handler_capi.h" +#include "include/capi/cef_ssl_info_capi.h" +#include "include/capi/cef_x509_certificate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Callback structure used to select a client certificate for authentication. +/// +typedef struct _cef_select_client_certificate_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Chooses the specified certificate for client certificate authentication. + /// NULL value means that no client certificate should be used. + /// + void(CEF_CALLBACK* select)( + struct _cef_select_client_certificate_callback_t* self, + struct _cef_x509certificate_t* cert); +} cef_select_client_certificate_callback_t; + +/// +/// Implement this structure to handle events related to browser requests. The +/// functions of this structure will be called on the thread indicated. +/// +typedef struct _cef_request_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called on the UI thread before browser navigation. Return true (1) to + /// cancel the navigation or false (0) to allow the navigation to proceed. The + /// |request| object cannot be modified in this callback. + /// cef_load_handler_t::OnLoadingStateChange will be called twice in all + /// cases. If the navigation is allowed cef_load_handler_t::OnLoadStart and + /// cef_load_handler_t::OnLoadEnd will be called. If the navigation is + /// canceled cef_load_handler_t::OnLoadError will be called with an + /// |errorCode| value of ERR_ABORTED. The |user_gesture| value will be true + /// (1) if the browser navigated via explicit user gesture (e.g. clicking a + /// link) or false (0) if it navigated automatically (e.g. via the + /// DomContentLoaded event). + /// + int(CEF_CALLBACK* on_before_browse)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + int user_gesture, + int is_redirect); + + /// + /// Called on the UI thread before OnBeforeBrowse in certain limited cases + /// where navigating a new or different browser might be desirable. This + /// includes user-initiated navigation that might open in a special way (e.g. + /// links clicked via middle-click or ctrl + left-click) and certain types of + /// cross-origin navigation initiated from the renderer process (e.g. + /// navigating the top-level frame to/from a file URL). The |browser| and + /// |frame| values represent the source of the navigation. The + /// |target_disposition| value indicates where the user intended to navigate + /// the browser based on standard Chromium behaviors (e.g. current tab, new + /// tab, etc). The |user_gesture| value will be true (1) if the browser + /// navigated via explicit user gesture (e.g. clicking a link) or false (0) if + /// it navigated automatically (e.g. via the DomContentLoaded event). Return + /// true (1) to cancel the navigation or false (0) to allow the navigation to + /// proceed in the source browser's top-level frame. + /// + int(CEF_CALLBACK* on_open_urlfrom_tab)( + struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + const cef_string_t* target_url, + cef_window_open_disposition_t target_disposition, + int user_gesture); + + /// + /// Called on the browser process IO thread before a resource request is + /// initiated. The |browser| and |frame| values represent the source of the + /// request. |request| represents the request contents and cannot be modified + /// in this callback. |is_navigation| will be true (1) if the resource request + /// is a navigation. |is_download| will be true (1) if the resource request is + /// a download. |request_initiator| is the origin (scheme + domain) of the + /// page that initiated the request. Set |disable_default_handling| to true + /// (1) to disable default handling of the request, in which case it will need + /// to be handled via cef_resource_request_handler_t::GetResourceHandler or it + /// will be canceled. To allow the resource load to proceed with default + /// handling return NULL. To specify a handler for the resource return a + /// cef_resource_request_handler_t object. If this callback returns NULL the + /// same function will be called on the associated + /// cef_request_context_handler_t, if any. + /// + struct _cef_resource_request_handler_t*( + CEF_CALLBACK* get_resource_request_handler)( + struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + int is_navigation, + int is_download, + const cef_string_t* request_initiator, + int* disable_default_handling); + + /// + /// Called on the IO thread when the browser needs credentials from the user. + /// |origin_url| is the origin making this authentication request. |isProxy| + /// indicates whether the host is a proxy server. |host| contains the hostname + /// and |port| contains the port number. |realm| is the realm of the challenge + /// and may be NULL. |scheme| is the authentication scheme used, such as + /// "basic" or "digest", and will be NULL if the source of the request is an + /// FTP server. Return true (1) to continue the request and call + /// cef_auth_callback_t::cont() either in this function or at a later time + /// when the authentication information is available. Return false (0) to + /// cancel the request immediately. + /// + int(CEF_CALLBACK* get_auth_credentials)( + struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, + const cef_string_t* origin_url, + int isProxy, + const cef_string_t* host, + int port, + const cef_string_t* realm, + const cef_string_t* scheme, + struct _cef_auth_callback_t* callback); + + /// + /// Called on the UI thread to handle requests for URLs with an invalid SSL + /// certificate. Return true (1) and call cef_callback_t functions either in + /// this function or at a later time to continue or cancel the request. Return + /// false (0) to cancel the request immediately. If + /// cef_settings_t.ignore_certificate_errors is set all invalid certificates + /// will be accepted without calling this function. + /// + int(CEF_CALLBACK* on_certificate_error)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, + cef_errorcode_t cert_error, + const cef_string_t* request_url, + struct _cef_sslinfo_t* ssl_info, + struct _cef_callback_t* callback); + + /// + /// Called on the UI thread when a client certificate is being requested for + /// authentication. Return false (0) to use the default behavior and + /// automatically select the first certificate available. Return true (1) and + /// call cef_select_client_certificate_callback_t::Select either in this + /// function or at a later time to select a certificate. Do not call Select or + /// call it with NULL to continue without using any certificate. |isProxy| + /// indicates whether the host is an HTTPS proxy or the origin server. |host| + /// and |port| contains the hostname and port of the SSL server. + /// |certificates| is the list of certificates to choose from; this list has + /// already been pruned by Chromium so that it only contains certificates from + /// issuers that the server trusts. + /// + int(CEF_CALLBACK* on_select_client_certificate)( + struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, + int isProxy, + const cef_string_t* host, + int port, + size_t certificatesCount, + struct _cef_x509certificate_t* const* certificates, + struct _cef_select_client_certificate_callback_t* callback); + + /// + /// Called on the browser process UI thread when the render view associated + /// with |browser| is ready to receive/handle IPC messages in the render + /// process. + /// + void(CEF_CALLBACK* on_render_view_ready)(struct _cef_request_handler_t* self, + struct _cef_browser_t* browser); + + /// + /// Called on the browser process UI thread when the render process terminates + /// unexpectedly. |status| indicates how the process terminated. + /// + void(CEF_CALLBACK* on_render_process_terminated)( + struct _cef_request_handler_t* self, + struct _cef_browser_t* browser, + cef_termination_status_t status); + + /// + /// Called on the browser process UI thread when the window.document object of + /// the main frame has been created. + /// + void(CEF_CALLBACK* on_document_available_in_main_frame)( + struct _cef_request_handler_t* self, + struct _cef_browser_t* browser); +} cef_request_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_ diff --git a/include/capi/cef_resource_bundle_capi.h b/include/capi/cef_resource_bundle_capi.h new file mode 100644 index 00000000..b06728c1 --- /dev/null +++ b/include/capi/cef_resource_bundle_capi.h @@ -0,0 +1,104 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=e8e8dd2730a47aad9414f7bfc2e6ad96aba2c875$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used for retrieving resources from the resource bundle (*.pak) +/// files loaded by CEF during startup or via the cef_resource_bundle_handler_t +/// returned from cef_app_t::GetResourceBundleHandler. See CefSettings for +/// additional options related to resource bundle loading. The functions of this +/// structure may be called on any thread unless otherwise indicated. +/// +typedef struct _cef_resource_bundle_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the localized string for the specified |string_id| or an NULL + /// string if the value is not found. Include cef_pack_strings.h for a listing + /// of valid string ID values. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_localized_string)( + struct _cef_resource_bundle_t* self, + int string_id); + + /// + /// Returns a cef_binary_value_t containing the decompressed contents of the + /// specified scale independent |resource_id| or NULL if not found. Include + /// cef_pack_resources.h for a listing of valid resource ID values. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_data_resource)( + struct _cef_resource_bundle_t* self, + int resource_id); + + /// + /// Returns a cef_binary_value_t containing the decompressed contents of the + /// specified |resource_id| nearest the scale factor |scale_factor| or NULL if + /// not found. Use a |scale_factor| value of SCALE_FACTOR_NONE for scale + /// independent resources or call GetDataResource instead.Include + /// cef_pack_resources.h for a listing of valid resource ID values. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_data_resource_for_scale)( + struct _cef_resource_bundle_t* self, + int resource_id, + cef_scale_factor_t scale_factor); +} cef_resource_bundle_t; + +/// +/// Returns the global resource bundle instance. +/// +CEF_EXPORT cef_resource_bundle_t* cef_resource_bundle_get_global(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_ diff --git a/include/capi/cef_resource_bundle_handler_capi.h b/include/capi/cef_resource_bundle_handler_capi.h new file mode 100644 index 00000000..bc9eea52 --- /dev/null +++ b/include/capi/cef_resource_bundle_handler_capi.h @@ -0,0 +1,105 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=00023b2ec108ae6e4bd282d16e82032cdc99d548$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used to implement a custom resource bundle structure. See +/// CefSettings for additional options related to resource bundle loading. The +/// functions of this structure may be called on multiple threads. +/// +typedef struct _cef_resource_bundle_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called to retrieve a localized translation for the specified |string_id|. + /// To provide the translation set |string| to the translation string and + /// return true (1). To use the default translation return false (0). Include + /// cef_pack_strings.h for a listing of valid string ID values. + /// + int(CEF_CALLBACK* get_localized_string)( + struct _cef_resource_bundle_handler_t* self, + int string_id, + cef_string_t* string); + + /// + /// Called to retrieve data for the specified scale independent |resource_id|. + /// To provide the resource data set |data| and |data_size| to the data + /// pointer and size respectively and return true (1). To use the default + /// resource data return false (0). The resource data will not be copied and + /// must remain resident in memory. Include cef_pack_resources.h for a listing + /// of valid resource ID values. + /// + int(CEF_CALLBACK* get_data_resource)( + struct _cef_resource_bundle_handler_t* self, + int resource_id, + void** data, + size_t* data_size); + + /// + /// Called to retrieve data for the specified |resource_id| nearest the scale + /// factor |scale_factor|. To provide the resource data set |data| and + /// |data_size| to the data pointer and size respectively and return true (1). + /// To use the default resource data return false (0). The resource data will + /// not be copied and must remain resident in memory. Include + /// cef_pack_resources.h for a listing of valid resource ID values. + /// + int(CEF_CALLBACK* get_data_resource_for_scale)( + struct _cef_resource_bundle_handler_t* self, + int resource_id, + cef_scale_factor_t scale_factor, + void** data, + size_t* data_size); +} cef_resource_bundle_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_ diff --git a/include/capi/cef_resource_handler_capi.h b/include/capi/cef_resource_handler_capi.h new file mode 100644 index 00000000..bad0b85a --- /dev/null +++ b/include/capi/cef_resource_handler_capi.h @@ -0,0 +1,210 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=93e5c4f5e93f56b63b5944208300669dcecba972$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_callback_capi.h" +#include "include/capi/cef_cookie_capi.h" +#include "include/capi/cef_request_capi.h" +#include "include/capi/cef_response_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Callback for asynchronous continuation of cef_resource_handler_t::skip(). +/// +typedef struct _cef_resource_skip_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Callback for asynchronous continuation of skip(). If |bytes_skipped| > 0 + /// then either skip() will be called again until the requested number of + /// bytes have been skipped or the request will proceed. If |bytes_skipped| <= + /// 0 the request will fail with ERR_REQUEST_RANGE_NOT_SATISFIABLE. + /// + void(CEF_CALLBACK* cont)(struct _cef_resource_skip_callback_t* self, + int64 bytes_skipped); +} cef_resource_skip_callback_t; + +/// +/// Callback for asynchronous continuation of cef_resource_handler_t::read(). +/// +typedef struct _cef_resource_read_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Callback for asynchronous continuation of read(). If |bytes_read| == 0 the + /// response will be considered complete. If |bytes_read| > 0 then read() will + /// be called again until the request is complete (based on either the result + /// or the expected content length). If |bytes_read| < 0 then the request will + /// fail and the |bytes_read| value will be treated as the error code. + /// + void(CEF_CALLBACK* cont)(struct _cef_resource_read_callback_t* self, + int bytes_read); +} cef_resource_read_callback_t; + +/// +/// Structure used to implement a custom request handler structure. The +/// functions of this structure will be called on the IO thread unless otherwise +/// indicated. +/// +typedef struct _cef_resource_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Open the response stream. To handle the request immediately set + /// |handle_request| to true (1) and return true (1). To decide at a later + /// time set |handle_request| to false (0), return true (1), and execute + /// |callback| to continue or cancel the request. To cancel the request + /// immediately set |handle_request| to true (1) and return false (0). This + /// function will be called in sequence but not from a dedicated thread. For + /// backwards compatibility set |handle_request| to false (0) and return false + /// (0) and the ProcessRequest function will be called. + /// + int(CEF_CALLBACK* open)(struct _cef_resource_handler_t* self, + struct _cef_request_t* request, + int* handle_request, + struct _cef_callback_t* callback); + + /// + /// Begin processing the request. To handle the request return true (1) and + /// call cef_callback_t::cont() once the response header information is + /// available (cef_callback_t::cont() can also be called from inside this + /// function if header information is available immediately). To cancel the + /// request return false (0). + /// + /// WARNING: This function is deprecated. Use Open instead. + /// + int(CEF_CALLBACK* process_request)(struct _cef_resource_handler_t* self, + struct _cef_request_t* request, + struct _cef_callback_t* callback); + + /// + /// Retrieve response header information. If the response length is not known + /// set |response_length| to -1 and read_response() will be called until it + /// returns false (0). If the response length is known set |response_length| + /// to a positive value and read_response() will be called until it returns + /// false (0) or the specified number of bytes have been read. Use the + /// |response| object to set the mime type, http status code and other + /// optional header values. To redirect the request to a new URL set + /// |redirectUrl| to the new URL. |redirectUrl| can be either a relative or + /// fully qualified URL. It is also possible to set |response| to a redirect + /// http status code and pass the new URL via a Location header. Likewise with + /// |redirectUrl| it is valid to set a relative or fully qualified URL as the + /// Location header value. If an error occured while setting up the request + /// you can call set_error() on |response| to indicate the error condition. + /// + void(CEF_CALLBACK* get_response_headers)(struct _cef_resource_handler_t* self, + struct _cef_response_t* response, + int64* response_length, + cef_string_t* redirectUrl); + + /// + /// Skip response data when requested by a Range header. Skip over and discard + /// |bytes_to_skip| bytes of response data. If data is available immediately + /// set |bytes_skipped| to the number of bytes skipped and return true (1). To + /// read the data at a later time set |bytes_skipped| to 0, return true (1) + /// and execute |callback| when the data is available. To indicate failure set + /// |bytes_skipped| to < 0 (e.g. -2 for ERR_FAILED) and return false (0). This + /// function will be called in sequence but not from a dedicated thread. + /// + int(CEF_CALLBACK* skip)(struct _cef_resource_handler_t* self, + int64 bytes_to_skip, + int64* bytes_skipped, + struct _cef_resource_skip_callback_t* callback); + + /// + /// Read response data. If data is available immediately copy up to + /// |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of + /// bytes copied, and return true (1). To read the data at a later time keep a + /// pointer to |data_out|, set |bytes_read| to 0, return true (1) and execute + /// |callback| when the data is available (|data_out| will remain valid until + /// the callback is executed). To indicate response completion set + /// |bytes_read| to 0 and return false (0). To indicate failure set + /// |bytes_read| to < 0 (e.g. -2 for ERR_FAILED) and return false (0). This + /// function will be called in sequence but not from a dedicated thread. For + /// backwards compatibility set |bytes_read| to -1 and return false (0) and + /// the ReadResponse function will be called. + /// + int(CEF_CALLBACK* read)(struct _cef_resource_handler_t* self, + void* data_out, + int bytes_to_read, + int* bytes_read, + struct _cef_resource_read_callback_t* callback); + + /// + /// Read response data. If data is available immediately copy up to + /// |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of + /// bytes copied, and return true (1). To read the data at a later time set + /// |bytes_read| to 0, return true (1) and call cef_callback_t::cont() when + /// the data is available. To indicate response completion return false (0). + /// + /// WARNING: This function is deprecated. Use Skip and Read instead. + /// + int(CEF_CALLBACK* read_response)(struct _cef_resource_handler_t* self, + void* data_out, + int bytes_to_read, + int* bytes_read, + struct _cef_callback_t* callback); + + /// + /// Request processing has been canceled. + /// + void(CEF_CALLBACK* cancel)(struct _cef_resource_handler_t* self); +} cef_resource_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_ diff --git a/include/capi/cef_resource_request_handler_capi.h b/include/capi/cef_resource_request_handler_capi.h new file mode 100644 index 00000000..18405562 --- /dev/null +++ b/include/capi/cef_resource_request_handler_capi.h @@ -0,0 +1,255 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=70d6b393cbdc96a75864911d7ca3568cc8dcdebf$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_REQUEST_HANDLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RESOURCE_REQUEST_HANDLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_callback_capi.h" +#include "include/capi/cef_frame_capi.h" +#include "include/capi/cef_request_capi.h" +#include "include/capi/cef_resource_handler_capi.h" +#include "include/capi/cef_response_capi.h" +#include "include/capi/cef_response_filter_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_cookie_access_filter_t; + +/// +/// Implement this structure to handle events related to browser requests. The +/// functions of this structure will be called on the IO thread unless otherwise +/// indicated. +/// +typedef struct _cef_resource_request_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called on the IO thread before a resource request is loaded. The |browser| + /// and |frame| values represent the source of the request, and may be NULL + /// for requests originating from service workers or cef_urlrequest_t. To + /// optionally filter cookies for the request return a + /// cef_cookie_access_filter_t object. The |request| object cannot not be + /// modified in this callback. + /// + struct _cef_cookie_access_filter_t*(CEF_CALLBACK* get_cookie_access_filter)( + struct _cef_resource_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request); + + /// + /// Called on the IO thread before a resource request is loaded. The |browser| + /// and |frame| values represent the source of the request, and may be NULL + /// for requests originating from service workers or cef_urlrequest_t. To + /// redirect or change the resource load optionally modify |request|. + /// Modification of the request URL will be treated as a redirect. Return + /// RV_CONTINUE to continue the request immediately. Return RV_CONTINUE_ASYNC + /// and call cef_callback_t functions at a later time to continue or cancel + /// the request asynchronously. Return RV_CANCEL to cancel the request + /// immediately. + /// + cef_return_value_t(CEF_CALLBACK* on_before_resource_load)( + struct _cef_resource_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + struct _cef_callback_t* callback); + + /// + /// Called on the IO thread before a resource is loaded. The |browser| and + /// |frame| values represent the source of the request, and may be NULL for + /// requests originating from service workers or cef_urlrequest_t. To allow + /// the resource to load using the default network loader return NULL. To + /// specify a handler for the resource return a cef_resource_handler_t object. + /// The |request| object cannot not be modified in this callback. + /// + struct _cef_resource_handler_t*(CEF_CALLBACK* get_resource_handler)( + struct _cef_resource_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request); + + /// + /// Called on the IO thread when a resource load is redirected. The |browser| + /// and |frame| values represent the source of the request, and may be NULL + /// for requests originating from service workers or cef_urlrequest_t. The + /// |request| parameter will contain the old URL and other request-related + /// information. The |response| parameter will contain the response that + /// resulted in the redirect. The |new_url| parameter will contain the new URL + /// and can be changed if desired. The |request| and |response| objects cannot + /// be modified in this callback. + /// + void(CEF_CALLBACK* on_resource_redirect)( + struct _cef_resource_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + struct _cef_response_t* response, + cef_string_t* new_url); + + /// + /// Called on the IO thread when a resource response is received. The + /// |browser| and |frame| values represent the source of the request, and may + /// be NULL for requests originating from service workers or cef_urlrequest_t. + /// To allow the resource load to proceed without modification return false + /// (0). To redirect or retry the resource load optionally modify |request| + /// and return true (1). Modification of the request URL will be treated as a + /// redirect. Requests handled using the default network loader cannot be + /// redirected in this callback. The |response| object cannot be modified in + /// this callback. + /// + /// WARNING: Redirecting using this function is deprecated. Use + /// OnBeforeResourceLoad or GetResourceHandler to perform redirects. + /// + int(CEF_CALLBACK* on_resource_response)( + struct _cef_resource_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + struct _cef_response_t* response); + + /// + /// Called on the IO thread to optionally filter resource response content. + /// The |browser| and |frame| values represent the source of the request, and + /// may be NULL for requests originating from service workers or + /// cef_urlrequest_t. |request| and |response| represent the request and + /// response respectively and cannot be modified in this callback. + /// + struct _cef_response_filter_t*(CEF_CALLBACK* get_resource_response_filter)( + struct _cef_resource_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + struct _cef_response_t* response); + + /// + /// Called on the IO thread when a resource load has completed. The |browser| + /// and |frame| values represent the source of the request, and may be NULL + /// for requests originating from service workers or cef_urlrequest_t. + /// |request| and |response| represent the request and response respectively + /// and cannot be modified in this callback. |status| indicates the load + /// completion status. |received_content_length| is the number of response + /// bytes actually read. This function will be called for all requests, + /// including requests that are aborted due to CEF shutdown or destruction of + /// the associated browser. In cases where the associated browser is destroyed + /// this callback may arrive after the cef_life_span_handler_t::OnBeforeClose + /// callback for that browser. The cef_frame_t::IsValid function can be used + /// to test for this situation, and care should be taken not to call |browser| + /// or |frame| functions that modify state (like LoadURL, SendProcessMessage, + /// etc.) if the frame is invalid. + /// + void(CEF_CALLBACK* on_resource_load_complete)( + struct _cef_resource_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + struct _cef_response_t* response, + cef_urlrequest_status_t status, + int64 received_content_length); + + /// + /// Called on the IO thread to handle requests for URLs with an unknown + /// protocol component. The |browser| and |frame| values represent the source + /// of the request, and may be NULL for requests originating from service + /// workers or cef_urlrequest_t. |request| cannot be modified in this + /// callback. Set |allow_os_execution| to true (1) to attempt execution via + /// the registered OS protocol handler, if any. SECURITY WARNING: YOU SHOULD + /// USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR OTHER URL + /// ANALYSIS BEFORE ALLOWING OS EXECUTION. + /// + void(CEF_CALLBACK* on_protocol_execution)( + struct _cef_resource_request_handler_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + int* allow_os_execution); +} cef_resource_request_handler_t; + +/// +/// Implement this structure to filter cookies that may be sent or received from +/// resource requests. The functions of this structure will be called on the IO +/// thread unless otherwise indicated. +/// +typedef struct _cef_cookie_access_filter_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called on the IO thread before a resource request is sent. The |browser| + /// and |frame| values represent the source of the request, and may be NULL + /// for requests originating from service workers or cef_urlrequest_t. + /// |request| cannot be modified in this callback. Return true (1) if the + /// specified cookie can be sent with the request or false (0) otherwise. + /// + int(CEF_CALLBACK* can_send_cookie)(struct _cef_cookie_access_filter_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + const struct _cef_cookie_t* cookie); + + /// + /// Called on the IO thread after a resource response is received. The + /// |browser| and |frame| values represent the source of the request, and may + /// be NULL for requests originating from service workers or cef_urlrequest_t. + /// |request| cannot be modified in this callback. Return true (1) if the + /// specified cookie returned with the response can be saved or false (0) + /// otherwise. + /// + int(CEF_CALLBACK* can_save_cookie)(struct _cef_cookie_access_filter_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + struct _cef_request_t* request, + struct _cef_response_t* response, + const struct _cef_cookie_t* cookie); +} cef_cookie_access_filter_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RESOURCE_REQUEST_HANDLER_CAPI_H_ diff --git a/include/capi/cef_response_capi.h b/include/capi/cef_response_capi.h new file mode 100644 index 00000000..d8c4b655 --- /dev/null +++ b/include/capi/cef_response_capi.h @@ -0,0 +1,177 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=7fbcd399c08dc39e33a7d0400a49f2e3a551bd02$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure used to represent a web response. The functions of this structure +/// may be called on any thread. +/// +typedef struct _cef_response_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is read-only. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_response_t* self); + + /// + /// Get the response error code. Returns ERR_NONE if there was no error. + /// + cef_errorcode_t(CEF_CALLBACK* get_error)(struct _cef_response_t* self); + + /// + /// Set the response error code. This can be used by custom scheme handlers to + /// return errors during initial request processing. + /// + void(CEF_CALLBACK* set_error)(struct _cef_response_t* self, + cef_errorcode_t error); + + /// + /// Get the response status code. + /// + int(CEF_CALLBACK* get_status)(struct _cef_response_t* self); + + /// + /// Set the response status code. + /// + void(CEF_CALLBACK* set_status)(struct _cef_response_t* self, int status); + + /// + /// Get the response status text. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_status_text)( + struct _cef_response_t* self); + + /// + /// Set the response status text. + /// + void(CEF_CALLBACK* set_status_text)(struct _cef_response_t* self, + const cef_string_t* statusText); + + /// + /// Get the response mime type. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_mime_type)( + struct _cef_response_t* self); + + /// + /// Set the response mime type. + /// + void(CEF_CALLBACK* set_mime_type)(struct _cef_response_t* self, + const cef_string_t* mimeType); + + /// + /// Get the response charset. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_charset)( + struct _cef_response_t* self); + + /// + /// Set the response charset. + /// + void(CEF_CALLBACK* set_charset)(struct _cef_response_t* self, + const cef_string_t* charset); + + /// + /// Get the value for the specified response header field. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_header_by_name)( + struct _cef_response_t* self, + const cef_string_t* name); + + /// + /// Set the header |name| to |value|. If |overwrite| is true (1) any existing + /// values will be replaced with the new value. If |overwrite| is false (0) + /// any existing values will not be overwritten. + /// + void(CEF_CALLBACK* set_header_by_name)(struct _cef_response_t* self, + const cef_string_t* name, + const cef_string_t* value, + int overwrite); + + /// + /// Get all response header fields. + /// + void(CEF_CALLBACK* get_header_map)(struct _cef_response_t* self, + cef_string_multimap_t headerMap); + + /// + /// Set all response header fields. + /// + void(CEF_CALLBACK* set_header_map)(struct _cef_response_t* self, + cef_string_multimap_t headerMap); + + /// + /// Get the resolved URL after redirects or changed as a result of HSTS. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_url)(struct _cef_response_t* self); + + /// + /// Set the resolved URL after redirects or changed as a result of HSTS. + /// + void(CEF_CALLBACK* set_url)(struct _cef_response_t* self, + const cef_string_t* url); +} cef_response_t; + +/// +/// Create a new cef_response_t object. +/// +CEF_EXPORT cef_response_t* cef_response_create(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_ diff --git a/include/capi/cef_response_filter_capi.h b/include/capi/cef_response_filter_capi.h new file mode 100644 index 00000000..c8a57de2 --- /dev/null +++ b/include/capi/cef_response_filter_capi.h @@ -0,0 +1,110 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=2c9b14a86ee6777e4834eadcfc95802f2dedb11a$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to filter resource response content. The functions +/// of this structure will be called on the browser process IO thread. +/// +typedef struct _cef_response_filter_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Initialize the response filter. Will only be called a single time. The + /// filter will not be installed if this function returns false (0). + /// + int(CEF_CALLBACK* init_filter)(struct _cef_response_filter_t* self); + + /// + /// Called to filter a chunk of data. Expected usage is as follows: + /// + /// 1. Read input data from |data_in| and set |data_in_read| to the number of + /// bytes that were read up to a maximum of |data_in_size|. |data_in| will + /// be NULL if |data_in_size| is zero. + /// 2. Write filtered output data to |data_out| and set |data_out_written| to + /// the number of bytes that were written up to a maximum of + /// |data_out_size|. If no output data was written then all data must be + /// read from |data_in| (user must set |data_in_read| = |data_in_size|). + /// 3. Return RESPONSE_FILTER_DONE if all output data was written or + /// RESPONSE_FILTER_NEED_MORE_DATA if output data is still pending. + /// + /// This function will be called repeatedly until the input buffer has been + /// fully read (user sets |data_in_read| = |data_in_size|) and there is no + /// more input data to filter (the resource response is complete). This + /// function may then be called an additional time with an NULL input buffer + /// if the user filled the output buffer (set |data_out_written| = + /// |data_out_size|) and returned RESPONSE_FILTER_NEED_MORE_DATA to indicate + /// that output data is still pending. + /// + /// Calls to this function will stop when one of the following conditions is + /// met: + /// + /// 1. There is no more input data to filter (the resource response is + /// complete) and the user sets |data_out_written| = 0 or returns + /// RESPONSE_FILTER_DONE to indicate that all data has been written, or; + /// 2. The user returns RESPONSE_FILTER_ERROR to indicate an error. + /// + /// Do not keep a reference to the buffers passed to this function. + /// + cef_response_filter_status_t(CEF_CALLBACK* filter)( + struct _cef_response_filter_t* self, + void* data_in, + size_t data_in_size, + size_t* data_in_read, + void* data_out, + size_t data_out_size, + size_t* data_out_written); +} cef_response_filter_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_ diff --git a/include/capi/cef_scheme_capi.h b/include/capi/cef_scheme_capi.h new file mode 100644 index 00000000..5f879628 --- /dev/null +++ b/include/capi/cef_scheme_capi.h @@ -0,0 +1,140 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=6b6a7f754abc9ee5d6f775ba9eee802d3244faf5$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_frame_capi.h" +#include "include/capi/cef_request_capi.h" +#include "include/capi/cef_resource_handler_capi.h" +#include "include/capi/cef_response_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_scheme_handler_factory_t; + +/// +/// Structure that manages custom scheme registrations. +/// +typedef struct _cef_scheme_registrar_t { + /// + /// Base structure. + /// + cef_base_scoped_t base; + + /// + /// Register a custom scheme. This function should not be called for the + /// built-in HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes. + /// + /// See cef_scheme_options_t for possible values for |options|. + /// + /// This function may be called on any thread. It should only be called once + /// per unique |scheme_name| value. If |scheme_name| is already registered or + /// if an error occurs this function will return false (0). + /// + int(CEF_CALLBACK* add_custom_scheme)(struct _cef_scheme_registrar_t* self, + const cef_string_t* scheme_name, + int options); +} cef_scheme_registrar_t; + +/// +/// Structure that creates cef_resource_handler_t instances for handling scheme +/// requests. The functions of this structure will always be called on the IO +/// thread. +/// +typedef struct _cef_scheme_handler_factory_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Return a new resource handler instance to handle the request or an NULL + /// reference to allow default handling of the request. |browser| and |frame| + /// will be the browser window and frame respectively that originated the + /// request or NULL if the request did not originate from a browser window + /// (for example, if the request came from cef_urlrequest_t). The |request| + /// object passed to this function cannot be modified. + /// + struct _cef_resource_handler_t*(CEF_CALLBACK* create)( + struct _cef_scheme_handler_factory_t* self, + struct _cef_browser_t* browser, + struct _cef_frame_t* frame, + const cef_string_t* scheme_name, + struct _cef_request_t* request); +} cef_scheme_handler_factory_t; + +/// +/// Register a scheme handler factory with the global request context. An NULL +/// |domain_name| value for a standard scheme will cause the factory to match +/// all domain names. The |domain_name| value will be ignored for non-standard +/// schemes. If |scheme_name| is a built-in scheme and no handler is returned by +/// |factory| then the built-in scheme handler factory will be called. If +/// |scheme_name| is a custom scheme then you must also implement the +/// cef_app_t::on_register_custom_schemes() function in all processes. This +/// function may be called multiple times to change or remove the factory that +/// matches the specified |scheme_name| and optional |domain_name|. Returns +/// false (0) if an error occurs. This function may be called on any thread in +/// the browser process. Using this function is equivalent to calling cef_reques +/// t_context_t::cef_request_context_get_global_context()->register_scheme_handl +/// er_factory(). +/// +CEF_EXPORT int cef_register_scheme_handler_factory( + const cef_string_t* scheme_name, + const cef_string_t* domain_name, + cef_scheme_handler_factory_t* factory); + +/// +/// Clear all scheme handler factories registered with the global request +/// context. Returns false (0) on error. This function may be called on any +/// thread in the browser process. Using this function is equivalent to calling +/// cef_request_context_t::cef_request_context_get_global_context()->clear_schem +/// e_handler_factories(). +/// +CEF_EXPORT int cef_clear_scheme_handler_factories(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_ diff --git a/include/capi/cef_server_capi.h b/include/capi/cef_server_capi.h new file mode 100644 index 00000000..d1d2d943 --- /dev/null +++ b/include/capi/cef_server_capi.h @@ -0,0 +1,328 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=64e9ebc0e01acca0333ca3419e379d4053892270$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_SERVER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_SERVER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_callback_capi.h" +#include "include/capi/cef_request_capi.h" +#include "include/capi/cef_task_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_server_handler_t; + +/// +/// Structure representing a server that supports HTTP and WebSocket requests. +/// Server capacity is limited and is intended to handle only a small number of +/// simultaneous connections (e.g. for communicating between applications on +/// localhost). The functions of this structure are safe to call from any thread +/// in the brower process unless otherwise indicated. +/// +typedef struct _cef_server_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the task runner for the dedicated server thread. + /// + struct _cef_task_runner_t*(CEF_CALLBACK* get_task_runner)( + struct _cef_server_t* self); + + /// + /// Stop the server and shut down the dedicated server thread. See + /// cef_server_handler_t::OnServerCreated documentation for a description of + /// server lifespan. + /// + void(CEF_CALLBACK* shutdown)(struct _cef_server_t* self); + + /// + /// Returns true (1) if the server is currently running and accepting incoming + /// connections. See cef_server_handler_t::OnServerCreated documentation for a + /// description of server lifespan. This function must be called on the + /// dedicated server thread. + /// + int(CEF_CALLBACK* is_running)(struct _cef_server_t* self); + + /// + /// Returns the server address including the port number. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_address)(struct _cef_server_t* self); + + /// + /// Returns true (1) if the server currently has a connection. This function + /// must be called on the dedicated server thread. + /// + int(CEF_CALLBACK* has_connection)(struct _cef_server_t* self); + + /// + /// Returns true (1) if |connection_id| represents a valid connection. This + /// function must be called on the dedicated server thread. + /// + int(CEF_CALLBACK* is_valid_connection)(struct _cef_server_t* self, + int connection_id); + + /// + /// Send an HTTP 200 "OK" response to the connection identified by + /// |connection_id|. |content_type| is the response content type (e.g. + /// "text/html"), |data| is the response content, and |data_size| is the size + /// of |data| in bytes. The contents of |data| will be copied. The connection + /// will be closed automatically after the response is sent. + /// + void(CEF_CALLBACK* send_http200response)(struct _cef_server_t* self, + int connection_id, + const cef_string_t* content_type, + const void* data, + size_t data_size); + + /// + /// Send an HTTP 404 "Not Found" response to the connection identified by + /// |connection_id|. The connection will be closed automatically after the + /// response is sent. + /// + void(CEF_CALLBACK* send_http404response)(struct _cef_server_t* self, + int connection_id); + + /// + /// Send an HTTP 500 "Internal Server Error" response to the connection + /// identified by |connection_id|. |error_message| is the associated error + /// message. The connection will be closed automatically after the response is + /// sent. + /// + void(CEF_CALLBACK* send_http500response)(struct _cef_server_t* self, + int connection_id, + const cef_string_t* error_message); + + /// + /// Send a custom HTTP response to the connection identified by + /// |connection_id|. |response_code| is the HTTP response code sent in the + /// status line (e.g. 200), |content_type| is the response content type sent + /// as the "Content-Type" header (e.g. "text/html"), |content_length| is the + /// expected content length, and |extra_headers| is the map of extra response + /// headers. If |content_length| is >= 0 then the "Content-Length" header will + /// be sent. If |content_length| is 0 then no content is expected and the + /// connection will be closed automatically after the response is sent. If + /// |content_length| is < 0 then no "Content-Length" header will be sent and + /// the client will continue reading until the connection is closed. Use the + /// SendRawData function to send the content, if applicable, and call + /// CloseConnection after all content has been sent. + /// + void(CEF_CALLBACK* send_http_response)(struct _cef_server_t* self, + int connection_id, + int response_code, + const cef_string_t* content_type, + int64 content_length, + cef_string_multimap_t extra_headers); + + /// + /// Send raw data directly to the connection identified by |connection_id|. + /// |data| is the raw data and |data_size| is the size of |data| in bytes. The + /// contents of |data| will be copied. No validation of |data| is performed + /// internally so the client should be careful to send the amount indicated by + /// the "Content-Length" header, if specified. See SendHttpResponse + /// documentation for intended usage. + /// + void(CEF_CALLBACK* send_raw_data)(struct _cef_server_t* self, + int connection_id, + const void* data, + size_t data_size); + + /// + /// Close the connection identified by |connection_id|. See SendHttpResponse + /// documentation for intended usage. + /// + void(CEF_CALLBACK* close_connection)(struct _cef_server_t* self, + int connection_id); + + /// + /// Send a WebSocket message to the connection identified by |connection_id|. + /// |data| is the response content and |data_size| is the size of |data| in + /// bytes. The contents of |data| will be copied. See + /// cef_server_handler_t::OnWebSocketRequest documentation for intended usage. + /// + void(CEF_CALLBACK* send_web_socket_message)(struct _cef_server_t* self, + int connection_id, + const void* data, + size_t data_size); +} cef_server_t; + +/// +/// Create a new server that binds to |address| and |port|. |address| must be a +/// valid IPv4 or IPv6 address (e.g. 127.0.0.1 or ::1) and |port| must be a port +/// number outside of the reserved range (e.g. between 1025 and 65535 on most +/// platforms). |backlog| is the maximum number of pending connections. A new +/// thread will be created for each CreateServer call (the "dedicated server +/// thread"). It is therefore recommended to use a different +/// cef_server_handler_t instance for each CreateServer call to avoid thread +/// safety issues in the cef_server_handler_t implementation. The +/// cef_server_handler_t::OnServerCreated function will be called on the +/// dedicated server thread to report success or failure. See +/// cef_server_handler_t::OnServerCreated documentation for a description of +/// server lifespan. +/// +CEF_EXPORT void cef_server_create(const cef_string_t* address, + uint16 port, + int backlog, + struct _cef_server_handler_t* handler); + +/// +/// Implement this structure to handle HTTP server requests. A new thread will +/// be created for each cef_server_t::CreateServer call (the "dedicated server +/// thread"), and the functions of this structure will be called on that thread. +/// It is therefore recommended to use a different cef_server_handler_t instance +/// for each cef_server_t::CreateServer call to avoid thread safety issues in +/// the cef_server_handler_t implementation. +/// +typedef struct _cef_server_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when |server| is created. If the server was started successfully + /// then cef_server_t::IsRunning will return true (1). The server will + /// continue running until cef_server_t::Shutdown is called, after which time + /// OnServerDestroyed will be called. If the server failed to start then + /// OnServerDestroyed will be called immediately after this function returns. + /// + void(CEF_CALLBACK* on_server_created)(struct _cef_server_handler_t* self, + struct _cef_server_t* server); + + /// + /// Called when |server| is destroyed. The server thread will be stopped after + /// this function returns. The client should release any references to + /// |server| when this function is called. See OnServerCreated documentation + /// for a description of server lifespan. + /// + void(CEF_CALLBACK* on_server_destroyed)(struct _cef_server_handler_t* self, + struct _cef_server_t* server); + + /// + /// Called when a client connects to |server|. |connection_id| uniquely + /// identifies the connection. Each call to this function will have a matching + /// call to OnClientDisconnected. + /// + void(CEF_CALLBACK* on_client_connected)(struct _cef_server_handler_t* self, + struct _cef_server_t* server, + int connection_id); + + /// + /// Called when a client disconnects from |server|. |connection_id| uniquely + /// identifies the connection. The client should release any data associated + /// with |connection_id| when this function is called and |connection_id| + /// should no longer be passed to cef_server_t functions. Disconnects can + /// originate from either the client or the server. For example, the server + /// will disconnect automatically after a cef_server_t::SendHttpXXXResponse + /// function is called. + /// + void(CEF_CALLBACK* on_client_disconnected)(struct _cef_server_handler_t* self, + struct _cef_server_t* server, + int connection_id); + + /// + /// Called when |server| receives an HTTP request. |connection_id| uniquely + /// identifies the connection, |client_address| is the requesting IPv4 or IPv6 + /// client address including port number, and |request| contains the request + /// contents (URL, function, headers and optional POST data). Call + /// cef_server_t functions either synchronously or asynchronusly to send a + /// response. + /// + void(CEF_CALLBACK* on_http_request)(struct _cef_server_handler_t* self, + struct _cef_server_t* server, + int connection_id, + const cef_string_t* client_address, + struct _cef_request_t* request); + + /// + /// Called when |server| receives a WebSocket request. |connection_id| + /// uniquely identifies the connection, |client_address| is the requesting + /// IPv4 or IPv6 client address including port number, and |request| contains + /// the request contents (URL, function, headers and optional POST data). + /// Execute |callback| either synchronously or asynchronously to accept or + /// decline the WebSocket connection. If the request is accepted then + /// OnWebSocketConnected will be called after the WebSocket has connected and + /// incoming messages will be delivered to the OnWebSocketMessage callback. If + /// the request is declined then the client will be disconnected and + /// OnClientDisconnected will be called. Call the + /// cef_server_t::SendWebSocketMessage function after receiving the + /// OnWebSocketConnected callback to respond with WebSocket messages. + /// + void(CEF_CALLBACK* on_web_socket_request)(struct _cef_server_handler_t* self, + struct _cef_server_t* server, + int connection_id, + const cef_string_t* client_address, + struct _cef_request_t* request, + struct _cef_callback_t* callback); + + /// + /// Called after the client has accepted the WebSocket connection for |server| + /// and |connection_id| via the OnWebSocketRequest callback. See + /// OnWebSocketRequest documentation for intended usage. + /// + void(CEF_CALLBACK* on_web_socket_connected)( + struct _cef_server_handler_t* self, + struct _cef_server_t* server, + int connection_id); + + /// + /// Called when |server| receives an WebSocket message. |connection_id| + /// uniquely identifies the connection, |data| is the message content and + /// |data_size| is the size of |data| in bytes. Do not keep a reference to + /// |data| outside of this function. See OnWebSocketRequest documentation for + /// intended usage. + /// + void(CEF_CALLBACK* on_web_socket_message)(struct _cef_server_handler_t* self, + struct _cef_server_t* server, + int connection_id, + const void* data, + size_t data_size); +} cef_server_handler_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_SERVER_CAPI_H_ diff --git a/include/capi/cef_shared_memory_region_capi.h b/include/capi/cef_shared_memory_region_capi.h new file mode 100644 index 00000000..07be55e6 --- /dev/null +++ b/include/capi/cef_shared_memory_region_capi.h @@ -0,0 +1,79 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=08f64795d78bdad29a45222a7263e795ce77a52d$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_SHARED_MEMORY_REGION_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_SHARED_MEMORY_REGION_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure that wraps platform-dependent share memory region mapping. +/// +typedef struct _cef_shared_memory_region_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if the mapping is valid. + /// + int(CEF_CALLBACK* is_valid)(struct _cef_shared_memory_region_t* self); + + /// + /// Returns the size of the mapping in bytes. Returns 0 for invalid instances. + /// + size_t(CEF_CALLBACK* size)(struct _cef_shared_memory_region_t* self); + + /// + /// Returns the pointer to the memory. Returns nullptr for invalid instances. + /// The returned pointer is only valid for the life span of this object. + /// + const void*(CEF_CALLBACK* memory)(struct _cef_shared_memory_region_t* self); +} cef_shared_memory_region_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_SHARED_MEMORY_REGION_CAPI_H_ diff --git a/include/capi/cef_shared_process_message_builder_capi.h b/include/capi/cef_shared_process_message_builder_capi.h new file mode 100644 index 00000000..1b570648 --- /dev/null +++ b/include/capi/cef_shared_process_message_builder_capi.h @@ -0,0 +1,101 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=1a2d8806256d04362f181350db2835850cb3e0ae$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_SHARED_PROCESS_MESSAGE_BUILDER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_SHARED_PROCESS_MESSAGE_BUILDER_CAPI_H_ +#pragma once + +#include "include/capi/cef_process_message_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure that builds a cef_process_message_t containing a shared memory +/// region. This structure is not thread-safe but may be used exclusively on a +/// different thread from the one which constructed it. +/// +typedef struct _cef_shared_process_message_builder_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if the builder is valid. + /// + int(CEF_CALLBACK* is_valid)( + struct _cef_shared_process_message_builder_t* self); + + /// + /// Returns the size of the shared memory region in bytes. Returns 0 for + /// invalid instances. + /// + size_t(CEF_CALLBACK* size)( + struct _cef_shared_process_message_builder_t* self); + + /// + /// Returns the pointer to the writable memory. Returns nullptr for invalid + /// instances. The returned pointer is only valid for the life span of this + /// object. + /// + void*(CEF_CALLBACK* memory)( + struct _cef_shared_process_message_builder_t* self); + + /// + /// Creates a new cef_process_message_t from the data provided to the builder. + /// Returns nullptr for invalid instances. Invalidates the builder instance. + /// + struct _cef_process_message_t*(CEF_CALLBACK* build)( + struct _cef_shared_process_message_builder_t* self); +} cef_shared_process_message_builder_t; + +/// +/// Creates a new cef_shared_process_message_builder_t with the specified |name| +/// and shared memory region of specified |byte_size|. +/// +CEF_EXPORT cef_shared_process_message_builder_t* +cef_shared_process_message_builder_create(const cef_string_t* name, + size_t byte_size); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_SHARED_PROCESS_MESSAGE_BUILDER_CAPI_H_ diff --git a/include/capi/cef_ssl_info_capi.h b/include/capi/cef_ssl_info_capi.h new file mode 100644 index 00000000..54b2009a --- /dev/null +++ b/include/capi/cef_ssl_info_capi.h @@ -0,0 +1,82 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=99dff3042ea437ecf5771eff9b3cab4c22190534$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" +#include "include/capi/cef_x509_certificate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure representing SSL information. +/// +typedef struct _cef_sslinfo_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns a bitmask containing any and all problems verifying the server + /// certificate. + /// + cef_cert_status_t(CEF_CALLBACK* get_cert_status)(struct _cef_sslinfo_t* self); + + /// + /// Returns the X.509 certificate. + /// + struct _cef_x509certificate_t*(CEF_CALLBACK* get_x509certificate)( + struct _cef_sslinfo_t* self); +} cef_sslinfo_t; + +/// +/// Returns true (1) if the certificate status represents an error. +/// +CEF_EXPORT int cef_is_cert_status_error(cef_cert_status_t status); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_ diff --git a/include/capi/cef_ssl_status_capi.h b/include/capi/cef_ssl_status_capi.h new file mode 100644 index 00000000..0c6c4b79 --- /dev/null +++ b/include/capi/cef_ssl_status_capi.h @@ -0,0 +1,95 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=034a68aa4901cde95e12a7900cfc65753fbde345$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" +#include "include/capi/cef_x509_certificate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure representing the SSL information for a navigation entry. +/// +typedef struct _cef_sslstatus_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if the status is related to a secure SSL/TLS connection. + /// + int(CEF_CALLBACK* is_secure_connection)(struct _cef_sslstatus_t* self); + + /// + /// Returns a bitmask containing any and all problems verifying the server + /// certificate. + /// + cef_cert_status_t(CEF_CALLBACK* get_cert_status)( + struct _cef_sslstatus_t* self); + + /// + /// Returns the SSL version used for the SSL connection. + /// + cef_ssl_version_t(CEF_CALLBACK* get_sslversion)( + struct _cef_sslstatus_t* self); + + /// + /// Returns a bitmask containing the page security content status. + /// + cef_ssl_content_status_t(CEF_CALLBACK* get_content_status)( + struct _cef_sslstatus_t* self); + + /// + /// Returns the X.509 certificate. + /// + struct _cef_x509certificate_t*(CEF_CALLBACK* get_x509certificate)( + struct _cef_sslstatus_t* self); +} cef_sslstatus_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_ diff --git a/include/capi/cef_stream_capi.h b/include/capi/cef_stream_capi.h new file mode 100644 index 00000000..c425b1fe --- /dev/null +++ b/include/capi/cef_stream_capi.h @@ -0,0 +1,263 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=bbb4153d5d7325ac9a410d7f85a8d47eadcfaf6e$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure the client can implement to provide a custom stream reader. The +/// functions of this structure may be called on any thread. +/// +typedef struct _cef_read_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Read raw binary data. + /// + size_t(CEF_CALLBACK* read)(struct _cef_read_handler_t* self, + void* ptr, + size_t size, + size_t n); + + /// + /// Seek to the specified offset position. |whence| may be any one of + /// SEEK_CUR, SEEK_END or SEEK_SET. Return zero on success and non-zero on + /// failure. + /// + int(CEF_CALLBACK* seek)(struct _cef_read_handler_t* self, + int64 offset, + int whence); + + /// + /// Return the current offset position. + /// + int64(CEF_CALLBACK* tell)(struct _cef_read_handler_t* self); + + /// + /// Return non-zero if at end of file. + /// + int(CEF_CALLBACK* eof)(struct _cef_read_handler_t* self); + + /// + /// Return true (1) if this handler performs work like accessing the file + /// system which may block. Used as a hint for determining the thread to + /// access the handler from. + /// + int(CEF_CALLBACK* may_block)(struct _cef_read_handler_t* self); +} cef_read_handler_t; + +/// +/// Structure used to read data from a stream. The functions of this structure +/// may be called on any thread. +/// +typedef struct _cef_stream_reader_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Read raw binary data. + /// + size_t(CEF_CALLBACK* read)(struct _cef_stream_reader_t* self, + void* ptr, + size_t size, + size_t n); + + /// + /// Seek to the specified offset position. |whence| may be any one of + /// SEEK_CUR, SEEK_END or SEEK_SET. Returns zero on success and non-zero on + /// failure. + /// + int(CEF_CALLBACK* seek)(struct _cef_stream_reader_t* self, + int64 offset, + int whence); + + /// + /// Return the current offset position. + /// + int64(CEF_CALLBACK* tell)(struct _cef_stream_reader_t* self); + + /// + /// Return non-zero if at end of file. + /// + int(CEF_CALLBACK* eof)(struct _cef_stream_reader_t* self); + + /// + /// Returns true (1) if this reader performs work like accessing the file + /// system which may block. Used as a hint for determining the thread to + /// access the reader from. + /// + int(CEF_CALLBACK* may_block)(struct _cef_stream_reader_t* self); +} cef_stream_reader_t; + +/// +/// Create a new cef_stream_reader_t object from a file. +/// +CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_file( + const cef_string_t* fileName); + +/// +/// Create a new cef_stream_reader_t object from data. +/// +CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void* data, + size_t size); + +/// +/// Create a new cef_stream_reader_t object from a custom handler. +/// +CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_handler( + cef_read_handler_t* handler); + +/// +/// Structure the client can implement to provide a custom stream writer. The +/// functions of this structure may be called on any thread. +/// +typedef struct _cef_write_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Write raw binary data. + /// + size_t(CEF_CALLBACK* write)(struct _cef_write_handler_t* self, + const void* ptr, + size_t size, + size_t n); + + /// + /// Seek to the specified offset position. |whence| may be any one of + /// SEEK_CUR, SEEK_END or SEEK_SET. Return zero on success and non-zero on + /// failure. + /// + int(CEF_CALLBACK* seek)(struct _cef_write_handler_t* self, + int64 offset, + int whence); + + /// + /// Return the current offset position. + /// + int64(CEF_CALLBACK* tell)(struct _cef_write_handler_t* self); + + /// + /// Flush the stream. + /// + int(CEF_CALLBACK* flush)(struct _cef_write_handler_t* self); + + /// + /// Return true (1) if this handler performs work like accessing the file + /// system which may block. Used as a hint for determining the thread to + /// access the handler from. + /// + int(CEF_CALLBACK* may_block)(struct _cef_write_handler_t* self); +} cef_write_handler_t; + +/// +/// Structure used to write data to a stream. The functions of this structure +/// may be called on any thread. +/// +typedef struct _cef_stream_writer_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Write raw binary data. + /// + size_t(CEF_CALLBACK* write)(struct _cef_stream_writer_t* self, + const void* ptr, + size_t size, + size_t n); + + /// + /// Seek to the specified offset position. |whence| may be any one of + /// SEEK_CUR, SEEK_END or SEEK_SET. Returns zero on success and non-zero on + /// failure. + /// + int(CEF_CALLBACK* seek)(struct _cef_stream_writer_t* self, + int64 offset, + int whence); + + /// + /// Return the current offset position. + /// + int64(CEF_CALLBACK* tell)(struct _cef_stream_writer_t* self); + + /// + /// Flush the stream. + /// + int(CEF_CALLBACK* flush)(struct _cef_stream_writer_t* self); + + /// + /// Returns true (1) if this writer performs work like accessing the file + /// system which may block. Used as a hint for determining the thread to + /// access the writer from. + /// + int(CEF_CALLBACK* may_block)(struct _cef_stream_writer_t* self); +} cef_stream_writer_t; + +/// +/// Create a new cef_stream_writer_t object for a file. +/// +CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_file( + const cef_string_t* fileName); + +/// +/// Create a new cef_stream_writer_t object for a custom handler. +/// +CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_handler( + cef_write_handler_t* handler); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_ diff --git a/include/capi/cef_string_visitor_capi.h b/include/capi/cef_string_visitor_capi.h new file mode 100644 index 00000000..5ea9b38f --- /dev/null +++ b/include/capi/cef_string_visitor_capi.h @@ -0,0 +1,69 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=6a22e5144c0254acb09656e6e41eedd05f2dd7e7$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to receive string values asynchronously. +/// +typedef struct _cef_string_visitor_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be executed. + /// + void(CEF_CALLBACK* visit)(struct _cef_string_visitor_t* self, + const cef_string_t* string); +} cef_string_visitor_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_ diff --git a/include/capi/cef_task_capi.h b/include/capi/cef_task_capi.h new file mode 100644 index 00000000..3a04e6bc --- /dev/null +++ b/include/capi/cef_task_capi.h @@ -0,0 +1,158 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=273a6abfd4ac030701be00c45811c19e74e128bd$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure for asynchronous task execution. If the task is +/// posted successfully and if the associated message loop is still running then +/// the execute() function will be called on the target thread. If the task +/// fails to post then the task object may be destroyed on the source thread +/// instead of the target thread. For this reason be cautious when performing +/// work in the task object destructor. +/// +typedef struct _cef_task_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Method that will be executed on the target thread. + /// + void(CEF_CALLBACK* execute)(struct _cef_task_t* self); +} cef_task_t; + +/// +/// Structure that asynchronously executes tasks on the associated thread. It is +/// safe to call the functions of this structure on any thread. +/// +/// CEF maintains multiple internal threads that are used for handling different +/// types of tasks in different processes. The cef_thread_id_t definitions in +/// cef_types.h list the common CEF threads. Task runners are also available for +/// other CEF threads as appropriate (for example, V8 WebWorker threads). +/// +typedef struct _cef_task_runner_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is pointing to the same task runner as + /// |that| object. + /// + int(CEF_CALLBACK* is_same)(struct _cef_task_runner_t* self, + struct _cef_task_runner_t* that); + + /// + /// Returns true (1) if this task runner belongs to the current thread. + /// + int(CEF_CALLBACK* belongs_to_current_thread)(struct _cef_task_runner_t* self); + + /// + /// Returns true (1) if this task runner is for the specified CEF thread. + /// + int(CEF_CALLBACK* belongs_to_thread)(struct _cef_task_runner_t* self, + cef_thread_id_t threadId); + + /// + /// Post a task for execution on the thread associated with this task runner. + /// Execution will occur asynchronously. + /// + int(CEF_CALLBACK* post_task)(struct _cef_task_runner_t* self, + struct _cef_task_t* task); + + /// + /// Post a task for delayed execution on the thread associated with this task + /// runner. Execution will occur asynchronously. Delayed tasks are not + /// supported on V8 WebWorker threads and will be executed without the + /// specified delay. + /// + int(CEF_CALLBACK* post_delayed_task)(struct _cef_task_runner_t* self, + struct _cef_task_t* task, + int64 delay_ms); +} cef_task_runner_t; + +/// +/// Returns the task runner for the current thread. Only CEF threads will have +/// task runners. An NULL reference will be returned if this function is called +/// on an invalid thread. +/// +CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_current_thread(void); + +/// +/// Returns the task runner for the specified CEF thread. +/// +CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_thread( + cef_thread_id_t threadId); + +/// +/// Returns true (1) if called on the specified thread. Equivalent to using +/// cef_task_runner_t::GetForThread(threadId)->belongs_to_current_thread(). +/// +CEF_EXPORT int cef_currently_on(cef_thread_id_t threadId); + +/// +/// Post a task for execution on the specified thread. Equivalent to using +/// cef_task_runner_t::GetForThread(threadId)->PostTask(task). +/// +CEF_EXPORT int cef_post_task(cef_thread_id_t threadId, cef_task_t* task); + +/// +/// Post a task for delayed execution on the specified thread. Equivalent to +/// using cef_task_runner_t::GetForThread(threadId)->PostDelayedTask(task, +/// delay_ms). +/// +CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId, + cef_task_t* task, + int64 delay_ms); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_ diff --git a/include/capi/cef_thread_capi.h b/include/capi/cef_thread_capi.h new file mode 100644 index 00000000..adfb79a0 --- /dev/null +++ b/include/capi/cef_thread_capi.h @@ -0,0 +1,117 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=b111114b291d3b91c526e6b3da5741959469ec4a$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_ +#pragma once + +#include "include/capi/cef_task_capi.h" +#include "include/internal/cef_thread_internal.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// A simple thread abstraction that establishes a message loop on a new thread. +/// The consumer uses cef_task_runner_t to execute code on the thread's message +/// loop. The thread is terminated when the cef_thread_t object is destroyed or +/// stop() is called. All pending tasks queued on the thread's message loop will +/// run to completion before the thread is terminated. cef_thread_create() can +/// be called on any valid CEF thread in either the browser or render process. +/// This structure should only be used for tasks that require a dedicated +/// thread. In most cases you can post tasks to an existing CEF thread instead +/// of creating a new one; see cef_task.h for details. +/// +typedef struct _cef_thread_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the cef_task_runner_t that will execute code on this thread's + /// message loop. This function is safe to call from any thread. + /// + struct _cef_task_runner_t*(CEF_CALLBACK* get_task_runner)( + struct _cef_thread_t* self); + + /// + /// Returns the platform thread ID. It will return the same value after stop() + /// is called. This function is safe to call from any thread. + /// + cef_platform_thread_id_t(CEF_CALLBACK* get_platform_thread_id)( + struct _cef_thread_t* self); + + /// + /// Stop and join the thread. This function must be called from the same + /// thread that called cef_thread_create(). Do not call this function if + /// cef_thread_create() was called with a |stoppable| value of false (0). + /// + void(CEF_CALLBACK* stop)(struct _cef_thread_t* self); + + /// + /// Returns true (1) if the thread is currently running. This function must be + /// called from the same thread that called cef_thread_create(). + /// + int(CEF_CALLBACK* is_running)(struct _cef_thread_t* self); +} cef_thread_t; + +/// +/// Create and start a new thread. This function does not block waiting for the +/// thread to run initialization. |display_name| is the name that will be used +/// to identify the thread. |priority| is the thread execution priority. +/// |message_loop_type| indicates the set of asynchronous events that the thread +/// can process. If |stoppable| is true (1) the thread will stopped and joined +/// on destruction or when stop() is called; otherwise, the thread cannot be +/// stopped and will be leaked on shutdown. On Windows the |com_init_mode| value +/// specifies how COM will be initialized for the thread. If |com_init_mode| is +/// set to COM_INIT_MODE_STA then |message_loop_type| must be set to ML_TYPE_UI. +/// +CEF_EXPORT cef_thread_t* cef_thread_create( + const cef_string_t* display_name, + cef_thread_priority_t priority, + cef_message_loop_type_t message_loop_type, + int stoppable, + cef_com_init_mode_t com_init_mode); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_ diff --git a/include/capi/cef_trace_capi.h b/include/capi/cef_trace_capi.h new file mode 100644 index 00000000..183ccdad --- /dev/null +++ b/include/capi/cef_trace_capi.h @@ -0,0 +1,118 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=8d275bd73854b2b8d5a7a5bc55fa737e020705ee$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_callback_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to receive notification when tracing has completed. +/// The functions of this structure will be called on the browser process UI +/// thread. +/// +typedef struct _cef_end_tracing_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called after all processes have sent their trace data. |tracing_file| is + /// the path at which tracing data was written. The client is responsible for + /// deleting |tracing_file|. + /// + void(CEF_CALLBACK* on_end_tracing_complete)( + struct _cef_end_tracing_callback_t* self, + const cef_string_t* tracing_file); +} cef_end_tracing_callback_t; + +/// +/// Start tracing events on all processes. Tracing is initialized asynchronously +/// and |callback| will be executed on the UI thread after initialization is +/// complete. +/// +/// If CefBeginTracing was called previously, or if a CefEndTracingAsync call is +/// pending, CefBeginTracing will fail and return false (0). +/// +/// |categories| is a comma-delimited list of category wildcards. A category can +/// have an optional '-' prefix to make it an excluded category. Having both +/// included and excluded categories in the same list is not supported. +/// +/// Examples: - "test_MyTest*" - "test_MyTest*,test_OtherStuff" - +/// "-excluded_category1,-excluded_category2" +/// +/// This function must be called on the browser process UI thread. +/// +CEF_EXPORT int cef_begin_tracing(const cef_string_t* categories, + struct _cef_completion_callback_t* callback); + +/// +/// Stop tracing events on all processes. +/// +/// This function will fail and return false (0) if a previous call to +/// CefEndTracingAsync is already pending or if CefBeginTracing was not called. +/// +/// |tracing_file| is the path at which tracing data will be written and +/// |callback| is the callback that will be executed once all processes have +/// sent their trace data. If |tracing_file| is NULL a new temporary file path +/// will be used. If |callback| is NULL no trace data will be written. +/// +/// This function must be called on the browser process UI thread. +/// +CEF_EXPORT int cef_end_tracing(const cef_string_t* tracing_file, + cef_end_tracing_callback_t* callback); + +/// +/// Returns the current system trace time or, if none is defined, the current +/// high-res time. Can be used by clients to synchronize with the time +/// information in trace events. +/// +CEF_EXPORT int64 cef_now_from_system_trace_time(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_ diff --git a/include/capi/cef_urlrequest_capi.h b/include/capi/cef_urlrequest_capi.h new file mode 100644 index 00000000..d54ffb78 --- /dev/null +++ b/include/capi/cef_urlrequest_capi.h @@ -0,0 +1,211 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=91c121d4353a80d7fff3ef582c5a56ac86e0a34c$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_ +#pragma once + +#include "include/capi/cef_auth_callback_capi.h" +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_request_capi.h" +#include "include/capi/cef_request_context_capi.h" +#include "include/capi/cef_response_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_urlrequest_client_t; + +/// +/// Structure used to make a URL request. URL requests are not associated with a +/// browser instance so no cef_client_t callbacks will be executed. URL requests +/// can be created on any valid CEF thread in either the browser or render +/// process. Once created the functions of the URL request object must be +/// accessed on the same thread that created it. +/// +typedef struct _cef_urlrequest_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the request object used to create this URL request. The returned + /// object is read-only and should not be modified. + /// + struct _cef_request_t*(CEF_CALLBACK* get_request)( + struct _cef_urlrequest_t* self); + + /// + /// Returns the client. + /// + struct _cef_urlrequest_client_t*(CEF_CALLBACK* get_client)( + struct _cef_urlrequest_t* self); + + /// + /// Returns the request status. + /// + cef_urlrequest_status_t(CEF_CALLBACK* get_request_status)( + struct _cef_urlrequest_t* self); + + /// + /// Returns the request error if status is UR_CANCELED or UR_FAILED, or 0 + /// otherwise. + /// + cef_errorcode_t(CEF_CALLBACK* get_request_error)( + struct _cef_urlrequest_t* self); + + /// + /// Returns the response, or NULL if no response information is available. + /// Response information will only be available after the upload has + /// completed. The returned object is read-only and should not be modified. + /// + struct _cef_response_t*(CEF_CALLBACK* get_response)( + struct _cef_urlrequest_t* self); + + /// + /// Returns true (1) if the response body was served from the cache. This + /// includes responses for which revalidation was required. + /// + int(CEF_CALLBACK* response_was_cached)(struct _cef_urlrequest_t* self); + + /// + /// Cancel the request. + /// + void(CEF_CALLBACK* cancel)(struct _cef_urlrequest_t* self); +} cef_urlrequest_t; + +/// +/// Create a new URL request that is not associated with a specific browser or +/// frame. Use cef_frame_t::CreateURLRequest instead if you want the request to +/// have this association, in which case it may be handled differently (see +/// documentation on that function). A request created with this function may +/// only originate from the browser process, and will behave as follows: +/// - It may be intercepted by the client via CefResourceRequestHandler or +/// CefSchemeHandlerFactory. +/// - POST data may only contain only a single element of type PDE_TYPE_FILE +/// or PDE_TYPE_BYTES. +/// - If |request_context| is empty the global request context will be used. +/// +/// The |request| object will be marked as read-only after calling this +/// function. +/// +CEF_EXPORT cef_urlrequest_t* cef_urlrequest_create( + struct _cef_request_t* request, + struct _cef_urlrequest_client_t* client, + struct _cef_request_context_t* request_context); + +/// +/// Structure that should be implemented by the cef_urlrequest_t client. The +/// functions of this structure will be called on the same thread that created +/// the request unless otherwise documented. +/// +typedef struct _cef_urlrequest_client_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Notifies the client that the request has completed. Use the + /// cef_urlrequest_t::GetRequestStatus function to determine if the request + /// was successful or not. + /// + void(CEF_CALLBACK* on_request_complete)(struct _cef_urlrequest_client_t* self, + struct _cef_urlrequest_t* request); + + /// + /// Notifies the client of upload progress. |current| denotes the number of + /// bytes sent so far and |total| is the total size of uploading data (or -1 + /// if chunked upload is enabled). This function will only be called if the + /// UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request. + /// + void(CEF_CALLBACK* on_upload_progress)(struct _cef_urlrequest_client_t* self, + struct _cef_urlrequest_t* request, + int64 current, + int64 total); + + /// + /// Notifies the client of download progress. |current| denotes the number of + /// bytes received up to the call and |total| is the expected total size of + /// the response (or -1 if not determined). + /// + void(CEF_CALLBACK* on_download_progress)( + struct _cef_urlrequest_client_t* self, + struct _cef_urlrequest_t* request, + int64 current, + int64 total); + + /// + /// Called when some part of the response is read. |data| contains the current + /// bytes received since the last call. This function will not be called if + /// the UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request. + /// + void(CEF_CALLBACK* on_download_data)(struct _cef_urlrequest_client_t* self, + struct _cef_urlrequest_t* request, + const void* data, + size_t data_length); + + /// + /// Called on the IO thread when the browser needs credentials from the user. + /// |isProxy| indicates whether the host is a proxy server. |host| contains + /// the hostname and |port| contains the port number. Return true (1) to + /// continue the request and call cef_auth_callback_t::cont() when the + /// authentication information is available. If the request has an associated + /// browser/frame then returning false (0) will result in a call to + /// GetAuthCredentials on the cef_request_handler_t associated with that + /// browser, if any. Otherwise, returning false (0) will cancel the request + /// immediately. This function will only be called for requests initiated from + /// the browser process. + /// + int(CEF_CALLBACK* get_auth_credentials)( + struct _cef_urlrequest_client_t* self, + int isProxy, + const cef_string_t* host, + int port, + const cef_string_t* realm, + const cef_string_t* scheme, + struct _cef_auth_callback_t* callback); +} cef_urlrequest_client_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_ diff --git a/include/capi/cef_v8_capi.h b/include/capi/cef_v8_capi.h new file mode 100644 index 00000000..7119475e --- /dev/null +++ b/include/capi/cef_v8_capi.h @@ -0,0 +1,1014 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=0d787ac7676ba90d3a1fe68d5e2494b985b1db0e$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_browser_capi.h" +#include "include/capi/cef_frame_capi.h" +#include "include/capi/cef_task_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_v8exception_t; +struct _cef_v8handler_t; +struct _cef_v8stack_frame_t; +struct _cef_v8value_t; + +/// +/// Structure representing a V8 context handle. V8 handles can only be accessed +/// from the thread on which they are created. Valid threads for creating a V8 +/// handle include the render process main thread (TID_RENDERER) and WebWorker +/// threads. A task runner for posting tasks on the associated thread can be +/// retrieved via the cef_v8context_t::get_task_runner() function. +/// +typedef struct _cef_v8context_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the task runner associated with this context. V8 handles can only + /// be accessed from the thread on which they are created. This function can + /// be called on any render process thread. + /// + struct _cef_task_runner_t*(CEF_CALLBACK* get_task_runner)( + struct _cef_v8context_t* self); + + /// + /// Returns true (1) if the underlying handle is valid and it can be accessed + /// on the current thread. Do not call any other functions if this function + /// returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_v8context_t* self); + + /// + /// Returns the browser for this context. This function will return an NULL + /// reference for WebWorker contexts. + /// + struct _cef_browser_t*(CEF_CALLBACK* get_browser)( + struct _cef_v8context_t* self); + + /// + /// Returns the frame for this context. This function will return an NULL + /// reference for WebWorker contexts. + /// + struct _cef_frame_t*(CEF_CALLBACK* get_frame)(struct _cef_v8context_t* self); + + /// + /// Returns the global object for this context. The context must be entered + /// before calling this function. + /// + struct _cef_v8value_t*(CEF_CALLBACK* get_global)( + struct _cef_v8context_t* self); + + /// + /// Enter this context. A context must be explicitly entered before creating a + /// V8 Object, Array, Function or Date asynchronously. exit() must be called + /// the same number of times as enter() before releasing this context. V8 + /// objects belong to the context in which they are created. Returns true (1) + /// if the scope was entered successfully. + /// + int(CEF_CALLBACK* enter)(struct _cef_v8context_t* self); + + /// + /// Exit this context. Call this function only after calling enter(). Returns + /// true (1) if the scope was exited successfully. + /// + int(CEF_CALLBACK* exit)(struct _cef_v8context_t* self); + + /// + /// Returns true (1) if this object is pointing to the same handle as |that| + /// object. + /// + int(CEF_CALLBACK* is_same)(struct _cef_v8context_t* self, + struct _cef_v8context_t* that); + + /// + /// Execute a string of JavaScript code in this V8 context. The |script_url| + /// parameter is the URL where the script in question can be found, if any. + /// The |start_line| parameter is the base line number to use for error + /// reporting. On success |retval| will be set to the return value, if any, + /// and the function will return true (1). On failure |exception| will be set + /// to the exception, if any, and the function will return false (0). + /// + int(CEF_CALLBACK* eval)(struct _cef_v8context_t* self, + const cef_string_t* code, + const cef_string_t* script_url, + int start_line, + struct _cef_v8value_t** retval, + struct _cef_v8exception_t** exception); +} cef_v8context_t; + +/// +/// Returns the current (top) context object in the V8 context stack. +/// +CEF_EXPORT cef_v8context_t* cef_v8context_get_current_context(void); + +/// +/// Returns the entered (bottom) context object in the V8 context stack. +/// +CEF_EXPORT cef_v8context_t* cef_v8context_get_entered_context(void); + +/// +/// Returns true (1) if V8 is currently inside a context. +/// +CEF_EXPORT int cef_v8context_in_context(void); + +/// +/// Structure that should be implemented to handle V8 function calls. The +/// functions of this structure will be called on the thread associated with the +/// V8 function. +/// +typedef struct _cef_v8handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Handle execution of the function identified by |name|. |object| is the + /// receiver ('this' object) of the function. |arguments| is the list of + /// arguments passed to the function. If execution succeeds set |retval| to + /// the function return value. If execution fails set |exception| to the + /// exception that will be thrown. Return true (1) if execution was handled. + /// + int(CEF_CALLBACK* execute)(struct _cef_v8handler_t* self, + const cef_string_t* name, + struct _cef_v8value_t* object, + size_t argumentsCount, + struct _cef_v8value_t* const* arguments, + struct _cef_v8value_t** retval, + cef_string_t* exception); +} cef_v8handler_t; + +/// +/// Structure that should be implemented to handle V8 accessor calls. Accessor +/// identifiers are registered by calling cef_v8value_t::set_value(). The +/// functions of this structure will be called on the thread associated with the +/// V8 accessor. +/// +typedef struct _cef_v8accessor_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Handle retrieval the accessor value identified by |name|. |object| is the + /// receiver ('this' object) of the accessor. If retrieval succeeds set + /// |retval| to the return value. If retrieval fails set |exception| to the + /// exception that will be thrown. Return true (1) if accessor retrieval was + /// handled. + /// + int(CEF_CALLBACK* get)(struct _cef_v8accessor_t* self, + const cef_string_t* name, + struct _cef_v8value_t* object, + struct _cef_v8value_t** retval, + cef_string_t* exception); + + /// + /// Handle assignment of the accessor value identified by |name|. |object| is + /// the receiver ('this' object) of the accessor. |value| is the new value + /// being assigned to the accessor. If assignment fails set |exception| to the + /// exception that will be thrown. Return true (1) if accessor assignment was + /// handled. + /// + int(CEF_CALLBACK* set)(struct _cef_v8accessor_t* self, + const cef_string_t* name, + struct _cef_v8value_t* object, + struct _cef_v8value_t* value, + cef_string_t* exception); +} cef_v8accessor_t; + +/// +/// Structure that should be implemented to handle V8 interceptor calls. The +/// functions of this structure will be called on the thread associated with the +/// V8 interceptor. Interceptor's named property handlers (with first argument +/// of type CefString) are called when object is indexed by string. Indexed +/// property handlers (with first argument of type int) are called when object +/// is indexed by integer. +/// +typedef struct _cef_v8interceptor_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Handle retrieval of the interceptor value identified by |name|. |object| + /// is the receiver ('this' object) of the interceptor. If retrieval succeeds, + /// set |retval| to the return value. If the requested value does not exist, + /// don't set either |retval| or |exception|. If retrieval fails, set + /// |exception| to the exception that will be thrown. If the property has an + /// associated accessor, it will be called only if you don't set |retval|. + /// Return true (1) if interceptor retrieval was handled, false (0) otherwise. + /// + int(CEF_CALLBACK* get_byname)(struct _cef_v8interceptor_t* self, + const cef_string_t* name, + struct _cef_v8value_t* object, + struct _cef_v8value_t** retval, + cef_string_t* exception); + + /// + /// Handle retrieval of the interceptor value identified by |index|. |object| + /// is the receiver ('this' object) of the interceptor. If retrieval succeeds, + /// set |retval| to the return value. If the requested value does not exist, + /// don't set either |retval| or |exception|. If retrieval fails, set + /// |exception| to the exception that will be thrown. Return true (1) if + /// interceptor retrieval was handled, false (0) otherwise. + /// + int(CEF_CALLBACK* get_byindex)(struct _cef_v8interceptor_t* self, + int index, + struct _cef_v8value_t* object, + struct _cef_v8value_t** retval, + cef_string_t* exception); + + /// + /// Handle assignment of the interceptor value identified by |name|. |object| + /// is the receiver ('this' object) of the interceptor. |value| is the new + /// value being assigned to the interceptor. If assignment fails, set + /// |exception| to the exception that will be thrown. This setter will always + /// be called, even when the property has an associated accessor. Return true + /// (1) if interceptor assignment was handled, false (0) otherwise. + /// + int(CEF_CALLBACK* set_byname)(struct _cef_v8interceptor_t* self, + const cef_string_t* name, + struct _cef_v8value_t* object, + struct _cef_v8value_t* value, + cef_string_t* exception); + + /// + /// Handle assignment of the interceptor value identified by |index|. |object| + /// is the receiver ('this' object) of the interceptor. |value| is the new + /// value being assigned to the interceptor. If assignment fails, set + /// |exception| to the exception that will be thrown. Return true (1) if + /// interceptor assignment was handled, false (0) otherwise. + /// + int(CEF_CALLBACK* set_byindex)(struct _cef_v8interceptor_t* self, + int index, + struct _cef_v8value_t* object, + struct _cef_v8value_t* value, + cef_string_t* exception); +} cef_v8interceptor_t; + +/// +/// Structure representing a V8 exception. The functions of this structure may +/// be called on any render process thread. +/// +typedef struct _cef_v8exception_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the exception message. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_message)( + struct _cef_v8exception_t* self); + + /// + /// Returns the line of source code that the exception occurred within. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_source_line)( + struct _cef_v8exception_t* self); + + /// + /// Returns the resource name for the script from where the function causing + /// the error originates. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_script_resource_name)( + struct _cef_v8exception_t* self); + + /// + /// Returns the 1-based number of the line where the error occurred or 0 if + /// the line number is unknown. + /// + int(CEF_CALLBACK* get_line_number)(struct _cef_v8exception_t* self); + + /// + /// Returns the index within the script of the first character where the error + /// occurred. + /// + int(CEF_CALLBACK* get_start_position)(struct _cef_v8exception_t* self); + + /// + /// Returns the index within the script of the last character where the error + /// occurred. + /// + int(CEF_CALLBACK* get_end_position)(struct _cef_v8exception_t* self); + + /// + /// Returns the index within the line of the first character where the error + /// occurred. + /// + int(CEF_CALLBACK* get_start_column)(struct _cef_v8exception_t* self); + + /// + /// Returns the index within the line of the last character where the error + /// occurred. + /// + int(CEF_CALLBACK* get_end_column)(struct _cef_v8exception_t* self); +} cef_v8exception_t; + +/// +/// Callback structure that is passed to cef_v8value_t::CreateArrayBuffer. +/// +typedef struct _cef_v8array_buffer_release_callback_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called to release |buffer| when the ArrayBuffer JS object is garbage + /// collected. |buffer| is the value that was passed to CreateArrayBuffer + /// along with this object. + /// + void(CEF_CALLBACK* release_buffer)( + struct _cef_v8array_buffer_release_callback_t* self, + void* buffer); +} cef_v8array_buffer_release_callback_t; + +/// +/// Structure representing a V8 value handle. V8 handles can only be accessed +/// from the thread on which they are created. Valid threads for creating a V8 +/// handle include the render process main thread (TID_RENDERER) and WebWorker +/// threads. A task runner for posting tasks on the associated thread can be +/// retrieved via the cef_v8context_t::get_task_runner() function. +/// +typedef struct _cef_v8value_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if the underlying handle is valid and it can be accessed + /// on the current thread. Do not call any other functions if this function + /// returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_v8value_t* self); + + /// + /// True if the value type is undefined. + /// + int(CEF_CALLBACK* is_undefined)(struct _cef_v8value_t* self); + + /// + /// True if the value type is null. + /// + int(CEF_CALLBACK* is_null)(struct _cef_v8value_t* self); + + /// + /// True if the value type is bool. + /// + int(CEF_CALLBACK* is_bool)(struct _cef_v8value_t* self); + + /// + /// True if the value type is int. + /// + int(CEF_CALLBACK* is_int)(struct _cef_v8value_t* self); + + /// + /// True if the value type is unsigned int. + /// + int(CEF_CALLBACK* is_uint)(struct _cef_v8value_t* self); + + /// + /// True if the value type is double. + /// + int(CEF_CALLBACK* is_double)(struct _cef_v8value_t* self); + + /// + /// True if the value type is Date. + /// + int(CEF_CALLBACK* is_date)(struct _cef_v8value_t* self); + + /// + /// True if the value type is string. + /// + int(CEF_CALLBACK* is_string)(struct _cef_v8value_t* self); + + /// + /// True if the value type is object. + /// + int(CEF_CALLBACK* is_object)(struct _cef_v8value_t* self); + + /// + /// True if the value type is array. + /// + int(CEF_CALLBACK* is_array)(struct _cef_v8value_t* self); + + /// + /// True if the value type is an ArrayBuffer. + /// + int(CEF_CALLBACK* is_array_buffer)(struct _cef_v8value_t* self); + + /// + /// True if the value type is function. + /// + int(CEF_CALLBACK* is_function)(struct _cef_v8value_t* self); + + /// + /// True if the value type is a Promise. + /// + int(CEF_CALLBACK* is_promise)(struct _cef_v8value_t* self); + + /// + /// Returns true (1) if this object is pointing to the same handle as |that| + /// object. + /// + int(CEF_CALLBACK* is_same)(struct _cef_v8value_t* self, + struct _cef_v8value_t* that); + + /// + /// Return a bool value. + /// + int(CEF_CALLBACK* get_bool_value)(struct _cef_v8value_t* self); + + /// + /// Return an int value. + /// + int32(CEF_CALLBACK* get_int_value)(struct _cef_v8value_t* self); + + /// + /// Return an unsigned int value. + /// + uint32(CEF_CALLBACK* get_uint_value)(struct _cef_v8value_t* self); + + /// + /// Return a double value. + /// + double(CEF_CALLBACK* get_double_value)(struct _cef_v8value_t* self); + + /// + /// Return a Date value. + /// + cef_basetime_t(CEF_CALLBACK* get_date_value)(struct _cef_v8value_t* self); + + /// + /// Return a string value. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_string_value)( + struct _cef_v8value_t* self); + + /// + /// Returns true (1) if this is a user created object. + /// + int(CEF_CALLBACK* is_user_created)(struct _cef_v8value_t* self); + + /// + /// Returns true (1) if the last function call resulted in an exception. This + /// attribute exists only in the scope of the current CEF value object. + /// + int(CEF_CALLBACK* has_exception)(struct _cef_v8value_t* self); + + /// + /// Returns the exception resulting from the last function call. This + /// attribute exists only in the scope of the current CEF value object. + /// + struct _cef_v8exception_t*(CEF_CALLBACK* get_exception)( + struct _cef_v8value_t* self); + + /// + /// Clears the last exception and returns true (1) on success. + /// + int(CEF_CALLBACK* clear_exception)(struct _cef_v8value_t* self); + + /// + /// Returns true (1) if this object will re-throw future exceptions. This + /// attribute exists only in the scope of the current CEF value object. + /// + int(CEF_CALLBACK* will_rethrow_exceptions)(struct _cef_v8value_t* self); + + /// + /// Set whether this object will re-throw future exceptions. By default + /// exceptions are not re-thrown. If a exception is re-thrown the current + /// context should not be accessed again until after the exception has been + /// caught and not re-thrown. Returns true (1) on success. This attribute + /// exists only in the scope of the current CEF value object. + /// + int(CEF_CALLBACK* set_rethrow_exceptions)(struct _cef_v8value_t* self, + int rethrow); + + /// + /// Returns true (1) if the object has a value with the specified identifier. + /// + int(CEF_CALLBACK* has_value_bykey)(struct _cef_v8value_t* self, + const cef_string_t* key); + + /// + /// Returns true (1) if the object has a value with the specified identifier. + /// + int(CEF_CALLBACK* has_value_byindex)(struct _cef_v8value_t* self, int index); + + /// + /// Deletes the value with the specified identifier and returns true (1) on + /// success. Returns false (0) if this function is called incorrectly or an + /// exception is thrown. For read-only and don't-delete values this function + /// will return true (1) even though deletion failed. + /// + int(CEF_CALLBACK* delete_value_bykey)(struct _cef_v8value_t* self, + const cef_string_t* key); + + /// + /// Deletes the value with the specified identifier and returns true (1) on + /// success. Returns false (0) if this function is called incorrectly, + /// deletion fails or an exception is thrown. For read-only and don't-delete + /// values this function will return true (1) even though deletion failed. + /// + int(CEF_CALLBACK* delete_value_byindex)(struct _cef_v8value_t* self, + int index); + + /// + /// Returns the value with the specified identifier on success. Returns NULL + /// if this function is called incorrectly or an exception is thrown. + /// + struct _cef_v8value_t*(CEF_CALLBACK* get_value_bykey)( + struct _cef_v8value_t* self, + const cef_string_t* key); + + /// + /// Returns the value with the specified identifier on success. Returns NULL + /// if this function is called incorrectly or an exception is thrown. + /// + struct _cef_v8value_t*( + CEF_CALLBACK* get_value_byindex)(struct _cef_v8value_t* self, int index); + + /// + /// Associates a value with the specified identifier and returns true (1) on + /// success. Returns false (0) if this function is called incorrectly or an + /// exception is thrown. For read-only values this function will return true + /// (1) even though assignment failed. + /// + int(CEF_CALLBACK* set_value_bykey)(struct _cef_v8value_t* self, + const cef_string_t* key, + struct _cef_v8value_t* value, + cef_v8_propertyattribute_t attribute); + + /// + /// Associates a value with the specified identifier and returns true (1) on + /// success. Returns false (0) if this function is called incorrectly or an + /// exception is thrown. For read-only values this function will return true + /// (1) even though assignment failed. + /// + int(CEF_CALLBACK* set_value_byindex)(struct _cef_v8value_t* self, + int index, + struct _cef_v8value_t* value); + + /// + /// Registers an identifier and returns true (1) on success. Access to the + /// identifier will be forwarded to the cef_v8accessor_t instance passed to + /// cef_v8value_t::cef_v8value_create_object(). Returns false (0) if this + /// function is called incorrectly or an exception is thrown. For read-only + /// values this function will return true (1) even though assignment failed. + /// + int(CEF_CALLBACK* set_value_byaccessor)(struct _cef_v8value_t* self, + const cef_string_t* key, + cef_v8_accesscontrol_t settings, + cef_v8_propertyattribute_t attribute); + + /// + /// Read the keys for the object's values into the specified vector. Integer- + /// based keys will also be returned as strings. + /// + int(CEF_CALLBACK* get_keys)(struct _cef_v8value_t* self, + cef_string_list_t keys); + + /// + /// Sets the user data for this object and returns true (1) on success. + /// Returns false (0) if this function is called incorrectly. This function + /// can only be called on user created objects. + /// + int(CEF_CALLBACK* set_user_data)(struct _cef_v8value_t* self, + struct _cef_base_ref_counted_t* user_data); + + /// + /// Returns the user data, if any, assigned to this object. + /// + struct _cef_base_ref_counted_t*(CEF_CALLBACK* get_user_data)( + struct _cef_v8value_t* self); + + /// + /// Returns the amount of externally allocated memory registered for the + /// object. + /// + int(CEF_CALLBACK* get_externally_allocated_memory)( + struct _cef_v8value_t* self); + + /// + /// Adjusts the amount of registered external memory for the object. Used to + /// give V8 an indication of the amount of externally allocated memory that is + /// kept alive by JavaScript objects. V8 uses this information to decide when + /// to perform global garbage collection. Each cef_v8value_t tracks the amount + /// of external memory associated with it and automatically decreases the + /// global total by the appropriate amount on its destruction. + /// |change_in_bytes| specifies the number of bytes to adjust by. This + /// function returns the number of bytes associated with the object after the + /// adjustment. This function can only be called on user created objects. + /// + int(CEF_CALLBACK* adjust_externally_allocated_memory)( + struct _cef_v8value_t* self, + int change_in_bytes); + + /// + /// Returns the number of elements in the array. + /// + int(CEF_CALLBACK* get_array_length)(struct _cef_v8value_t* self); + + /// + /// Returns the ReleaseCallback object associated with the ArrayBuffer or NULL + /// if the ArrayBuffer was not created with CreateArrayBuffer. + /// + struct _cef_v8array_buffer_release_callback_t*( + CEF_CALLBACK* get_array_buffer_release_callback)( + struct _cef_v8value_t* self); + + /// + /// Prevent the ArrayBuffer from using it's memory block by setting the length + /// to zero. This operation cannot be undone. If the ArrayBuffer was created + /// with CreateArrayBuffer then + /// cef_v8array_buffer_release_callback_t::ReleaseBuffer will be called to + /// release the underlying buffer. + /// + int(CEF_CALLBACK* neuter_array_buffer)(struct _cef_v8value_t* self); + + /// + /// Returns the function name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_function_name)( + struct _cef_v8value_t* self); + + /// + /// Returns the function handler or NULL if not a CEF-created function. + /// + struct _cef_v8handler_t*(CEF_CALLBACK* get_function_handler)( + struct _cef_v8value_t* self); + + /// + /// Execute the function using the current V8 context. This function should + /// only be called from within the scope of a cef_v8handler_t or + /// cef_v8accessor_t callback, or in combination with calling enter() and + /// exit() on a stored cef_v8context_t reference. |object| is the receiver + /// ('this' object) of the function. If |object| is NULL the current context's + /// global object will be used. |arguments| is the list of arguments that will + /// be passed to the function. Returns the function return value on success. + /// Returns NULL if this function is called incorrectly or an exception is + /// thrown. + /// + struct _cef_v8value_t*(CEF_CALLBACK* execute_function)( + struct _cef_v8value_t* self, + struct _cef_v8value_t* object, + size_t argumentsCount, + struct _cef_v8value_t* const* arguments); + + /// + /// Execute the function using the specified V8 context. |object| is the + /// receiver ('this' object) of the function. If |object| is NULL the + /// specified context's global object will be used. |arguments| is the list of + /// arguments that will be passed to the function. Returns the function return + /// value on success. Returns NULL if this function is called incorrectly or + /// an exception is thrown. + /// + struct _cef_v8value_t*(CEF_CALLBACK* execute_function_with_context)( + struct _cef_v8value_t* self, + struct _cef_v8context_t* context, + struct _cef_v8value_t* object, + size_t argumentsCount, + struct _cef_v8value_t* const* arguments); + + /// + /// Resolve the Promise using the current V8 context. This function should + /// only be called from within the scope of a cef_v8handler_t or + /// cef_v8accessor_t callback, or in combination with calling enter() and + /// exit() on a stored cef_v8context_t reference. |arg| is the argument passed + /// to the resolved promise. Returns true (1) on success. Returns false (0) if + /// this function is called incorrectly or an exception is thrown. + /// + int(CEF_CALLBACK* resolve_promise)(struct _cef_v8value_t* self, + struct _cef_v8value_t* arg); + + /// + /// Reject the Promise using the current V8 context. This function should only + /// be called from within the scope of a cef_v8handler_t or cef_v8accessor_t + /// callback, or in combination with calling enter() and exit() on a stored + /// cef_v8context_t reference. Returns true (1) on success. Returns false (0) + /// if this function is called incorrectly or an exception is thrown. + /// + int(CEF_CALLBACK* reject_promise)(struct _cef_v8value_t* self, + const cef_string_t* errorMsg); +} cef_v8value_t; + +/// +/// Create a new cef_v8value_t object of type undefined. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_undefined(void); + +/// +/// Create a new cef_v8value_t object of type null. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_null(void); + +/// +/// Create a new cef_v8value_t object of type bool. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_bool(int value); + +/// +/// Create a new cef_v8value_t object of type int. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_int(int32 value); + +/// +/// Create a new cef_v8value_t object of type unsigned int. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_uint(uint32 value); + +/// +/// Create a new cef_v8value_t object of type double. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_double(double value); + +/// +/// Create a new cef_v8value_t object of type Date. This function should only be +/// called from within the scope of a cef_render_process_handler_t, +/// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling +/// enter() and exit() on a stored cef_v8context_t reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_date(cef_basetime_t date); + +/// +/// Create a new cef_v8value_t object of type string. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_string(const cef_string_t* value); + +/// +/// Create a new cef_v8value_t object of type object with optional accessor +/// and/or interceptor. This function should only be called from within the +/// scope of a cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t +/// callback, or in combination with calling enter() and exit() on a stored +/// cef_v8context_t reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_object( + cef_v8accessor_t* accessor, + cef_v8interceptor_t* interceptor); + +/// +/// Create a new cef_v8value_t object of type array with the specified |length|. +/// If |length| is negative the returned array will have length 0. This function +/// should only be called from within the scope of a +/// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback, +/// or in combination with calling enter() and exit() on a stored +/// cef_v8context_t reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_array(int length); + +/// +/// Create a new cef_v8value_t object of type ArrayBuffer which wraps the +/// provided |buffer| of size |length| bytes. The ArrayBuffer is externalized, +/// meaning that it does not own |buffer|. The caller is responsible for freeing +/// |buffer| when requested via a call to +/// cef_v8array_buffer_release_callback_t::ReleaseBuffer. This function should +/// only be called from within the scope of a cef_render_process_handler_t, +/// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling +/// enter() and exit() on a stored cef_v8context_t reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_array_buffer( + void* buffer, + size_t length, + cef_v8array_buffer_release_callback_t* release_callback); + +/// +/// Create a new cef_v8value_t object of type function. This function should +/// only be called from within the scope of a cef_render_process_handler_t, +/// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling +/// enter() and exit() on a stored cef_v8context_t reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const cef_string_t* name, + cef_v8handler_t* handler); + +/// +/// Create a new cef_v8value_t object of type Promise. This function should only +/// be called from within the scope of a cef_render_process_handler_t, +/// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling +/// enter() and exit() on a stored cef_v8context_t reference. +/// +CEF_EXPORT cef_v8value_t* cef_v8value_create_promise(void); + +/// +/// Structure representing a V8 stack trace handle. V8 handles can only be +/// accessed from the thread on which they are created. Valid threads for +/// creating a V8 handle include the render process main thread (TID_RENDERER) +/// and WebWorker threads. A task runner for posting tasks on the associated +/// thread can be retrieved via the cef_v8context_t::get_task_runner() function. +/// +typedef struct _cef_v8stack_trace_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if the underlying handle is valid and it can be accessed + /// on the current thread. Do not call any other functions if this function + /// returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_v8stack_trace_t* self); + + /// + /// Returns the number of stack frames. + /// + int(CEF_CALLBACK* get_frame_count)(struct _cef_v8stack_trace_t* self); + + /// + /// Returns the stack frame at the specified 0-based index. + /// + struct _cef_v8stack_frame_t*( + CEF_CALLBACK* get_frame)(struct _cef_v8stack_trace_t* self, int index); +} cef_v8stack_trace_t; + +/// +/// Returns the stack trace for the currently active context. |frame_limit| is +/// the maximum number of frames that will be captured. +/// +CEF_EXPORT cef_v8stack_trace_t* cef_v8stack_trace_get_current(int frame_limit); + +/// +/// Structure representing a V8 stack frame handle. V8 handles can only be +/// accessed from the thread on which they are created. Valid threads for +/// creating a V8 handle include the render process main thread (TID_RENDERER) +/// and WebWorker threads. A task runner for posting tasks on the associated +/// thread can be retrieved via the cef_v8context_t::get_task_runner() function. +/// +typedef struct _cef_v8stack_frame_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if the underlying handle is valid and it can be accessed + /// on the current thread. Do not call any other functions if this function + /// returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_v8stack_frame_t* self); + + /// + /// Returns the name of the resource script that contains the function. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_script_name)( + struct _cef_v8stack_frame_t* self); + + /// + /// Returns the name of the resource script that contains the function or the + /// sourceURL value if the script name is undefined and its source ends with a + /// "//@ sourceURL=..." string. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_script_name_or_source_url)( + struct _cef_v8stack_frame_t* self); + + /// + /// Returns the name of the function. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_function_name)( + struct _cef_v8stack_frame_t* self); + + /// + /// Returns the 1-based line number for the function call or 0 if unknown. + /// + int(CEF_CALLBACK* get_line_number)(struct _cef_v8stack_frame_t* self); + + /// + /// Returns the 1-based column offset on the line for the function call or 0 + /// if unknown. + /// + int(CEF_CALLBACK* get_column)(struct _cef_v8stack_frame_t* self); + + /// + /// Returns true (1) if the function was compiled using eval(). + /// + int(CEF_CALLBACK* is_eval)(struct _cef_v8stack_frame_t* self); + + /// + /// Returns true (1) if the function was called as a constructor via "new". + /// + int(CEF_CALLBACK* is_constructor)(struct _cef_v8stack_frame_t* self); +} cef_v8stack_frame_t; + +/// +/// Register a new V8 extension with the specified JavaScript extension code and +/// handler. Functions implemented by the handler are prototyped using the +/// keyword 'native'. The calling of a native function is restricted to the +/// scope in which the prototype of the native function is defined. This +/// function may only be called on the render process main thread. +/// +/// Example JavaScript extension code: <pre> +/// // create the 'example' global object if it doesn't already exist. +/// if (!example) +/// example = {}; +/// // create the 'example.test' global object if it doesn't already exist. +/// if (!example.test) +/// example.test = {}; +/// (function() { +/// // Define the function 'example.test.myfunction'. +/// example.test.myfunction = function() { +/// // Call CefV8Handler::Execute() with the function name 'MyFunction' +/// // and no arguments. +/// native function MyFunction(); +/// return MyFunction(); +/// }; +/// // Define the getter function for parameter 'example.test.myparam'. +/// example.test.__defineGetter__('myparam', function() { +/// // Call CefV8Handler::Execute() with the function name 'GetMyParam' +/// // and no arguments. +/// native function GetMyParam(); +/// return GetMyParam(); +/// }); +/// // Define the setter function for parameter 'example.test.myparam'. +/// example.test.__defineSetter__('myparam', function(b) { +/// // Call CefV8Handler::Execute() with the function name 'SetMyParam' +/// // and a single argument. +/// native function SetMyParam(); +/// if(b) SetMyParam(b); +/// }); +/// +/// // Extension definitions can also contain normal JavaScript variables +/// // and functions. +/// var myint = 0; +/// example.test.increment = function() { +/// myint += 1; +/// return myint; +/// }; +/// })(); +/// </pre> +/// +/// Example usage in the page: <pre> +/// // Call the function. +/// example.test.myfunction(); +/// // Set the parameter. +/// example.test.myparam = value; +/// // Get the parameter. +/// value = example.test.myparam; +/// // Call another function. +/// example.test.increment(); +/// </pre> +/// +CEF_EXPORT int cef_register_extension(const cef_string_t* extension_name, + const cef_string_t* javascript_code, + cef_v8handler_t* handler); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_ diff --git a/include/capi/cef_values_capi.h b/include/capi/cef_values_capi.h new file mode 100644 index 00000000..50abd75f --- /dev/null +++ b/include/capi/cef_values_capi.h @@ -0,0 +1,755 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=1b8f7f620685c30b91c8fa656e1a01d182684ae6$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_binary_value_t; +struct _cef_dictionary_value_t; +struct _cef_list_value_t; + +/// +/// Structure that wraps other data value types. Complex types (binary, +/// dictionary and list) will be referenced but not owned by this object. Can be +/// used on any process and thread. +/// +typedef struct _cef_value_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if the underlying data is valid. This will always be true + /// (1) for simple types. For complex types (binary, dictionary and list) the + /// underlying data may become invalid if owned by another object (e.g. list + /// or dictionary) and that other object is then modified or destroyed. This + /// value object can be re-used by calling Set*() even if the underlying data + /// is invalid. + /// + int(CEF_CALLBACK* is_valid)(struct _cef_value_t* self); + + /// + /// Returns true (1) if the underlying data is owned by another object. + /// + int(CEF_CALLBACK* is_owned)(struct _cef_value_t* self); + + /// + /// Returns true (1) if the underlying data is read-only. Some APIs may expose + /// read-only objects. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_value_t* self); + + /// + /// Returns true (1) if this object and |that| object have the same underlying + /// data. If true (1) modifications to this object will also affect |that| + /// object and vice-versa. + /// + int(CEF_CALLBACK* is_same)(struct _cef_value_t* self, + struct _cef_value_t* that); + + /// + /// Returns true (1) if this object and |that| object have an equivalent + /// underlying value but are not necessarily the same object. + /// + int(CEF_CALLBACK* is_equal)(struct _cef_value_t* self, + struct _cef_value_t* that); + + /// + /// Returns a copy of this object. The underlying data will also be copied. + /// + struct _cef_value_t*(CEF_CALLBACK* copy)(struct _cef_value_t* self); + + /// + /// Returns the underlying value type. + /// + cef_value_type_t(CEF_CALLBACK* get_type)(struct _cef_value_t* self); + + /// + /// Returns the underlying value as type bool. + /// + int(CEF_CALLBACK* get_bool)(struct _cef_value_t* self); + + /// + /// Returns the underlying value as type int. + /// + int(CEF_CALLBACK* get_int)(struct _cef_value_t* self); + + /// + /// Returns the underlying value as type double. + /// + double(CEF_CALLBACK* get_double)(struct _cef_value_t* self); + + /// + /// Returns the underlying value as type string. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_string)(struct _cef_value_t* self); + + /// + /// Returns the underlying value as type binary. The returned reference may + /// become invalid if the value is owned by another object or if ownership is + /// transferred to another object in the future. To maintain a reference to + /// the value after assigning ownership to a dictionary or list pass this + /// object to the set_value() function instead of passing the returned + /// reference to set_binary(). + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_binary)( + struct _cef_value_t* self); + + /// + /// Returns the underlying value as type dictionary. The returned reference + /// may become invalid if the value is owned by another object or if ownership + /// is transferred to another object in the future. To maintain a reference to + /// the value after assigning ownership to a dictionary or list pass this + /// object to the set_value() function instead of passing the returned + /// reference to set_dictionary(). + /// + struct _cef_dictionary_value_t*(CEF_CALLBACK* get_dictionary)( + struct _cef_value_t* self); + + /// + /// Returns the underlying value as type list. The returned reference may + /// become invalid if the value is owned by another object or if ownership is + /// transferred to another object in the future. To maintain a reference to + /// the value after assigning ownership to a dictionary or list pass this + /// object to the set_value() function instead of passing the returned + /// reference to set_list(). + /// + struct _cef_list_value_t*(CEF_CALLBACK* get_list)(struct _cef_value_t* self); + + /// + /// Sets the underlying value as type null. Returns true (1) if the value was + /// set successfully. + /// + int(CEF_CALLBACK* set_null)(struct _cef_value_t* self); + + /// + /// Sets the underlying value as type bool. Returns true (1) if the value was + /// set successfully. + /// + int(CEF_CALLBACK* set_bool)(struct _cef_value_t* self, int value); + + /// + /// Sets the underlying value as type int. Returns true (1) if the value was + /// set successfully. + /// + int(CEF_CALLBACK* set_int)(struct _cef_value_t* self, int value); + + /// + /// Sets the underlying value as type double. Returns true (1) if the value + /// was set successfully. + /// + int(CEF_CALLBACK* set_double)(struct _cef_value_t* self, double value); + + /// + /// Sets the underlying value as type string. Returns true (1) if the value + /// was set successfully. + /// + int(CEF_CALLBACK* set_string)(struct _cef_value_t* self, + const cef_string_t* value); + + /// + /// Sets the underlying value as type binary. Returns true (1) if the value + /// was set successfully. This object keeps a reference to |value| and + /// ownership of the underlying data remains unchanged. + /// + int(CEF_CALLBACK* set_binary)(struct _cef_value_t* self, + struct _cef_binary_value_t* value); + + /// + /// Sets the underlying value as type dict. Returns true (1) if the value was + /// set successfully. This object keeps a reference to |value| and ownership + /// of the underlying data remains unchanged. + /// + int(CEF_CALLBACK* set_dictionary)(struct _cef_value_t* self, + struct _cef_dictionary_value_t* value); + + /// + /// Sets the underlying value as type list. Returns true (1) if the value was + /// set successfully. This object keeps a reference to |value| and ownership + /// of the underlying data remains unchanged. + /// + int(CEF_CALLBACK* set_list)(struct _cef_value_t* self, + struct _cef_list_value_t* value); +} cef_value_t; + +/// +/// Creates a new object. +/// +CEF_EXPORT cef_value_t* cef_value_create(void); + +/// +/// Structure representing a binary value. Can be used on any process and +/// thread. +/// +typedef struct _cef_binary_value_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. This object may become invalid + /// if the underlying data is owned by another object (e.g. list or + /// dictionary) and that other object is then modified or destroyed. Do not + /// call any other functions if this function returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_binary_value_t* self); + + /// + /// Returns true (1) if this object is currently owned by another object. + /// + int(CEF_CALLBACK* is_owned)(struct _cef_binary_value_t* self); + + /// + /// Returns true (1) if this object and |that| object have the same underlying + /// data. + /// + int(CEF_CALLBACK* is_same)(struct _cef_binary_value_t* self, + struct _cef_binary_value_t* that); + + /// + /// Returns true (1) if this object and |that| object have an equivalent + /// underlying value but are not necessarily the same object. + /// + int(CEF_CALLBACK* is_equal)(struct _cef_binary_value_t* self, + struct _cef_binary_value_t* that); + + /// + /// Returns a copy of this object. The data in this object will also be + /// copied. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* copy)( + struct _cef_binary_value_t* self); + + /// + /// Returns the data size. + /// + size_t(CEF_CALLBACK* get_size)(struct _cef_binary_value_t* self); + + /// + /// Read up to |buffer_size| number of bytes into |buffer|. Reading begins at + /// the specified byte |data_offset|. Returns the number of bytes read. + /// + size_t(CEF_CALLBACK* get_data)(struct _cef_binary_value_t* self, + void* buffer, + size_t buffer_size, + size_t data_offset); +} cef_binary_value_t; + +/// +/// Creates a new object that is not owned by any other object. The specified +/// |data| will be copied. +/// +CEF_EXPORT cef_binary_value_t* cef_binary_value_create(const void* data, + size_t data_size); + +/// +/// Structure representing a dictionary value. Can be used on any process and +/// thread. +/// +typedef struct _cef_dictionary_value_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. This object may become invalid + /// if the underlying data is owned by another object (e.g. list or + /// dictionary) and that other object is then modified or destroyed. Do not + /// call any other functions if this function returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_dictionary_value_t* self); + + /// + /// Returns true (1) if this object is currently owned by another object. + /// + int(CEF_CALLBACK* is_owned)(struct _cef_dictionary_value_t* self); + + /// + /// Returns true (1) if the values of this object are read-only. Some APIs may + /// expose read-only objects. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_dictionary_value_t* self); + + /// + /// Returns true (1) if this object and |that| object have the same underlying + /// data. If true (1) modifications to this object will also affect |that| + /// object and vice-versa. + /// + int(CEF_CALLBACK* is_same)(struct _cef_dictionary_value_t* self, + struct _cef_dictionary_value_t* that); + + /// + /// Returns true (1) if this object and |that| object have an equivalent + /// underlying value but are not necessarily the same object. + /// + int(CEF_CALLBACK* is_equal)(struct _cef_dictionary_value_t* self, + struct _cef_dictionary_value_t* that); + + /// + /// Returns a writable copy of this object. If |exclude_NULL_children| is true + /// (1) any NULL dictionaries or lists will be excluded from the copy. + /// + struct _cef_dictionary_value_t*(CEF_CALLBACK* copy)( + struct _cef_dictionary_value_t* self, + int exclude_empty_children); + + /// + /// Returns the number of values. + /// + size_t(CEF_CALLBACK* get_size)(struct _cef_dictionary_value_t* self); + + /// + /// Removes all values. Returns true (1) on success. + /// + int(CEF_CALLBACK* clear)(struct _cef_dictionary_value_t* self); + + /// + /// Returns true (1) if the current dictionary has a value for the given key. + /// + int(CEF_CALLBACK* has_key)(struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Reads all keys for this dictionary into the specified vector. + /// + int(CEF_CALLBACK* get_keys)(struct _cef_dictionary_value_t* self, + cef_string_list_t keys); + + /// + /// Removes the value at the specified key. Returns true (1) is the value was + /// removed successfully. + /// + int(CEF_CALLBACK* remove)(struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value type for the specified key. + /// + cef_value_type_t(CEF_CALLBACK* get_type)(struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value at the specified key. For simple types the returned + /// value will copy existing data and modifications to the value will not + /// modify this object. For complex types (binary, dictionary and list) the + /// returned value will reference existing data and modifications to the value + /// will modify this object. + /// + struct _cef_value_t*(CEF_CALLBACK* get_value)( + struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value at the specified key as type bool. + /// + int(CEF_CALLBACK* get_bool)(struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value at the specified key as type int. + /// + int(CEF_CALLBACK* get_int)(struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value at the specified key as type double. + /// + double(CEF_CALLBACK* get_double)(struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value at the specified key as type string. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_string)( + struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value at the specified key as type binary. The returned value + /// will reference existing data. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_binary)( + struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value at the specified key as type dictionary. The returned + /// value will reference existing data and modifications to the value will + /// modify this object. + /// + struct _cef_dictionary_value_t*(CEF_CALLBACK* get_dictionary)( + struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Returns the value at the specified key as type list. The returned value + /// will reference existing data and modifications to the value will modify + /// this object. + /// + struct _cef_list_value_t*(CEF_CALLBACK* get_list)( + struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Sets the value at the specified key. Returns true (1) if the value was set + /// successfully. If |value| represents simple data then the underlying data + /// will be copied and modifications to |value| will not modify this object. + /// If |value| represents complex data (binary, dictionary or list) then the + /// underlying data will be referenced and modifications to |value| will + /// modify this object. + /// + int(CEF_CALLBACK* set_value)(struct _cef_dictionary_value_t* self, + const cef_string_t* key, + struct _cef_value_t* value); + + /// + /// Sets the value at the specified key as type null. Returns true (1) if the + /// value was set successfully. + /// + int(CEF_CALLBACK* set_null)(struct _cef_dictionary_value_t* self, + const cef_string_t* key); + + /// + /// Sets the value at the specified key as type bool. Returns true (1) if the + /// value was set successfully. + /// + int(CEF_CALLBACK* set_bool)(struct _cef_dictionary_value_t* self, + const cef_string_t* key, + int value); + + /// + /// Sets the value at the specified key as type int. Returns true (1) if the + /// value was set successfully. + /// + int(CEF_CALLBACK* set_int)(struct _cef_dictionary_value_t* self, + const cef_string_t* key, + int value); + + /// + /// Sets the value at the specified key as type double. Returns true (1) if + /// the value was set successfully. + /// + int(CEF_CALLBACK* set_double)(struct _cef_dictionary_value_t* self, + const cef_string_t* key, + double value); + + /// + /// Sets the value at the specified key as type string. Returns true (1) if + /// the value was set successfully. + /// + int(CEF_CALLBACK* set_string)(struct _cef_dictionary_value_t* self, + const cef_string_t* key, + const cef_string_t* value); + + /// + /// Sets the value at the specified key as type binary. Returns true (1) if + /// the value was set successfully. If |value| is currently owned by another + /// object then the value will be copied and the |value| reference will not + /// change. Otherwise, ownership will be transferred to this object and the + /// |value| reference will be invalidated. + /// + int(CEF_CALLBACK* set_binary)(struct _cef_dictionary_value_t* self, + const cef_string_t* key, + struct _cef_binary_value_t* value); + + /// + /// Sets the value at the specified key as type dict. Returns true (1) if the + /// value was set successfully. If |value| is currently owned by another + /// object then the value will be copied and the |value| reference will not + /// change. Otherwise, ownership will be transferred to this object and the + /// |value| reference will be invalidated. + /// + int(CEF_CALLBACK* set_dictionary)(struct _cef_dictionary_value_t* self, + const cef_string_t* key, + struct _cef_dictionary_value_t* value); + + /// + /// Sets the value at the specified key as type list. Returns true (1) if the + /// value was set successfully. If |value| is currently owned by another + /// object then the value will be copied and the |value| reference will not + /// change. Otherwise, ownership will be transferred to this object and the + /// |value| reference will be invalidated. + /// + int(CEF_CALLBACK* set_list)(struct _cef_dictionary_value_t* self, + const cef_string_t* key, + struct _cef_list_value_t* value); +} cef_dictionary_value_t; + +/// +/// Creates a new object that is not owned by any other object. +/// +CEF_EXPORT cef_dictionary_value_t* cef_dictionary_value_create(void); + +/// +/// Structure representing a list value. Can be used on any process and thread. +/// +typedef struct _cef_list_value_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. This object may become invalid + /// if the underlying data is owned by another object (e.g. list or + /// dictionary) and that other object is then modified or destroyed. Do not + /// call any other functions if this function returns false (0). + /// + int(CEF_CALLBACK* is_valid)(struct _cef_list_value_t* self); + + /// + /// Returns true (1) if this object is currently owned by another object. + /// + int(CEF_CALLBACK* is_owned)(struct _cef_list_value_t* self); + + /// + /// Returns true (1) if the values of this object are read-only. Some APIs may + /// expose read-only objects. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_list_value_t* self); + + /// + /// Returns true (1) if this object and |that| object have the same underlying + /// data. If true (1) modifications to this object will also affect |that| + /// object and vice-versa. + /// + int(CEF_CALLBACK* is_same)(struct _cef_list_value_t* self, + struct _cef_list_value_t* that); + + /// + /// Returns true (1) if this object and |that| object have an equivalent + /// underlying value but are not necessarily the same object. + /// + int(CEF_CALLBACK* is_equal)(struct _cef_list_value_t* self, + struct _cef_list_value_t* that); + + /// + /// Returns a writable copy of this object. + /// + struct _cef_list_value_t*(CEF_CALLBACK* copy)(struct _cef_list_value_t* self); + + /// + /// Sets the number of values. If the number of values is expanded all new + /// value slots will default to type null. Returns true (1) on success. + /// + int(CEF_CALLBACK* set_size)(struct _cef_list_value_t* self, size_t size); + + /// + /// Returns the number of values. + /// + size_t(CEF_CALLBACK* get_size)(struct _cef_list_value_t* self); + + /// + /// Removes all values. Returns true (1) on success. + /// + int(CEF_CALLBACK* clear)(struct _cef_list_value_t* self); + + /// + /// Removes the value at the specified index. + /// + int(CEF_CALLBACK* remove)(struct _cef_list_value_t* self, size_t index); + + /// + /// Returns the value type at the specified index. + /// + cef_value_type_t(CEF_CALLBACK* get_type)(struct _cef_list_value_t* self, + size_t index); + + /// + /// Returns the value at the specified index. For simple types the returned + /// value will copy existing data and modifications to the value will not + /// modify this object. For complex types (binary, dictionary and list) the + /// returned value will reference existing data and modifications to the value + /// will modify this object. + /// + struct _cef_value_t*(CEF_CALLBACK* get_value)(struct _cef_list_value_t* self, + size_t index); + + /// + /// Returns the value at the specified index as type bool. + /// + int(CEF_CALLBACK* get_bool)(struct _cef_list_value_t* self, size_t index); + + /// + /// Returns the value at the specified index as type int. + /// + int(CEF_CALLBACK* get_int)(struct _cef_list_value_t* self, size_t index); + + /// + /// Returns the value at the specified index as type double. + /// + double(CEF_CALLBACK* get_double)(struct _cef_list_value_t* self, + size_t index); + + /// + /// Returns the value at the specified index as type string. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t( + CEF_CALLBACK* get_string)(struct _cef_list_value_t* self, size_t index); + + /// + /// Returns the value at the specified index as type binary. The returned + /// value will reference existing data. + /// + struct _cef_binary_value_t*( + CEF_CALLBACK* get_binary)(struct _cef_list_value_t* self, size_t index); + + /// + /// Returns the value at the specified index as type dictionary. The returned + /// value will reference existing data and modifications to the value will + /// modify this object. + /// + struct _cef_dictionary_value_t*(CEF_CALLBACK* get_dictionary)( + struct _cef_list_value_t* self, + size_t index); + + /// + /// Returns the value at the specified index as type list. The returned value + /// will reference existing data and modifications to the value will modify + /// this object. + /// + struct _cef_list_value_t*( + CEF_CALLBACK* get_list)(struct _cef_list_value_t* self, size_t index); + + /// + /// Sets the value at the specified index. Returns true (1) if the value was + /// set successfully. If |value| represents simple data then the underlying + /// data will be copied and modifications to |value| will not modify this + /// object. If |value| represents complex data (binary, dictionary or list) + /// then the underlying data will be referenced and modifications to |value| + /// will modify this object. + /// + int(CEF_CALLBACK* set_value)(struct _cef_list_value_t* self, + size_t index, + struct _cef_value_t* value); + + /// + /// Sets the value at the specified index as type null. Returns true (1) if + /// the value was set successfully. + /// + int(CEF_CALLBACK* set_null)(struct _cef_list_value_t* self, size_t index); + + /// + /// Sets the value at the specified index as type bool. Returns true (1) if + /// the value was set successfully. + /// + int(CEF_CALLBACK* set_bool)(struct _cef_list_value_t* self, + size_t index, + int value); + + /// + /// Sets the value at the specified index as type int. Returns true (1) if the + /// value was set successfully. + /// + int(CEF_CALLBACK* set_int)(struct _cef_list_value_t* self, + size_t index, + int value); + + /// + /// Sets the value at the specified index as type double. Returns true (1) if + /// the value was set successfully. + /// + int(CEF_CALLBACK* set_double)(struct _cef_list_value_t* self, + size_t index, + double value); + + /// + /// Sets the value at the specified index as type string. Returns true (1) if + /// the value was set successfully. + /// + int(CEF_CALLBACK* set_string)(struct _cef_list_value_t* self, + size_t index, + const cef_string_t* value); + + /// + /// Sets the value at the specified index as type binary. Returns true (1) if + /// the value was set successfully. If |value| is currently owned by another + /// object then the value will be copied and the |value| reference will not + /// change. Otherwise, ownership will be transferred to this object and the + /// |value| reference will be invalidated. + /// + int(CEF_CALLBACK* set_binary)(struct _cef_list_value_t* self, + size_t index, + struct _cef_binary_value_t* value); + + /// + /// Sets the value at the specified index as type dict. Returns true (1) if + /// the value was set successfully. If |value| is currently owned by another + /// object then the value will be copied and the |value| reference will not + /// change. Otherwise, ownership will be transferred to this object and the + /// |value| reference will be invalidated. + /// + int(CEF_CALLBACK* set_dictionary)(struct _cef_list_value_t* self, + size_t index, + struct _cef_dictionary_value_t* value); + + /// + /// Sets the value at the specified index as type list. Returns true (1) if + /// the value was set successfully. If |value| is currently owned by another + /// object then the value will be copied and the |value| reference will not + /// change. Otherwise, ownership will be transferred to this object and the + /// |value| reference will be invalidated. + /// + int(CEF_CALLBACK* set_list)(struct _cef_list_value_t* self, + size_t index, + struct _cef_list_value_t* value); +} cef_list_value_t; + +/// +/// Creates a new object that is not owned by any other object. +/// +CEF_EXPORT cef_list_value_t* cef_list_value_create(void); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_ diff --git a/include/capi/cef_waitable_event_capi.h b/include/capi/cef_waitable_event_capi.h new file mode 100644 index 00000000..1f5431c7 --- /dev/null +++ b/include/capi/cef_waitable_event_capi.h @@ -0,0 +1,117 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=683d592a2405ada0a9c46c004f003d640a3298ad$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// WaitableEvent is a thread synchronization tool that allows one thread to +/// wait for another thread to finish some work. This is equivalent to using a +/// Lock+ConditionVariable to protect a simple boolean value. However, using +/// WaitableEvent in conjunction with a Lock to wait for a more complex state +/// change (e.g., for an item to be added to a queue) is not recommended. In +/// that case consider using a ConditionVariable instead of a WaitableEvent. It +/// is safe to create and/or signal a WaitableEvent from any thread. Blocking on +/// a WaitableEvent by calling the *wait() functions is not allowed on the +/// browser process UI or IO threads. +/// +typedef struct _cef_waitable_event_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Put the event in the un-signaled state. + /// + void(CEF_CALLBACK* reset)(struct _cef_waitable_event_t* self); + + /// + /// Put the event in the signaled state. This causes any thread blocked on + /// Wait to be woken up. + /// + void(CEF_CALLBACK* signal)(struct _cef_waitable_event_t* self); + + /// + /// Returns true (1) if the event is in the signaled state, else false (0). If + /// the event was created with |automatic_reset| set to true (1) then calling + /// this function will also cause a reset. + /// + int(CEF_CALLBACK* is_signaled)(struct _cef_waitable_event_t* self); + + /// + /// Wait indefinitely for the event to be signaled. This function will not + /// return until after the call to signal() has completed. This function + /// cannot be called on the browser process UI or IO threads. + /// + void(CEF_CALLBACK* wait)(struct _cef_waitable_event_t* self); + + /// + /// Wait up to |max_ms| milliseconds for the event to be signaled. Returns + /// true (1) if the event was signaled. A return value of false (0) does not + /// necessarily mean that |max_ms| was exceeded. This function will not return + /// until after the call to signal() has completed. This function cannot be + /// called on the browser process UI or IO threads. + /// + int(CEF_CALLBACK* timed_wait)(struct _cef_waitable_event_t* self, + int64 max_ms); +} cef_waitable_event_t; + +/// +/// Create a new waitable event. If |automatic_reset| is true (1) then the event +/// state is automatically reset to un-signaled after a single waiting thread +/// has been released; otherwise, the state remains signaled until reset() is +/// called manually. If |initially_signaled| is true (1) then the event will +/// start in the signaled state. +/// +CEF_EXPORT cef_waitable_event_t* cef_waitable_event_create( + int automatic_reset, + int initially_signaled); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_ diff --git a/include/capi/cef_x509_certificate_capi.h b/include/capi/cef_x509_certificate_capi.h new file mode 100644 index 00000000..bfd4700f --- /dev/null +++ b/include/capi/cef_x509_certificate_capi.h @@ -0,0 +1,213 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=7a541729b4ac664b22cdea625f19f1dba1b6a685$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure representing the issuer or subject field of an X.509 certificate. +/// +typedef struct _cef_x509cert_principal_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns a name that can be used to represent the issuer. It tries in this + /// order: Common Name (CN), Organization Name (O) and Organizational Unit + /// Name (OU) and returns the first non-NULL one found. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_display_name)( + struct _cef_x509cert_principal_t* self); + + /// + /// Returns the common name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_common_name)( + struct _cef_x509cert_principal_t* self); + + /// + /// Returns the locality name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_locality_name)( + struct _cef_x509cert_principal_t* self); + + /// + /// Returns the state or province name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_state_or_province_name)( + struct _cef_x509cert_principal_t* self); + + /// + /// Returns the country name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_country_name)( + struct _cef_x509cert_principal_t* self); + + /// + /// Retrieve the list of street addresses. + /// + void(CEF_CALLBACK* get_street_addresses)( + struct _cef_x509cert_principal_t* self, + cef_string_list_t addresses); + + /// + /// Retrieve the list of organization names. + /// + void(CEF_CALLBACK* get_organization_names)( + struct _cef_x509cert_principal_t* self, + cef_string_list_t names); + + /// + /// Retrieve the list of organization unit names. + /// + void(CEF_CALLBACK* get_organization_unit_names)( + struct _cef_x509cert_principal_t* self, + cef_string_list_t names); + + /// + /// Retrieve the list of domain components. + /// + void(CEF_CALLBACK* get_domain_components)( + struct _cef_x509cert_principal_t* self, + cef_string_list_t components); +} cef_x509cert_principal_t; + +/// +/// Structure representing a X.509 certificate. +/// +typedef struct _cef_x509certificate_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the subject of the X.509 certificate. For HTTPS server + /// certificates this represents the web server. The common name of the + /// subject should match the host name of the web server. + /// + struct _cef_x509cert_principal_t*(CEF_CALLBACK* get_subject)( + struct _cef_x509certificate_t* self); + + /// + /// Returns the issuer of the X.509 certificate. + /// + struct _cef_x509cert_principal_t*(CEF_CALLBACK* get_issuer)( + struct _cef_x509certificate_t* self); + + /// + /// Returns the DER encoded serial number for the X.509 certificate. The value + /// possibly includes a leading 00 byte. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_serial_number)( + struct _cef_x509certificate_t* self); + + /// + /// Returns the date before which the X.509 certificate is invalid. + /// CefBaseTime.GetTimeT() will return 0 if no date was specified. + /// + cef_basetime_t(CEF_CALLBACK* get_valid_start)( + struct _cef_x509certificate_t* self); + + /// + /// Returns the date after which the X.509 certificate is invalid. + /// CefBaseTime.GetTimeT() will return 0 if no date was specified. + /// + cef_basetime_t(CEF_CALLBACK* get_valid_expiry)( + struct _cef_x509certificate_t* self); + + /// + /// Returns the DER encoded data for the X.509 certificate. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_derencoded)( + struct _cef_x509certificate_t* self); + + /// + /// Returns the PEM encoded data for the X.509 certificate. + /// + struct _cef_binary_value_t*(CEF_CALLBACK* get_pemencoded)( + struct _cef_x509certificate_t* self); + + /// + /// Returns the number of certificates in the issuer chain. If 0, the + /// certificate is self-signed. + /// + size_t(CEF_CALLBACK* get_issuer_chain_size)( + struct _cef_x509certificate_t* self); + + /// + /// Returns the DER encoded data for the certificate issuer chain. If we + /// failed to encode a certificate in the chain it is still present in the + /// array but is an NULL string. + /// + void(CEF_CALLBACK* get_derencoded_issuer_chain)( + struct _cef_x509certificate_t* self, + size_t* chainCount, + struct _cef_binary_value_t** chain); + + /// + /// Returns the PEM encoded data for the certificate issuer chain. If we + /// failed to encode a certificate in the chain it is still present in the + /// array but is an NULL string. + /// + void(CEF_CALLBACK* get_pemencoded_issuer_chain)( + struct _cef_x509certificate_t* self, + size_t* chainCount, + struct _cef_binary_value_t** chain); +} cef_x509certificate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_ diff --git a/include/capi/cef_xml_reader_capi.h b/include/capi/cef_xml_reader_capi.h new file mode 100644 index 00000000..3db9b94e --- /dev/null +++ b/include/capi/cef_xml_reader_capi.h @@ -0,0 +1,274 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=366f872b03f7c25ef56677cc427a317bb529ad9c$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_stream_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure that supports the reading of XML data via the libxml streaming +/// API. The functions of this structure should only be called on the thread +/// that creates the object. +/// +typedef struct _cef_xml_reader_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Moves the cursor to the next node in the document. This function must be + /// called at least once to set the current cursor position. Returns true (1) + /// if the cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_next_node)(struct _cef_xml_reader_t* self); + + /// + /// Close the document. This should be called directly to ensure that cleanup + /// occurs on the correct thread. + /// + int(CEF_CALLBACK* close)(struct _cef_xml_reader_t* self); + + /// + /// Returns true (1) if an error has been reported by the XML parser. + /// + int(CEF_CALLBACK* has_error)(struct _cef_xml_reader_t* self); + + /// + /// Returns the error string. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_error)( + struct _cef_xml_reader_t* self); + + /// + /// Returns the node type. + /// + cef_xml_node_type_t(CEF_CALLBACK* get_type)(struct _cef_xml_reader_t* self); + + /// + /// Returns the node depth. Depth starts at 0 for the root node. + /// + int(CEF_CALLBACK* get_depth)(struct _cef_xml_reader_t* self); + + /// + /// Returns the local name. See http://www.w3.org/TR/REC-xml-names/#NT- + /// LocalPart for additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_local_name)( + struct _cef_xml_reader_t* self); + + /// + /// Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for + /// additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_prefix)( + struct _cef_xml_reader_t* self); + + /// + /// Returns the qualified name, equal to (Prefix:)LocalName. See + /// http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_qualified_name)( + struct _cef_xml_reader_t* self); + + /// + /// Returns the URI defining the namespace associated with the node. See + /// http://www.w3.org/TR/REC-xml-names/ for additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_namespace_uri)( + struct _cef_xml_reader_t* self); + + /// + /// Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for + /// additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_base_uri)( + struct _cef_xml_reader_t* self); + + /// + /// Returns the xml:lang scope within which the node resides. See + /// http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_xml_lang)( + struct _cef_xml_reader_t* self); + + /// + /// Returns true (1) if the node represents an NULL element. "<a/>" is + /// considered NULL but "<a></a>" is not. + /// + int(CEF_CALLBACK* is_empty_element)(struct _cef_xml_reader_t* self); + + /// + /// Returns true (1) if the node has a text value. + /// + int(CEF_CALLBACK* has_value)(struct _cef_xml_reader_t* self); + + /// + /// Returns the text value. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_value)( + struct _cef_xml_reader_t* self); + + /// + /// Returns true (1) if the node has attributes. + /// + int(CEF_CALLBACK* has_attributes)(struct _cef_xml_reader_t* self); + + /// + /// Returns the number of attributes. + /// + size_t(CEF_CALLBACK* get_attribute_count)(struct _cef_xml_reader_t* self); + + /// + /// Returns the value of the attribute at the specified 0-based index. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_attribute_byindex)( + struct _cef_xml_reader_t* self, + int index); + + /// + /// Returns the value of the attribute with the specified qualified name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_attribute_byqname)( + struct _cef_xml_reader_t* self, + const cef_string_t* qualifiedName); + + /// + /// Returns the value of the attribute with the specified local name and + /// namespace URI. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_attribute_bylname)( + struct _cef_xml_reader_t* self, + const cef_string_t* localName, + const cef_string_t* namespaceURI); + + /// + /// Returns an XML representation of the current node's children. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_inner_xml)( + struct _cef_xml_reader_t* self); + + /// + /// Returns an XML representation of the current node including its children. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_outer_xml)( + struct _cef_xml_reader_t* self); + + /// + /// Returns the line number for the current node. + /// + int(CEF_CALLBACK* get_line_number)(struct _cef_xml_reader_t* self); + + /// + /// Moves the cursor to the attribute at the specified 0-based index. Returns + /// true (1) if the cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_attribute_byindex)(struct _cef_xml_reader_t* self, + int index); + + /// + /// Moves the cursor to the attribute with the specified qualified name. + /// Returns true (1) if the cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_attribute_byqname)( + struct _cef_xml_reader_t* self, + const cef_string_t* qualifiedName); + + /// + /// Moves the cursor to the attribute with the specified local name and + /// namespace URI. Returns true (1) if the cursor position was set + /// successfully. + /// + int(CEF_CALLBACK* move_to_attribute_bylname)( + struct _cef_xml_reader_t* self, + const cef_string_t* localName, + const cef_string_t* namespaceURI); + + /// + /// Moves the cursor to the first attribute in the current element. Returns + /// true (1) if the cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_first_attribute)(struct _cef_xml_reader_t* self); + + /// + /// Moves the cursor to the next attribute in the current element. Returns + /// true (1) if the cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_next_attribute)(struct _cef_xml_reader_t* self); + + /// + /// Moves the cursor back to the carrying element. Returns true (1) if the + /// cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_carrying_element)(struct _cef_xml_reader_t* self); +} cef_xml_reader_t; + +/// +/// Create a new cef_xml_reader_t object. The returned object's functions can +/// only be called from the thread that created the object. +/// +CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create( + struct _cef_stream_reader_t* stream, + cef_xml_encoding_type_t encodingType, + const cef_string_t* URI); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_ diff --git a/include/capi/cef_zip_reader_capi.h b/include/capi/cef_zip_reader_capi.h new file mode 100644 index 00000000..05c9cd2e --- /dev/null +++ b/include/capi/cef_zip_reader_capi.h @@ -0,0 +1,148 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=83debac545c04a630270665b391f52b15484b5d3$ +// + +#ifndef CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_stream_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Structure that supports the reading of zip archives via the zlib unzip API. +/// The functions of this structure should only be called on the thread that +/// creates the object. +/// +typedef struct _cef_zip_reader_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Moves the cursor to the first file in the archive. Returns true (1) if the + /// cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_first_file)(struct _cef_zip_reader_t* self); + + /// + /// Moves the cursor to the next file in the archive. Returns true (1) if the + /// cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_next_file)(struct _cef_zip_reader_t* self); + + /// + /// Moves the cursor to the specified file in the archive. If |caseSensitive| + /// is true (1) then the search will be case sensitive. Returns true (1) if + /// the cursor position was set successfully. + /// + int(CEF_CALLBACK* move_to_file)(struct _cef_zip_reader_t* self, + const cef_string_t* fileName, + int caseSensitive); + + /// + /// Closes the archive. This should be called directly to ensure that cleanup + /// occurs on the correct thread. + /// + int(CEF_CALLBACK* close)(struct _cef_zip_reader_t* self); + + /// + /// Returns the name of the file. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_file_name)( + struct _cef_zip_reader_t* self); + + /// + /// Returns the uncompressed size of the file. + /// + int64(CEF_CALLBACK* get_file_size)(struct _cef_zip_reader_t* self); + + /// + /// Returns the last modified timestamp for the file. + /// + cef_basetime_t(CEF_CALLBACK* get_file_last_modified)( + struct _cef_zip_reader_t* self); + + /// + /// Opens the file for reading of uncompressed data. A read password may + /// optionally be specified. + /// + int(CEF_CALLBACK* open_file)(struct _cef_zip_reader_t* self, + const cef_string_t* password); + + /// + /// Closes the file. + /// + int(CEF_CALLBACK* close_file)(struct _cef_zip_reader_t* self); + + /// + /// Read uncompressed file contents into the specified buffer. Returns < 0 if + /// an error occurred, 0 if at the end of file, or the number of bytes read. + /// + int(CEF_CALLBACK* read_file)(struct _cef_zip_reader_t* self, + void* buffer, + size_t bufferSize); + + /// + /// Returns the current offset in the uncompressed file contents. + /// + int64(CEF_CALLBACK* tell)(struct _cef_zip_reader_t* self); + + /// + /// Returns true (1) if at end of the file contents. + /// + int(CEF_CALLBACK* eof)(struct _cef_zip_reader_t* self); +} cef_zip_reader_t; + +/// +/// Create a new cef_zip_reader_t object. The returned object's functions can +/// only be called from the thread that created the object. +/// +CEF_EXPORT cef_zip_reader_t* cef_zip_reader_create( + struct _cef_stream_reader_t* stream); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_ diff --git a/include/capi/test/cef_test_helpers_capi.h b/include/capi/test/cef_test_helpers_capi.h new file mode 100644 index 00000000..c24bcf5a --- /dev/null +++ b/include/capi/test/cef_test_helpers_capi.h @@ -0,0 +1,74 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=4d10dad2278e6d61367b3deaf501a0e7b4fd60e9$ +// + +#ifndef CEF_INCLUDE_CAPI_TEST_CEF_TEST_HELPERS_CAPI_H_ +#define CEF_INCLUDE_CAPI_TEST_CEF_TEST_HELPERS_CAPI_H_ +#pragma once + +#if !defined(BUILDING_CEF_SHARED) && !defined(WRAPPING_CEF_SHARED) && \ + !defined(UNIT_TEST) +#error This file can be included for unit tests only +#endif + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Execute JavaScript with a user gesture to trigger functionality like +/// onbeforeunload handlers that will otherwise be blocked. +/// +CEF_EXPORT void cef_execute_java_script_with_user_gesture_for_tests( + struct _cef_frame_t* frame, + const cef_string_t* javascript); + +/// +/// Set the DIR_SRC_TEST_DATA_ROOT directory used to load test data. Must be +/// configured when running from a CEF binary distribution. Defaults to the +/// "chromium/src" directory when running from a local CEF/Chromium build. |dir| +/// must be an absolute path. +/// +CEF_EXPORT void cef_set_data_directory_for_tests(const cef_string_t* dir); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_TEST_CEF_TEST_HELPERS_CAPI_H_ diff --git a/include/capi/test/cef_test_server_capi.h b/include/capi/test/cef_test_server_capi.h new file mode 100644 index 00000000..ba30e684 --- /dev/null +++ b/include/capi/test/cef_test_server_capi.h @@ -0,0 +1,197 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=df532eb91caf9de44b077abdf00620dd2508402b$ +// + +#ifndef CEF_INCLUDE_CAPI_TEST_CEF_TEST_SERVER_CAPI_H_ +#define CEF_INCLUDE_CAPI_TEST_CEF_TEST_SERVER_CAPI_H_ +#pragma once + +#if !defined(BUILDING_CEF_SHARED) && !defined(WRAPPING_CEF_SHARED) && \ + !defined(UNIT_TEST) +#error This file can be included for unit tests only +#endif + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_request_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_test_server_connection_t; +struct _cef_test_server_handler_t; + +/// +/// Structure representing an embedded test server that supports HTTP/HTTPS +/// requests. This is a basic server providing only an essential subset of the +/// HTTP/1.1 protocol. Especially, it assumes that the request syntax is +/// correct. It *does not* support a Chunked Transfer Encoding. Server capacity +/// is limited and is intended to handle only a small number of simultaneous +/// connections (e.g. for communicating between applications on localhost). The +/// functions of this structure are safe to call from any thread in the brower +/// process unless otherwise indicated. +/// +typedef struct _cef_test_server_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Stop the server and shut down the dedicated server thread. This function + /// must be called on the same thread as CreateAndStart. It will block until + /// the dedicated server thread has shut down. + /// + void(CEF_CALLBACK* stop)(struct _cef_test_server_t* self); + + /// + /// Returns the server origin including the port number (e.g. + /// "[http|https]://127.0.0.1:<port>". + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_origin)( + struct _cef_test_server_t* self); +} cef_test_server_t; + +/// +/// Create and start a new test server that binds to |port|. If |port| is 0 an +/// available port number will be selected. If |https_server| is true (1) the +/// server will be HTTPS, otherwise it will be HTTP. When |https_server| is true +/// (1) the |https_cert_type| value is used to configure the certificate type. +/// Returns the newly created server object on success, or nullptr if the server +/// cannot be started. +/// +/// A new thread will be created for each CreateAndStart call (the "dedicated +/// server thread"). It is therefore recommended to use a different +/// cef_test_server_handler_t instance for each CreateAndStart call to avoid +/// thread safety issues in the cef_test_server_handler_t implementation. +/// +/// On success, this function will block until the dedicated server thread has +/// started. The server will continue running until Stop is called. +/// +CEF_EXPORT cef_test_server_t* cef_test_server_create_and_start( + uint16 port, + int https_server, + cef_test_cert_type_t https_cert_type, + struct _cef_test_server_handler_t* handler); + +/// +/// Implement this structure to handle test server requests. A new thread will +/// be created for each cef_test_server_t::CreateAndStart call (the "dedicated +/// server thread"), and the functions of this structure will be called on that +/// thread. See related documentation on cef_test_server_t::CreateAndStart. +/// +typedef struct _cef_test_server_handler_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Called when |server| receives a request. To handle the request return true + /// (1) and use |connection| to send the response either synchronously or + /// asynchronously. Otherwise, return false (0) if the request is unhandled. + /// When returning false (0) do not call any |connection| functions. + /// + int(CEF_CALLBACK* on_test_server_request)( + struct _cef_test_server_handler_t* self, + struct _cef_test_server_t* server, + struct _cef_request_t* request, + struct _cef_test_server_connection_t* connection); +} cef_test_server_handler_t; + +/// +/// Structure representing a test server connection. The functions of this +/// structure are safe to call from any thread in the brower process unless +/// otherwise indicated. +/// +typedef struct _cef_test_server_connection_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Send an HTTP 200 "OK" response. |content_type| is the response content + /// type (e.g. "text/html"). |data| is the response content and |data_size| is + /// the size of |data| in bytes. The contents of |data| will be copied. The + /// connection will be closed automatically after the response is sent. + /// + void(CEF_CALLBACK* send_http200response)( + struct _cef_test_server_connection_t* self, + const cef_string_t* content_type, + const void* data, + size_t data_size); + + /// + /// Send an HTTP 404 "Not Found" response. The connection will be closed + /// automatically after the response is sent. + /// + void(CEF_CALLBACK* send_http404response)( + struct _cef_test_server_connection_t* self); + + /// + /// Send an HTTP 500 "Internal Server Error" response. |error_message| is the + /// associated error message. The connection will be closed automatically + /// after the response is sent. + /// + void(CEF_CALLBACK* send_http500response)( + struct _cef_test_server_connection_t* self, + const cef_string_t* error_message); + + /// + /// Send a custom HTTP response. |response_code| is the HTTP response code + /// sent in the status line (e.g. 200). |content_type| is the response content + /// type (e.g. "text/html"). |data| is the response content and |data_size| is + /// the size of |data| in bytes. The contents of |data| will be copied. + /// |extra_headers| is an optional map of additional header key/value pairs. + /// The connection will be closed automatically after the response is sent. + /// + void(CEF_CALLBACK* send_http_response)( + struct _cef_test_server_connection_t* self, + int response_code, + const cef_string_t* content_type, + const void* data, + size_t data_size, + cef_string_multimap_t extra_headers); +} cef_test_server_connection_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_TEST_CEF_TEST_SERVER_CAPI_H_ diff --git a/include/capi/test/cef_translator_test_capi.h b/include/capi/test/cef_translator_test_capi.h new file mode 100644 index 00000000..b1e87b05 --- /dev/null +++ b/include/capi/test/cef_translator_test_capi.h @@ -0,0 +1,763 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=58809bc0a16010773cf11b5165e65b32ec4b4793$ +// + +#ifndef CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_ +#define CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_ +#pragma once + +#if !defined(BUILDING_CEF_SHARED) && !defined(WRAPPING_CEF_SHARED) && \ + !defined(UNIT_TEST) +#error This file can be included for unit tests only +#endif + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_translator_test_ref_ptr_client_child_t; +struct _cef_translator_test_ref_ptr_client_t; +struct _cef_translator_test_ref_ptr_library_child_t; +struct _cef_translator_test_ref_ptr_library_t; +struct _cef_translator_test_scoped_client_child_t; +struct _cef_translator_test_scoped_client_t; +struct _cef_translator_test_scoped_library_child_t; +struct _cef_translator_test_scoped_library_t; + +/// +/// Structure for testing all of the possible data transfer types. +/// +typedef struct _cef_translator_test_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Return a void value. + /// + void(CEF_CALLBACK* get_void)(struct _cef_translator_test_t* self); + + /// + /// Return a bool value. + /// + int(CEF_CALLBACK* get_bool)(struct _cef_translator_test_t* self); + + /// + /// Return an int value. + /// + int(CEF_CALLBACK* get_int)(struct _cef_translator_test_t* self); + + /// + /// Return a double value. + /// + double(CEF_CALLBACK* get_double)(struct _cef_translator_test_t* self); + + /// + /// Return a long value. + /// + long(CEF_CALLBACK* get_long)(struct _cef_translator_test_t* self); + + /// + /// Return a size_t value. + /// + size_t(CEF_CALLBACK* get_sizet)(struct _cef_translator_test_t* self); + + /// + /// Set a void value. + /// + int(CEF_CALLBACK* set_void)(struct _cef_translator_test_t* self); + + /// + /// Set a bool value. + /// + int(CEF_CALLBACK* set_bool)(struct _cef_translator_test_t* self, int val); + + /// + /// Set an int value. + /// + int(CEF_CALLBACK* set_int)(struct _cef_translator_test_t* self, int val); + + /// + /// Set a double value. + /// + int(CEF_CALLBACK* set_double)(struct _cef_translator_test_t* self, + double val); + + /// + /// Set a long value. + /// + int(CEF_CALLBACK* set_long)(struct _cef_translator_test_t* self, long val); + + /// + /// Set a size_t value. + /// + int(CEF_CALLBACK* set_sizet)(struct _cef_translator_test_t* self, size_t val); + + /// + /// Set a int list value. + /// + int(CEF_CALLBACK* set_int_list)(struct _cef_translator_test_t* self, + size_t valCount, + int const* val); + + /// + /// Return an int list value by out-param. + /// + int(CEF_CALLBACK* get_int_list_by_ref)(struct _cef_translator_test_t* self, + size_t* valCount, + int* val); + + /// + /// Return the number of points that will be output above. + /// + size_t(CEF_CALLBACK* get_int_list_size)(struct _cef_translator_test_t* self); + + /// + /// Return a string value. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_string)( + struct _cef_translator_test_t* self); + + /// + /// Set a string value. + /// + int(CEF_CALLBACK* set_string)(struct _cef_translator_test_t* self, + const cef_string_t* val); + + /// + /// Return a string value by out-param. + /// + void(CEF_CALLBACK* get_string_by_ref)(struct _cef_translator_test_t* self, + cef_string_t* val); + + /// + /// Set a string list value. + /// + int(CEF_CALLBACK* set_string_list)(struct _cef_translator_test_t* self, + cef_string_list_t val); + + /// + /// Return a string list value by out-param. + /// + int(CEF_CALLBACK* get_string_list_by_ref)(struct _cef_translator_test_t* self, + cef_string_list_t val); + + /// + /// Set a string map value. + /// + int(CEF_CALLBACK* set_string_map)(struct _cef_translator_test_t* self, + cef_string_map_t val); + + /// + /// Return a string map value by out-param. + /// + int(CEF_CALLBACK* get_string_map_by_ref)(struct _cef_translator_test_t* self, + cef_string_map_t val); + + /// + /// Set a string multimap value. + /// + int(CEF_CALLBACK* set_string_multimap)(struct _cef_translator_test_t* self, + cef_string_multimap_t val); + + /// + /// Return a string multimap value by out-param. + /// + int(CEF_CALLBACK* get_string_multimap_by_ref)( + struct _cef_translator_test_t* self, + cef_string_multimap_t val); + + /// + /// Return a point value. + /// + cef_point_t(CEF_CALLBACK* get_point)(struct _cef_translator_test_t* self); + + /// + /// Set a point value. + /// + int(CEF_CALLBACK* set_point)(struct _cef_translator_test_t* self, + const cef_point_t* val); + + /// + /// Return a point value by out-param. + /// + void(CEF_CALLBACK* get_point_by_ref)(struct _cef_translator_test_t* self, + cef_point_t* val); + + /// + /// Set a point list vlaue. + /// + int(CEF_CALLBACK* set_point_list)(struct _cef_translator_test_t* self, + size_t valCount, + cef_point_t const* val); + + /// + /// Return a point list value by out-param. + /// + int(CEF_CALLBACK* get_point_list_by_ref)(struct _cef_translator_test_t* self, + size_t* valCount, + cef_point_t* val); + + /// + /// Return the number of points that will be output above. + /// + size_t(CEF_CALLBACK* get_point_list_size)( + struct _cef_translator_test_t* self); + + /// + /// Return an new library-side object. + /// + struct _cef_translator_test_ref_ptr_library_t*( + CEF_CALLBACK* get_ref_ptr_library)(struct _cef_translator_test_t* self, + int val); + + /// + /// Set an object. Returns the value from + /// cef_translator_test_ref_ptr_library_t::get_value(). This tests input and + /// execution of a library-side object type. + /// + int(CEF_CALLBACK* set_ref_ptr_library)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_ref_ptr_library_t* val); + + /// + /// Set an object. Returns the object passed in. This tests input and output + /// of a library-side object type. + /// + struct _cef_translator_test_ref_ptr_library_t*( + CEF_CALLBACK* set_ref_ptr_library_and_return)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_ref_ptr_library_t* val); + + /// + /// Set a child object. Returns the value from + /// cef_translator_test_ref_ptr_library_t::get_value(). This tests input of a + /// library- side child object type and execution as the parent type. + /// + int(CEF_CALLBACK* set_child_ref_ptr_library)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_ref_ptr_library_child_t* val); + + /// + /// Set a child object. Returns the object as the parent type. This tests + /// input of a library-side child object type and return as the parent type. + /// + struct _cef_translator_test_ref_ptr_library_t*( + CEF_CALLBACK* set_child_ref_ptr_library_and_return_parent)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_ref_ptr_library_child_t* val); + + /// + /// Set an object list vlaue. + /// + int(CEF_CALLBACK* set_ref_ptr_library_list)( + struct _cef_translator_test_t* self, + size_t valCount, + struct _cef_translator_test_ref_ptr_library_t* const* val, + int val1, + int val2); + + /// + /// Return an object list value by out-param. + /// + int(CEF_CALLBACK* get_ref_ptr_library_list_by_ref)( + struct _cef_translator_test_t* self, + size_t* valCount, + struct _cef_translator_test_ref_ptr_library_t** val, + int val1, + int val2); + + /// + /// Return the number of object that will be output above. + /// + size_t(CEF_CALLBACK* get_ref_ptr_library_list_size)( + struct _cef_translator_test_t* self); + + /// + /// Set an object. Returns the value from + /// cef_translator_test_ref_ptr_client_t::get_value(). This tests input and + /// execution of a client-side object type. + /// + int(CEF_CALLBACK* set_ref_ptr_client)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_ref_ptr_client_t* val); + + /// + /// Set an object. Returns the handler passed in. This tests input and output + /// of a client-side object type. + /// + struct _cef_translator_test_ref_ptr_client_t*( + CEF_CALLBACK* set_ref_ptr_client_and_return)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_ref_ptr_client_t* val); + + /// + /// Set a child object. Returns the value from + /// cef_translator_test_ref_ptr_client_t::get_value(). This tests input of a + /// client- side child object type and execution as the parent type. + /// + int(CEF_CALLBACK* set_child_ref_ptr_client)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_ref_ptr_client_child_t* val); + + /// + /// Set a child object. Returns the object as the parent type. This tests + /// input of a client-side child object type and return as the parent type. + /// + struct _cef_translator_test_ref_ptr_client_t*( + CEF_CALLBACK* set_child_ref_ptr_client_and_return_parent)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_ref_ptr_client_child_t* val); + + /// + /// Set an object list vlaue. + /// + int(CEF_CALLBACK* set_ref_ptr_client_list)( + struct _cef_translator_test_t* self, + size_t valCount, + struct _cef_translator_test_ref_ptr_client_t* const* val, + int val1, + int val2); + + /// + /// Return an object list value by out-param. + /// + int(CEF_CALLBACK* get_ref_ptr_client_list_by_ref)( + struct _cef_translator_test_t* self, + size_t* valCount, + struct _cef_translator_test_ref_ptr_client_t** val, + struct _cef_translator_test_ref_ptr_client_t* val1, + struct _cef_translator_test_ref_ptr_client_t* val2); + + /// + /// Return the number of object that will be output above. + /// + size_t(CEF_CALLBACK* get_ref_ptr_client_list_size)( + struct _cef_translator_test_t* self); + + /// + /// Return an new library-side object. + /// + struct _cef_translator_test_scoped_library_t*( + CEF_CALLBACK* get_own_ptr_library)(struct _cef_translator_test_t* self, + int val); + + /// + /// Set an object. Returns the value from + /// cef_translator_test_scoped_library_t::get_value(). This tests input and + /// execution of a library-side object type. + /// + int(CEF_CALLBACK* set_own_ptr_library)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_library_t* val); + + /// + /// Set an object. Returns the object passed in. This tests input and output + /// of a library-side object type. + /// + struct _cef_translator_test_scoped_library_t*( + CEF_CALLBACK* set_own_ptr_library_and_return)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_library_t* val); + + /// + /// Set a child object. Returns the value from + /// cef_translator_test_scoped_library_t::get_value(). This tests input of a + /// library- side child object type and execution as the parent type. + /// + int(CEF_CALLBACK* set_child_own_ptr_library)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_library_child_t* val); + + /// + /// Set a child object. Returns the object as the parent type. This tests + /// input of a library-side child object type and return as the parent type. + /// + struct _cef_translator_test_scoped_library_t*( + CEF_CALLBACK* set_child_own_ptr_library_and_return_parent)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_library_child_t* val); + + /// + /// Set an object. Returns the value from + /// cef_translator_test_scoped_client_t::get_value(). This tests input and + /// execution of a client-side object type. + /// + int(CEF_CALLBACK* set_own_ptr_client)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_client_t* val); + + /// + /// Set an object. Returns the handler passed in. This tests input and output + /// of a client-side object type. + /// + struct _cef_translator_test_scoped_client_t*( + CEF_CALLBACK* set_own_ptr_client_and_return)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_client_t* val); + + /// + /// Set a child object. Returns the value from + /// cef_translator_test_scoped_client_t::get_value(). This tests input of a + /// client- side child object type and execution as the parent type. + /// + int(CEF_CALLBACK* set_child_own_ptr_client)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_client_child_t* val); + + /// + /// Set a child object. Returns the object as the parent type. This tests + /// input of a client-side child object type and return as the parent type. + /// + struct _cef_translator_test_scoped_client_t*( + CEF_CALLBACK* set_child_own_ptr_client_and_return_parent)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_client_child_t* val); + + /// + /// Set an object. Returns the value from + /// cef_translator_test_scoped_library_t::get_value(). This tests input and + /// execution of a library-side object type. + /// + int(CEF_CALLBACK* set_raw_ptr_library)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_library_t* val); + + /// + /// Set a child object. Returns the value from + /// cef_translator_test_scoped_library_t::get_value(). This tests input of a + /// library- side child object type and execution as the parent type. + /// + int(CEF_CALLBACK* set_child_raw_ptr_library)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_library_child_t* val); + + /// + /// Set an object list vlaue. + /// + int(CEF_CALLBACK* set_raw_ptr_library_list)( + struct _cef_translator_test_t* self, + size_t valCount, + struct _cef_translator_test_scoped_library_t* const* val, + int val1, + int val2); + + /// + /// Set an object. Returns the value from + /// cef_translator_test_scoped_client_t::get_value(). This tests input and + /// execution of a client-side object type. + /// + int(CEF_CALLBACK* set_raw_ptr_client)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_client_t* val); + + /// + /// Set a child object. Returns the value from + /// cef_translator_test_scoped_client_t::get_value(). This tests input of a + /// client- side child object type and execution as the parent type. + /// + int(CEF_CALLBACK* set_child_raw_ptr_client)( + struct _cef_translator_test_t* self, + struct _cef_translator_test_scoped_client_child_t* val); + + /// + /// Set an object list vlaue. + /// + int(CEF_CALLBACK* set_raw_ptr_client_list)( + struct _cef_translator_test_t* self, + size_t valCount, + struct _cef_translator_test_scoped_client_t* const* val, + int val1, + int val2); +} cef_translator_test_t; + +/// +/// Create the test object. +/// +CEF_EXPORT cef_translator_test_t* cef_translator_test_create(void); + +/// +/// Library-side test object for RefPtr. +/// +typedef struct _cef_translator_test_ref_ptr_library_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_value)( + struct _cef_translator_test_ref_ptr_library_t* self); + + /// + /// Set a value. + /// + void(CEF_CALLBACK* set_value)( + struct _cef_translator_test_ref_ptr_library_t* self, + int value); +} cef_translator_test_ref_ptr_library_t; + +/// +/// Create the test object. +/// +CEF_EXPORT cef_translator_test_ref_ptr_library_t* +cef_translator_test_ref_ptr_library_create(int value); + +/// +/// Library-side child test object for RefPtr. +/// +typedef struct _cef_translator_test_ref_ptr_library_child_t { + /// + /// Base structure. + /// + cef_translator_test_ref_ptr_library_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_other_value)( + struct _cef_translator_test_ref_ptr_library_child_t* self); + + /// + /// Set a value. + /// + void(CEF_CALLBACK* set_other_value)( + struct _cef_translator_test_ref_ptr_library_child_t* self, + int value); +} cef_translator_test_ref_ptr_library_child_t; + +/// +/// Create the test object. +/// +CEF_EXPORT cef_translator_test_ref_ptr_library_child_t* +cef_translator_test_ref_ptr_library_child_create(int value, int other_value); + +/// +/// Another library-side child test object for RefPtr. +/// +typedef struct _cef_translator_test_ref_ptr_library_child_child_t { + /// + /// Base structure. + /// + cef_translator_test_ref_ptr_library_child_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_other_other_value)( + struct _cef_translator_test_ref_ptr_library_child_child_t* self); + + /// + /// Set a value. + /// + void(CEF_CALLBACK* set_other_other_value)( + struct _cef_translator_test_ref_ptr_library_child_child_t* self, + int value); +} cef_translator_test_ref_ptr_library_child_child_t; + +/// +/// Create the test object. +/// +CEF_EXPORT cef_translator_test_ref_ptr_library_child_child_t* +cef_translator_test_ref_ptr_library_child_child_create(int value, + int other_value, + int other_other_value); + +/// +/// Client-side test object for RefPtr. +/// +typedef struct _cef_translator_test_ref_ptr_client_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_value)( + struct _cef_translator_test_ref_ptr_client_t* self); +} cef_translator_test_ref_ptr_client_t; + +/// +/// Client-side child test object for RefPtr. +/// +typedef struct _cef_translator_test_ref_ptr_client_child_t { + /// + /// Base structure. + /// + cef_translator_test_ref_ptr_client_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_other_value)( + struct _cef_translator_test_ref_ptr_client_child_t* self); +} cef_translator_test_ref_ptr_client_child_t; + +/// +/// Library-side test object for OwnPtr/RawPtr. +/// +typedef struct _cef_translator_test_scoped_library_t { + /// + /// Base structure. + /// + cef_base_scoped_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_value)( + struct _cef_translator_test_scoped_library_t* self); + + /// + /// Set a value. + /// + void(CEF_CALLBACK* set_value)( + struct _cef_translator_test_scoped_library_t* self, + int value); +} cef_translator_test_scoped_library_t; + +/// +/// Create the test object. +/// +CEF_EXPORT cef_translator_test_scoped_library_t* +cef_translator_test_scoped_library_create(int value); + +/// +/// Library-side child test object for OwnPtr/RawPtr. +/// +typedef struct _cef_translator_test_scoped_library_child_t { + /// + /// Base structure. + /// + cef_translator_test_scoped_library_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_other_value)( + struct _cef_translator_test_scoped_library_child_t* self); + + /// + /// Set a value. + /// + void(CEF_CALLBACK* set_other_value)( + struct _cef_translator_test_scoped_library_child_t* self, + int value); +} cef_translator_test_scoped_library_child_t; + +/// +/// Create the test object. +/// +CEF_EXPORT cef_translator_test_scoped_library_child_t* +cef_translator_test_scoped_library_child_create(int value, int other_value); + +/// +/// Another library-side child test object for OwnPtr/RawPtr. +/// +typedef struct _cef_translator_test_scoped_library_child_child_t { + /// + /// Base structure. + /// + cef_translator_test_scoped_library_child_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_other_other_value)( + struct _cef_translator_test_scoped_library_child_child_t* self); + + /// + /// Set a value. + /// + void(CEF_CALLBACK* set_other_other_value)( + struct _cef_translator_test_scoped_library_child_child_t* self, + int value); +} cef_translator_test_scoped_library_child_child_t; + +/// +/// Create the test object. +/// +CEF_EXPORT cef_translator_test_scoped_library_child_child_t* +cef_translator_test_scoped_library_child_child_create(int value, + int other_value, + int other_other_value); + +/// +/// Client-side test object for OwnPtr/RawPtr. +/// +typedef struct _cef_translator_test_scoped_client_t { + /// + /// Base structure. + /// + cef_base_scoped_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_value)( + struct _cef_translator_test_scoped_client_t* self); +} cef_translator_test_scoped_client_t; + +/// +/// Client-side child test object for OwnPtr/RawPtr. +/// +typedef struct _cef_translator_test_scoped_client_child_t { + /// + /// Base structure. + /// + cef_translator_test_scoped_client_t base; + + /// + /// Return a value. + /// + int(CEF_CALLBACK* get_other_value)( + struct _cef_translator_test_scoped_client_child_t* self); +} cef_translator_test_scoped_client_child_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_ diff --git a/include/capi/views/cef_box_layout_capi.h b/include/capi/views/cef_box_layout_capi.h new file mode 100644 index 00000000..f053f017 --- /dev/null +++ b/include/capi/views/cef_box_layout_capi.h @@ -0,0 +1,88 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=31153d0702b646d310e74f04e256c0f5915b8caa$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BOX_LAYOUT_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_BOX_LAYOUT_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_layout_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_view_t; + +/// +/// A Layout manager that arranges child views vertically or horizontally in a +/// side-by-side fashion with spacing around and between the child views. The +/// child views are always sized according to their preferred size. If the +/// host's bounds provide insufficient space, child views will be clamped. +/// Excess space will not be distributed. Methods must be called on the browser +/// process UI thread unless otherwise indicated. +/// +typedef struct _cef_box_layout_t { + /// + /// Base structure. + /// + cef_layout_t base; + + /// + /// Set the flex weight for the given |view|. Using the preferred size as the + /// basis, free space along the main axis is distributed to views in the ratio + /// of their flex weights. Similarly, if the views will overflow the parent, + /// space is subtracted in these ratios. A flex of 0 means this view is not + /// resized. Flex values must not be negative. + /// + void(CEF_CALLBACK* set_flex_for_view)(struct _cef_box_layout_t* self, + struct _cef_view_t* view, + int flex); + + /// + /// Clears the flex for the given |view|, causing it to use the default flex + /// specified via cef_box_layout_tSettings.default_flex. + /// + void(CEF_CALLBACK* clear_flex_for_view)(struct _cef_box_layout_t* self, + struct _cef_view_t* view); +} cef_box_layout_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_BOX_LAYOUT_CAPI_H_ diff --git a/include/capi/views/cef_browser_view_capi.h b/include/capi/views/cef_browser_view_capi.h new file mode 100644 index 00000000..1e190bf7 --- /dev/null +++ b/include/capi/views/cef_browser_view_capi.h @@ -0,0 +1,117 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=f72e94f6bd63b6ea623c4d3170b5ad4333c136d6$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_CAPI_H_ +#pragma once + +#include "include/capi/cef_browser_capi.h" +#include "include/capi/views/cef_browser_view_delegate_capi.h" +#include "include/capi/views/cef_view_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// A View hosting a cef_browser_t instance. Methods must be called on the +/// browser process UI thread unless otherwise indicated. +/// +typedef struct _cef_browser_view_t { + /// + /// Base structure. + /// + cef_view_t base; + + /// + /// Returns the cef_browser_t hosted by this BrowserView. Will return NULL if + /// the browser has not yet been created or has already been destroyed. + /// + struct _cef_browser_t*(CEF_CALLBACK* get_browser)( + struct _cef_browser_view_t* self); + + /// + /// Returns the Chrome toolbar associated with this BrowserView. Only + /// supported when using the Chrome runtime. The cef_browser_view_delegate_t:: + /// get_chrome_toolbar_type() function must return a value other than + /// CEF_CTT_NONE and the toolbar will not be available until after this + /// BrowserView is added to a cef_window_t and + /// cef_view_delegate_t::on_window_changed() has been called. + /// + struct _cef_view_t*(CEF_CALLBACK* get_chrome_toolbar)( + struct _cef_browser_view_t* self); + + /// + /// Sets whether accelerators registered with cef_window_t::SetAccelerator are + /// triggered before or after the event is sent to the cef_browser_t. If + /// |prefer_accelerators| is true (1) then the matching accelerator will be + /// triggered immediately and the event will not be sent to the cef_browser_t. + /// If |prefer_accelerators| is false (0) then the matching accelerator will + /// only be triggered if the event is not handled by web content or by + /// cef_keyboard_handler_t. The default value is false (0). + /// + void(CEF_CALLBACK* set_prefer_accelerators)(struct _cef_browser_view_t* self, + int prefer_accelerators); +} cef_browser_view_t; + +/// +/// Create a new BrowserView. The underlying cef_browser_t will not be created +/// until this view is added to the views hierarchy. The optional |extra_info| +/// parameter provides an opportunity to specify extra information specific to +/// the created browser that will be passed to +/// cef_render_process_handler_t::on_browser_created() in the render process. +/// +CEF_EXPORT cef_browser_view_t* cef_browser_view_create( + struct _cef_client_t* client, + const cef_string_t* url, + const struct _cef_browser_settings_t* settings, + struct _cef_dictionary_value_t* extra_info, + struct _cef_request_context_t* request_context, + struct _cef_browser_view_delegate_t* delegate); + +/// +/// Returns the BrowserView associated with |browser|. +/// +CEF_EXPORT cef_browser_view_t* cef_browser_view_get_for_browser( + struct _cef_browser_t* browser); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_CAPI_H_ diff --git a/include/capi/views/cef_browser_view_delegate_capi.h b/include/capi/views/cef_browser_view_delegate_capi.h new file mode 100644 index 00000000..25fc074f --- /dev/null +++ b/include/capi/views/cef_browser_view_delegate_capi.h @@ -0,0 +1,129 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=e38c41a553d518abcd1b912d32281e99b93c4fd7$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_DELEGATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_DELEGATE_CAPI_H_ +#pragma once + +#include "include/capi/cef_client_capi.h" +#include "include/capi/views/cef_view_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_browser_t; +struct _cef_browser_view_t; + +/// +/// Implement this structure to handle BrowserView events. The functions of this +/// structure will be called on the browser process UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_browser_view_delegate_t { + /// + /// Base structure. + /// + cef_view_delegate_t base; + + /// + /// Called when |browser| associated with |browser_view| is created. This + /// function will be called after cef_life_span_handler_t::on_after_created() + /// is called for |browser| and before on_popup_browser_view_created() is + /// called for |browser|'s parent delegate if |browser| is a popup. + /// + void(CEF_CALLBACK* on_browser_created)( + struct _cef_browser_view_delegate_t* self, + struct _cef_browser_view_t* browser_view, + struct _cef_browser_t* browser); + + /// + /// Called when |browser| associated with |browser_view| is destroyed. Release + /// all references to |browser| and do not attempt to execute any functions on + /// |browser| after this callback returns. This function will be called before + /// cef_life_span_handler_t::on_before_close() is called for |browser|. + /// + void(CEF_CALLBACK* on_browser_destroyed)( + struct _cef_browser_view_delegate_t* self, + struct _cef_browser_view_t* browser_view, + struct _cef_browser_t* browser); + + /// + /// Called before a new popup BrowserView is created. The popup originated + /// from |browser_view|. |settings| and |client| are the values returned from + /// cef_life_span_handler_t::on_before_popup(). |is_devtools| will be true (1) + /// if the popup will be a DevTools browser. Return the delegate that will be + /// used for the new popup BrowserView. + /// + struct _cef_browser_view_delegate_t*( + CEF_CALLBACK* get_delegate_for_popup_browser_view)( + struct _cef_browser_view_delegate_t* self, + struct _cef_browser_view_t* browser_view, + const struct _cef_browser_settings_t* settings, + struct _cef_client_t* client, + int is_devtools); + + /// + /// Called after |popup_browser_view| is created. This function will be called + /// after cef_life_span_handler_t::on_after_created() and on_browser_created() + /// are called for the new popup browser. The popup originated from + /// |browser_view|. |is_devtools| will be true (1) if the popup is a DevTools + /// browser. Optionally add |popup_browser_view| to the views hierarchy + /// yourself and return true (1). Otherwise return false (0) and a default + /// cef_window_t will be created for the popup. + /// + int(CEF_CALLBACK* on_popup_browser_view_created)( + struct _cef_browser_view_delegate_t* self, + struct _cef_browser_view_t* browser_view, + struct _cef_browser_view_t* popup_browser_view, + int is_devtools); + + /// + /// Returns the Chrome toolbar type that will be available via + /// cef_browser_view_t::get_chrome_toolbar(). See that function for related + /// documentation. + /// + cef_chrome_toolbar_type_t(CEF_CALLBACK* get_chrome_toolbar_type)( + struct _cef_browser_view_delegate_t* self); +} cef_browser_view_delegate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_DELEGATE_CAPI_H_ diff --git a/include/capi/views/cef_button_capi.h b/include/capi/views/cef_button_capi.h new file mode 100644 index 00000000..e4fa6815 --- /dev/null +++ b/include/capi/views/cef_button_capi.h @@ -0,0 +1,104 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=6580dc6ef6c20d5d78dc0160982b9ef57c939f86$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_view_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_label_button_t; + +/// +/// A View representing a button. Depending on the specific type, the button +/// could be implemented by a native control or custom rendered. Methods must be +/// called on the browser process UI thread unless otherwise indicated. +/// +typedef struct _cef_button_t { + /// + /// Base structure. + /// + cef_view_t base; + + /// + /// Returns this Button as a LabelButton or NULL if this is not a LabelButton. + /// + struct _cef_label_button_t*(CEF_CALLBACK* as_label_button)( + struct _cef_button_t* self); + + /// + /// Sets the current display state of the Button. + /// + void(CEF_CALLBACK* set_state)(struct _cef_button_t* self, + cef_button_state_t state); + + /// + /// Returns the current display state of the Button. + /// + cef_button_state_t(CEF_CALLBACK* get_state)(struct _cef_button_t* self); + + /// + /// Sets the Button will use an ink drop effect for displaying state changes. + /// + void(CEF_CALLBACK* set_ink_drop_enabled)(struct _cef_button_t* self, + int enabled); + + /// + /// Sets the tooltip text that will be displayed when the user hovers the + /// mouse cursor over the Button. + /// + void(CEF_CALLBACK* set_tooltip_text)(struct _cef_button_t* self, + const cef_string_t* tooltip_text); + + /// + /// Sets the accessible name that will be exposed to assistive technology + /// (AT). + /// + void(CEF_CALLBACK* set_accessible_name)(struct _cef_button_t* self, + const cef_string_t* name); +} cef_button_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_CAPI_H_ diff --git a/include/capi/views/cef_button_delegate_capi.h b/include/capi/views/cef_button_delegate_capi.h new file mode 100644 index 00000000..caa27da2 --- /dev/null +++ b/include/capi/views/cef_button_delegate_capi.h @@ -0,0 +1,80 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=9843593667569cf8755386ab2d884620087a36b8$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_DELEGATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_DELEGATE_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_view_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_button_t; + +/// +/// Implement this structure to handle Button events. The functions of this +/// structure will be called on the browser process UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_button_delegate_t { + /// + /// Base structure. + /// + cef_view_delegate_t base; + + /// + /// Called when |button| is pressed. + /// + void(CEF_CALLBACK* on_button_pressed)(struct _cef_button_delegate_t* self, + struct _cef_button_t* button); + + /// + /// Called when the state of |button| changes. + /// + void(CEF_CALLBACK* on_button_state_changed)( + struct _cef_button_delegate_t* self, + struct _cef_button_t* button); +} cef_button_delegate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_BUTTON_DELEGATE_CAPI_H_ diff --git a/include/capi/views/cef_display_capi.h b/include/capi/views/cef_display_capi.h new file mode 100644 index 00000000..3c36324d --- /dev/null +++ b/include/capi/views/cef_display_capi.h @@ -0,0 +1,175 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=7674d3af52dd4272b454b2028e7a4ee72fb3c9ff$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_DISPLAY_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_DISPLAY_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// This structure typically, but not always, corresponds to a physical display +/// connected to the system. A fake Display may exist on a headless system, or a +/// Display may correspond to a remote, virtual display. All size and position +/// values are in density independent pixel (DIP) coordinates unless otherwise +/// indicated. Methods must be called on the browser process UI thread unless +/// otherwise indicated. +/// +typedef struct _cef_display_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns the unique identifier for this Display. + /// + int64(CEF_CALLBACK* get_id)(struct _cef_display_t* self); + + /// + /// Returns this Display's device pixel scale factor. This specifies how much + /// the UI should be scaled when the actual output has more pixels than + /// standard displays (which is around 100~120dpi). The potential return + /// values differ by platform. + /// + float(CEF_CALLBACK* get_device_scale_factor)(struct _cef_display_t* self); + + /// + /// Convert |point| from DIP coordinates to pixel coordinates using this + /// Display's device scale factor. + /// + void(CEF_CALLBACK* convert_point_to_pixels)(struct _cef_display_t* self, + cef_point_t* point); + + /// + /// Convert |point| from pixel coordinates to DIP coordinates using this + /// Display's device scale factor. + /// + void(CEF_CALLBACK* convert_point_from_pixels)(struct _cef_display_t* self, + cef_point_t* point); + + /// + /// Returns this Display's bounds in DIP screen coordinates. This is the full + /// size of the display. + /// + cef_rect_t(CEF_CALLBACK* get_bounds)(struct _cef_display_t* self); + + /// + /// Returns this Display's work area in DIP screen coordinates. This excludes + /// areas of the display that are occupied with window manager toolbars, etc. + /// + cef_rect_t(CEF_CALLBACK* get_work_area)(struct _cef_display_t* self); + + /// + /// Returns this Display's rotation in degrees. + /// + int(CEF_CALLBACK* get_rotation)(struct _cef_display_t* self); +} cef_display_t; + +/// +/// Returns the primary Display. +/// +CEF_EXPORT cef_display_t* cef_display_get_primary(void); + +/// +/// Returns the Display nearest |point|. Set |input_pixel_coords| to true (1) if +/// |point| is in pixel screen coordinates instead of DIP screen coordinates. +/// +CEF_EXPORT cef_display_t* cef_display_get_nearest_point( + const cef_point_t* point, + int input_pixel_coords); + +/// +/// Returns the Display that most closely intersects |bounds|. Set +/// |input_pixel_coords| to true (1) if |bounds| is in pixel screen coordinates +/// instead of DIP screen coordinates. +/// +CEF_EXPORT cef_display_t* cef_display_get_matching_bounds( + const cef_rect_t* bounds, + int input_pixel_coords); + +/// +/// Returns the total number of Displays. Mirrored displays are excluded; this +/// function is intended to return the number of distinct, usable displays. +/// +CEF_EXPORT size_t cef_display_get_count(void); + +/// +/// Returns all Displays. Mirrored displays are excluded; this function is +/// intended to return distinct, usable displays. +/// +CEF_EXPORT void cef_display_get_alls(size_t* displaysCount, + cef_display_t** displays); + +/// +/// Convert |point| from DIP screen coordinates to pixel screen coordinates. +/// This function is only used on Windows. +/// +CEF_EXPORT cef_point_t +cef_display_convert_screen_point_to_pixels(const cef_point_t* point); + +/// +/// Convert |point| from pixel screen coordinates to DIP screen coordinates. +/// This function is only used on Windows. +/// +CEF_EXPORT cef_point_t +cef_display_convert_screen_point_from_pixels(const cef_point_t* point); + +/// +/// Convert |rect| from DIP screen coordinates to pixel screen coordinates. This +/// function is only used on Windows. +/// +CEF_EXPORT cef_rect_t +cef_display_convert_screen_rect_to_pixels(const cef_rect_t* rect); + +/// +/// Convert |rect| from pixel screen coordinates to DIP screen coordinates. This +/// function is only used on Windows. +/// +CEF_EXPORT cef_rect_t +cef_display_convert_screen_rect_from_pixels(const cef_rect_t* rect); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_DISPLAY_CAPI_H_ diff --git a/include/capi/views/cef_fill_layout_capi.h b/include/capi/views/cef_fill_layout_capi.h new file mode 100644 index 00000000..c9ae6d9c --- /dev/null +++ b/include/capi/views/cef_fill_layout_capi.h @@ -0,0 +1,65 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=fdb3457ac8b18ad3cf0144af5886586dd675c8f8$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_FILL_LAYOUT_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_FILL_LAYOUT_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_layout_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// A simple Layout that causes the associated Panel's one child to be sized to +/// match the bounds of its parent. Methods must be called on the browser +/// process UI thread unless otherwise indicated. +/// +typedef struct _cef_fill_layout_t { + /// + /// Base structure. + /// + cef_layout_t base; +} cef_fill_layout_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_FILL_LAYOUT_CAPI_H_ diff --git a/include/capi/views/cef_label_button_capi.h b/include/capi/views/cef_label_button_capi.h new file mode 100644 index 00000000..07b38763 --- /dev/null +++ b/include/capi/views/cef_label_button_capi.h @@ -0,0 +1,162 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=eee5b9ebfa58617d5e6fa969e27cc9e378fddb22$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_LABEL_BUTTON_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_LABEL_BUTTON_CAPI_H_ +#pragma once + +#include "include/capi/cef_image_capi.h" +#include "include/capi/views/cef_button_capi.h" +#include "include/capi/views/cef_button_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_menu_button_t; + +/// +/// LabelButton is a button with optional text and/or icon. Methods must be +/// called on the browser process UI thread unless otherwise indicated. +/// +typedef struct _cef_label_button_t { + /// + /// Base structure. + /// + cef_button_t base; + + /// + /// Returns this LabelButton as a MenuButton or NULL if this is not a + /// MenuButton. + /// + struct _cef_menu_button_t*(CEF_CALLBACK* as_menu_button)( + struct _cef_label_button_t* self); + + /// + /// Sets the text shown on the LabelButton. By default |text| will also be + /// used as the accessible name. + /// + void(CEF_CALLBACK* set_text)(struct _cef_label_button_t* self, + const cef_string_t* text); + + /// + /// Returns the text shown on the LabelButton. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_text)( + struct _cef_label_button_t* self); + + /// + /// Sets the image shown for |button_state|. When this Button is drawn if no + /// image exists for the current state then the image for + /// CEF_BUTTON_STATE_NORMAL, if any, will be shown. + /// + void(CEF_CALLBACK* set_image)(struct _cef_label_button_t* self, + cef_button_state_t button_state, + struct _cef_image_t* image); + + /// + /// Returns the image shown for |button_state|. If no image exists for that + /// state then the image for CEF_BUTTON_STATE_NORMAL will be returned. + /// + struct _cef_image_t*(CEF_CALLBACK* get_image)( + struct _cef_label_button_t* self, + cef_button_state_t button_state); + + /// + /// Sets the text color shown for the specified button |for_state| to |color|. + /// + void(CEF_CALLBACK* set_text_color)(struct _cef_label_button_t* self, + cef_button_state_t for_state, + cef_color_t color); + + /// + /// Sets the text colors shown for the non-disabled states to |color|. + /// + void(CEF_CALLBACK* set_enabled_text_colors)(struct _cef_label_button_t* self, + cef_color_t color); + + /// + /// Sets the font list. The format is "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", + /// where: - FONT_FAMILY_LIST is a comma-separated list of font family names, + /// - STYLES is an optional space-separated list of style names (case- + /// sensitive + /// "Bold" and "Italic" are supported), and + /// - SIZE is an integer font size in pixels with the suffix "px". + /// + /// Here are examples of valid font description strings: - "Arial, Helvetica, + /// Bold Italic 14px" - "Arial, 14px" + /// + void(CEF_CALLBACK* set_font_list)(struct _cef_label_button_t* self, + const cef_string_t* font_list); + + /// + /// Sets the horizontal alignment; reversed in RTL. Default is + /// CEF_HORIZONTAL_ALIGNMENT_CENTER. + /// + void(CEF_CALLBACK* set_horizontal_alignment)( + struct _cef_label_button_t* self, + cef_horizontal_alignment_t alignment); + + /// + /// Reset the minimum size of this LabelButton to |size|. + /// + void(CEF_CALLBACK* set_minimum_size)(struct _cef_label_button_t* self, + const cef_size_t* size); + + /// + /// Reset the maximum size of this LabelButton to |size|. + /// + void(CEF_CALLBACK* set_maximum_size)(struct _cef_label_button_t* self, + const cef_size_t* size); +} cef_label_button_t; + +/// +/// Create a new LabelButton. A |delegate| must be provided to handle the button +/// click. |text| will be shown on the LabelButton and used as the default +/// accessible name. +/// +CEF_EXPORT cef_label_button_t* cef_label_button_create( + struct _cef_button_delegate_t* delegate, + const cef_string_t* text); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_LABEL_BUTTON_CAPI_H_ diff --git a/include/capi/views/cef_layout_capi.h b/include/capi/views/cef_layout_capi.h new file mode 100644 index 00000000..5430a459 --- /dev/null +++ b/include/capi/views/cef_layout_capi.h @@ -0,0 +1,85 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=c4a17c07bb2a3518fc5b7350efdc13ffeb803747$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_LAYOUT_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_LAYOUT_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_box_layout_t; +struct _cef_fill_layout_t; + +/// +/// A Layout handles the sizing of the children of a Panel according to +/// implementation-specific heuristics. Methods must be called on the browser +/// process UI thread unless otherwise indicated. +/// +typedef struct _cef_layout_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns this Layout as a BoxLayout or NULL if this is not a BoxLayout. + /// + struct _cef_box_layout_t*(CEF_CALLBACK* as_box_layout)( + struct _cef_layout_t* self); + + /// + /// Returns this Layout as a FillLayout or NULL if this is not a FillLayout. + /// + struct _cef_fill_layout_t*(CEF_CALLBACK* as_fill_layout)( + struct _cef_layout_t* self); + + /// + /// Returns true (1) if this Layout is valid. + /// + int(CEF_CALLBACK* is_valid)(struct _cef_layout_t* self); +} cef_layout_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_LAYOUT_CAPI_H_ diff --git a/include/capi/views/cef_menu_button_capi.h b/include/capi/views/cef_menu_button_capi.h new file mode 100644 index 00000000..85cec0fe --- /dev/null +++ b/include/capi/views/cef_menu_button_capi.h @@ -0,0 +1,99 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=dcfa5d39d1355b2c675637a13378f43376a8053e$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_CAPI_H_ +#pragma once + +#include "include/capi/cef_menu_model_capi.h" +#include "include/capi/views/cef_label_button_capi.h" +#include "include/capi/views/cef_menu_button_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// MenuButton is a button with optional text, icon and/or menu marker that +/// shows a menu when clicked with the left mouse button. All size and position +/// values are in density independent pixels (DIP) unless otherwise indicated. +/// Methods must be called on the browser process UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_menu_button_t { + /// + /// Base structure. + /// + cef_label_button_t base; + + /// + /// Show a menu with contents |menu_model|. |screen_point| specifies the menu + /// position in screen coordinates. |anchor_position| specifies how the menu + /// will be anchored relative to |screen_point|. This function should be + /// called from cef_menu_button_delegate_t::on_menu_button_pressed(). + /// + void(CEF_CALLBACK* show_menu)(struct _cef_menu_button_t* self, + struct _cef_menu_model_t* menu_model, + const cef_point_t* screen_point, + cef_menu_anchor_position_t anchor_position); + + /// + /// Show the menu for this button. Results in a call to + /// cef_menu_button_delegate_t::on_menu_button_pressed(). + /// + void(CEF_CALLBACK* trigger_menu)(struct _cef_menu_button_t* self); +} cef_menu_button_t; + +/// +/// Create a new MenuButton. A |delegate| must be provided to call show_menu() +/// when the button is clicked. |text| will be shown on the MenuButton and used +/// as the default accessible name. If |with_frame| is true (1) the button will +/// have a visible frame at all times, center alignment, additional padding and +/// a default minimum size of 70x33 DIP. If |with_frame| is false (0) the button +/// will only have a visible frame on hover/press, left alignment, less padding +/// and no default minimum size. +/// +CEF_EXPORT cef_menu_button_t* cef_menu_button_create( + struct _cef_menu_button_delegate_t* delegate, + const cef_string_t* text); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_CAPI_H_ diff --git a/include/capi/views/cef_menu_button_delegate_capi.h b/include/capi/views/cef_menu_button_delegate_capi.h new file mode 100644 index 00000000..5d938648 --- /dev/null +++ b/include/capi/views/cef_menu_button_delegate_capi.h @@ -0,0 +1,89 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=38177cad78713d382b81f8b8aa4372402c62fac7$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_DELEGATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_DELEGATE_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_button_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_menu_button_t; + +/// +/// MenuButton pressed lock is released when this object is destroyed. +/// +typedef struct _cef_menu_button_pressed_lock_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; +} cef_menu_button_pressed_lock_t; + +/// +/// Implement this structure to handle MenuButton events. The functions of this +/// structure will be called on the browser process UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_menu_button_delegate_t { + /// + /// Base structure. + /// + cef_button_delegate_t base; + + /// + /// Called when |button| is pressed. Call cef_menu_button_t::show_menu() to + /// show a popup menu at |screen_point|. When showing a custom popup such as a + /// window keep a reference to |button_pressed_lock| until the popup is hidden + /// to maintain the pressed button state. + /// + void(CEF_CALLBACK* on_menu_button_pressed)( + struct _cef_menu_button_delegate_t* self, + struct _cef_menu_button_t* menu_button, + const cef_point_t* screen_point, + struct _cef_menu_button_pressed_lock_t* button_pressed_lock); +} cef_menu_button_delegate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_MENU_BUTTON_DELEGATE_CAPI_H_ diff --git a/include/capi/views/cef_overlay_controller_capi.h b/include/capi/views/cef_overlay_controller_capi.h new file mode 100644 index 00000000..8084bfd6 --- /dev/null +++ b/include/capi/views/cef_overlay_controller_capi.h @@ -0,0 +1,217 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=a5a2c7fe2c285b45268eee1710a8549ab12727f3$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_OVERLAY_CONTROLLER_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_OVERLAY_CONTROLLER_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_view_t; +struct _cef_window_t; + +/// +/// Controller for an overlay that contains a contents View added via +/// cef_window_t::AddOverlayView. Methods exposed by this controller should be +/// called in preference to functions of the same name exposed by the contents +/// View unless otherwise indicated. Methods must be called on the browser +/// process UI thread unless otherwise indicated. +/// +typedef struct _cef_overlay_controller_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns true (1) if this object is valid. + /// + int(CEF_CALLBACK* is_valid)(struct _cef_overlay_controller_t* self); + + /// + /// Returns true (1) if this object is the same as |that| object. + /// + int(CEF_CALLBACK* is_same)(struct _cef_overlay_controller_t* self, + struct _cef_overlay_controller_t* that); + + /// + /// Returns the contents View for this overlay. + /// + struct _cef_view_t*(CEF_CALLBACK* get_contents_view)( + struct _cef_overlay_controller_t* self); + + /// + /// Returns the top-level Window hosting this overlay. Use this function + /// instead of calling get_window() on the contents View. + /// + struct _cef_window_t*(CEF_CALLBACK* get_window)( + struct _cef_overlay_controller_t* self); + + /// + /// Returns the docking mode for this overlay. + /// + cef_docking_mode_t(CEF_CALLBACK* get_docking_mode)( + struct _cef_overlay_controller_t* self); + + /// + /// Destroy this overlay. + /// + void(CEF_CALLBACK* destroy)(struct _cef_overlay_controller_t* self); + + /// + /// Sets the bounds (size and position) of this overlay. This will set the + /// bounds of the contents View to match and trigger a re-layout if necessary. + /// |bounds| is in parent coordinates and any insets configured on this + /// overlay will be ignored. Use this function only for overlays created with + /// a docking mode value of CEF_DOCKING_MODE_CUSTOM. With other docking modes + /// modify the insets of this overlay and/or layout of the contents View and + /// call size_to_preferred_size() instead to calculate the new size and re- + /// position the overlay if necessary. + /// + void(CEF_CALLBACK* set_bounds)(struct _cef_overlay_controller_t* self, + const cef_rect_t* bounds); + + /// + /// Returns the bounds (size and position) of this overlay in parent + /// coordinates. + /// + cef_rect_t(CEF_CALLBACK* get_bounds)(struct _cef_overlay_controller_t* self); + + /// + /// Returns the bounds (size and position) of this overlay in DIP screen + /// coordinates. + /// + cef_rect_t(CEF_CALLBACK* get_bounds_in_screen)( + struct _cef_overlay_controller_t* self); + + /// + /// Sets the size of this overlay without changing the position. This will set + /// the size of the contents View to match and trigger a re-layout if + /// necessary. |size| is in parent coordinates and any insets configured on + /// this overlay will be ignored. Use this function only for overlays created + /// with a docking mode value of CEF_DOCKING_MODE_CUSTOM. With other docking + /// modes modify the insets of this overlay and/or layout of the contents View + /// and call size_to_preferred_size() instead to calculate the new size and + /// re-position the overlay if necessary. + /// + void(CEF_CALLBACK* set_size)(struct _cef_overlay_controller_t* self, + const cef_size_t* size); + + /// + /// Returns the size of this overlay in parent coordinates. + /// + cef_size_t(CEF_CALLBACK* get_size)(struct _cef_overlay_controller_t* self); + + /// + /// Sets the position of this overlay without changing the size. |position| is + /// in parent coordinates and any insets configured on this overlay will be + /// ignored. Use this function only for overlays created with a docking mode + /// value of CEF_DOCKING_MODE_CUSTOM. With other docking modes modify the + /// insets of this overlay and/or layout of the contents View and call + /// size_to_preferred_size() instead to calculate the new size and re-position + /// the overlay if necessary. + /// + void(CEF_CALLBACK* set_position)(struct _cef_overlay_controller_t* self, + const cef_point_t* position); + + /// + /// Returns the position of this overlay in parent coordinates. + /// + cef_point_t(CEF_CALLBACK* get_position)( + struct _cef_overlay_controller_t* self); + + /// + /// Sets the insets for this overlay. |insets| is in parent coordinates. Use + /// this function only for overlays created with a docking mode value other + /// than CEF_DOCKING_MODE_CUSTOM. + /// + void(CEF_CALLBACK* set_insets)(struct _cef_overlay_controller_t* self, + const cef_insets_t* insets); + + /// + /// Returns the insets for this overlay in parent coordinates. + /// + cef_insets_t(CEF_CALLBACK* get_insets)( + struct _cef_overlay_controller_t* self); + + /// + /// Size this overlay to its preferred size and trigger a re-layout if + /// necessary. The position of overlays created with a docking mode value of + /// CEF_DOCKING_MODE_CUSTOM will not be modified by calling this function. + /// With other docking modes this function may re-position the overlay if + /// necessary to accommodate the new size and any insets configured on the + /// contents View. + /// + void(CEF_CALLBACK* size_to_preferred_size)( + struct _cef_overlay_controller_t* self); + + /// + /// Sets whether this overlay is visible. Overlays are hidden by default. If + /// this overlay is hidden then it and any child Views will not be drawn and, + /// if any of those Views currently have focus, then focus will also be + /// cleared. Painting is scheduled as needed. + /// + void(CEF_CALLBACK* set_visible)(struct _cef_overlay_controller_t* self, + int visible); + + /// + /// Returns whether this overlay is visible. A View may be visible but still + /// not drawn in a Window if any parent Views are hidden. Call is_drawn() to + /// determine whether this overlay and all parent Views are visible and will + /// be drawn. + /// + int(CEF_CALLBACK* is_visible)(struct _cef_overlay_controller_t* self); + + /// + /// Returns whether this overlay is visible and drawn in a Window. A View is + /// drawn if it and all parent Views are visible. To determine if the + /// containing Window is visible to the user on-screen call is_visible() on + /// the Window. + /// + int(CEF_CALLBACK* is_drawn)(struct _cef_overlay_controller_t* self); +} cef_overlay_controller_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_OVERLAY_CONTROLLER_CAPI_H_ diff --git a/include/capi/views/cef_panel_capi.h b/include/capi/views/cef_panel_capi.h new file mode 100644 index 00000000..658b0050 --- /dev/null +++ b/include/capi/views/cef_panel_capi.h @@ -0,0 +1,151 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=40d350f75893a1e4307b282317d55f0fceae3baf$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_panel_delegate_capi.h" +#include "include/capi/views/cef_view_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_box_layout_t; +struct _cef_fill_layout_t; +struct _cef_layout_t; +struct _cef_window_t; + +/// +/// A Panel is a container in the views hierarchy that can contain other Views +/// as children. Methods must be called on the browser process UI thread unless +/// otherwise indicated. +/// +typedef struct _cef_panel_t { + /// + /// Base structure. + /// + cef_view_t base; + + /// + /// Returns this Panel as a Window or NULL if this is not a Window. + /// + struct _cef_window_t*(CEF_CALLBACK* as_window)(struct _cef_panel_t* self); + + /// + /// Set this Panel's Layout to FillLayout and return the FillLayout object. + /// + struct _cef_fill_layout_t*(CEF_CALLBACK* set_to_fill_layout)( + struct _cef_panel_t* self); + + /// + /// Set this Panel's Layout to BoxLayout and return the BoxLayout object. + /// + struct _cef_box_layout_t*(CEF_CALLBACK* set_to_box_layout)( + struct _cef_panel_t* self, + const cef_box_layout_settings_t* settings); + + /// + /// Get the Layout. + /// + struct _cef_layout_t*(CEF_CALLBACK* get_layout)(struct _cef_panel_t* self); + + /// + /// Lay out the child Views (set their bounds based on sizing heuristics + /// specific to the current Layout). + /// + void(CEF_CALLBACK* layout)(struct _cef_panel_t* self); + + /// + /// Add a child View. + /// + void(CEF_CALLBACK* add_child_view)(struct _cef_panel_t* self, + struct _cef_view_t* view); + + /// + /// Add a child View at the specified |index|. If |index| matches the result + /// of GetChildCount() then the View will be added at the end. + /// + void(CEF_CALLBACK* add_child_view_at)(struct _cef_panel_t* self, + struct _cef_view_t* view, + int index); + + /// + /// Move the child View to the specified |index|. A negative value for |index| + /// will move the View to the end. + /// + void(CEF_CALLBACK* reorder_child_view)(struct _cef_panel_t* self, + struct _cef_view_t* view, + int index); + + /// + /// Remove a child View. The View can then be added to another Panel. + /// + void(CEF_CALLBACK* remove_child_view)(struct _cef_panel_t* self, + struct _cef_view_t* view); + + /// + /// Remove all child Views. The removed Views will be deleted if the client + /// holds no references to them. + /// + void(CEF_CALLBACK* remove_all_child_views)(struct _cef_panel_t* self); + + /// + /// Returns the number of child Views. + /// + size_t(CEF_CALLBACK* get_child_view_count)(struct _cef_panel_t* self); + + /// + /// Returns the child View at the specified |index|. + /// + struct _cef_view_t*( + CEF_CALLBACK* get_child_view_at)(struct _cef_panel_t* self, int index); +} cef_panel_t; + +/// +/// Create a new Panel. +/// +CEF_EXPORT cef_panel_t* cef_panel_create( + struct _cef_panel_delegate_t* delegate); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_CAPI_H_ diff --git a/include/capi/views/cef_panel_delegate_capi.h b/include/capi/views/cef_panel_delegate_capi.h new file mode 100644 index 00000000..227762d5 --- /dev/null +++ b/include/capi/views/cef_panel_delegate_capi.h @@ -0,0 +1,65 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=e8bdae70e1f16fba3a5e01d9e215a02f13291ff5$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_DELEGATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_DELEGATE_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_view_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// Implement this structure to handle Panel events. The functions of this +/// structure will be called on the browser process UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_panel_delegate_t { + /// + /// Base structure. + /// + cef_view_delegate_t base; +} cef_panel_delegate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_DELEGATE_CAPI_H_ diff --git a/include/capi/views/cef_scroll_view_capi.h b/include/capi/views/cef_scroll_view_capi.h new file mode 100644 index 00000000..dd503c28 --- /dev/null +++ b/include/capi/views/cef_scroll_view_capi.h @@ -0,0 +1,112 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=e3aa3fbb265a600d498884b0fbb852fc5bbf8856$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_SCROLL_VIEW_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_SCROLL_VIEW_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_view_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// A ScrollView will show horizontal and/or vertical scrollbars when necessary +/// based on the size of the attached content view. Methods must be called on +/// the browser process UI thread unless otherwise indicated. +/// +typedef struct _cef_scroll_view_t { + /// + /// Base structure. + /// + cef_view_t base; + + /// + /// Set the content View. The content View must have a specified size (e.g. + /// via cef_view_t::SetBounds or cef_view_delegate_t::GetPreferredSize). + /// + void(CEF_CALLBACK* set_content_view)(struct _cef_scroll_view_t* self, + struct _cef_view_t* view); + + /// + /// Returns the content View. + /// + struct _cef_view_t*(CEF_CALLBACK* get_content_view)( + struct _cef_scroll_view_t* self); + + /// + /// Returns the visible region of the content View. + /// + cef_rect_t(CEF_CALLBACK* get_visible_content_rect)( + struct _cef_scroll_view_t* self); + + /// + /// Returns true (1) if the horizontal scrollbar is currently showing. + /// + int(CEF_CALLBACK* has_horizontal_scrollbar)(struct _cef_scroll_view_t* self); + + /// + /// Returns the height of the horizontal scrollbar. + /// + int(CEF_CALLBACK* get_horizontal_scrollbar_height)( + struct _cef_scroll_view_t* self); + + /// + /// Returns true (1) if the vertical scrollbar is currently showing. + /// + int(CEF_CALLBACK* has_vertical_scrollbar)(struct _cef_scroll_view_t* self); + + /// + /// Returns the width of the vertical scrollbar. + /// + int(CEF_CALLBACK* get_vertical_scrollbar_width)( + struct _cef_scroll_view_t* self); +} cef_scroll_view_t; + +/// +/// Create a new ScrollView. +/// +CEF_EXPORT cef_scroll_view_t* cef_scroll_view_create( + struct _cef_view_delegate_t* delegate); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_SCROLL_VIEW_CAPI_H_ diff --git a/include/capi/views/cef_textfield_capi.h b/include/capi/views/cef_textfield_capi.h new file mode 100644 index 00000000..c525f216 --- /dev/null +++ b/include/capi/views/cef_textfield_capi.h @@ -0,0 +1,274 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=7d5a43282c9847c5c842abd5de023f4c5c69a9f0$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_textfield_delegate_capi.h" +#include "include/capi/views/cef_view_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// A Textfield supports editing of text. This control is custom rendered with +/// no platform-specific code. Methods must be called on the browser process UI +/// thread unless otherwise indicated. +/// +typedef struct _cef_textfield_t { + /// + /// Base structure. + /// + cef_view_t base; + + /// + /// Sets whether the text will be displayed as asterisks. + /// + void(CEF_CALLBACK* set_password_input)(struct _cef_textfield_t* self, + int password_input); + + /// + /// Returns true (1) if the text will be displayed as asterisks. + /// + int(CEF_CALLBACK* is_password_input)(struct _cef_textfield_t* self); + + /// + /// Sets whether the text will read-only. + /// + void(CEF_CALLBACK* set_read_only)(struct _cef_textfield_t* self, + int read_only); + + /// + /// Returns true (1) if the text is read-only. + /// + int(CEF_CALLBACK* is_read_only)(struct _cef_textfield_t* self); + + /// + /// Returns the currently displayed text. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_text)(struct _cef_textfield_t* self); + + /// + /// Sets the contents to |text|. The cursor will be moved to end of the text + /// if the current position is outside of the text range. + /// + void(CEF_CALLBACK* set_text)(struct _cef_textfield_t* self, + const cef_string_t* text); + + /// + /// Appends |text| to the previously-existing text. + /// + void(CEF_CALLBACK* append_text)(struct _cef_textfield_t* self, + const cef_string_t* text); + + /// + /// Inserts |text| at the current cursor position replacing any selected text. + /// + void(CEF_CALLBACK* insert_or_replace_text)(struct _cef_textfield_t* self, + const cef_string_t* text); + + /// + /// Returns true (1) if there is any selected text. + /// + int(CEF_CALLBACK* has_selection)(struct _cef_textfield_t* self); + + /// + /// Returns the currently selected text. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_selected_text)( + struct _cef_textfield_t* self); + + /// + /// Selects all text. If |reversed| is true (1) the range will end at the + /// logical beginning of the text; this generally shows the leading portion of + /// text that overflows its display area. + /// + void(CEF_CALLBACK* select_all)(struct _cef_textfield_t* self, int reversed); + + /// + /// Clears the text selection and sets the caret to the end. + /// + void(CEF_CALLBACK* clear_selection)(struct _cef_textfield_t* self); + + /// + /// Returns the selected logical text range. + /// + cef_range_t(CEF_CALLBACK* get_selected_range)(struct _cef_textfield_t* self); + + /// + /// Selects the specified logical text range. + /// + void(CEF_CALLBACK* select_range)(struct _cef_textfield_t* self, + const cef_range_t* range); + + /// + /// Returns the current cursor position. + /// + size_t(CEF_CALLBACK* get_cursor_position)(struct _cef_textfield_t* self); + + /// + /// Sets the text color. + /// + void(CEF_CALLBACK* set_text_color)(struct _cef_textfield_t* self, + cef_color_t color); + + /// + /// Returns the text color. + /// + cef_color_t(CEF_CALLBACK* get_text_color)(struct _cef_textfield_t* self); + + /// + /// Sets the selection text color. + /// + void(CEF_CALLBACK* set_selection_text_color)(struct _cef_textfield_t* self, + cef_color_t color); + + /// + /// Returns the selection text color. + /// + cef_color_t(CEF_CALLBACK* get_selection_text_color)( + struct _cef_textfield_t* self); + + /// + /// Sets the selection background color. + /// + void(CEF_CALLBACK* set_selection_background_color)( + struct _cef_textfield_t* self, + cef_color_t color); + + /// + /// Returns the selection background color. + /// + cef_color_t(CEF_CALLBACK* get_selection_background_color)( + struct _cef_textfield_t* self); + + /// + /// Sets the font list. The format is "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", + /// where: - FONT_FAMILY_LIST is a comma-separated list of font family names, + /// - STYLES is an optional space-separated list of style names (case- + /// sensitive + /// "Bold" and "Italic" are supported), and + /// - SIZE is an integer font size in pixels with the suffix "px". + /// + /// Here are examples of valid font description strings: - "Arial, Helvetica, + /// Bold Italic 14px" - "Arial, 14px" + /// + void(CEF_CALLBACK* set_font_list)(struct _cef_textfield_t* self, + const cef_string_t* font_list); + + /// + /// Applies |color| to the specified |range| without changing the default + /// color. If |range| is NULL the color will be set on the complete text + /// contents. + /// + void(CEF_CALLBACK* apply_text_color)(struct _cef_textfield_t* self, + cef_color_t color, + const cef_range_t* range); + + /// + /// Applies |style| to the specified |range| without changing the default + /// style. If |add| is true (1) the style will be added, otherwise the style + /// will be removed. If |range| is NULL the style will be set on the complete + /// text contents. + /// + void(CEF_CALLBACK* apply_text_style)(struct _cef_textfield_t* self, + cef_text_style_t style, + int add, + const cef_range_t* range); + + /// + /// Returns true (1) if the action associated with the specified command id is + /// enabled. See additional comments on execute_command(). + /// + int(CEF_CALLBACK* is_command_enabled)(struct _cef_textfield_t* self, + cef_text_field_commands_t command_id); + + /// + /// Performs the action associated with the specified command id. + /// + void(CEF_CALLBACK* execute_command)(struct _cef_textfield_t* self, + cef_text_field_commands_t command_id); + + /// + /// Clears Edit history. + /// + void(CEF_CALLBACK* clear_edit_history)(struct _cef_textfield_t* self); + + /// + /// Sets the placeholder text that will be displayed when the Textfield is + /// NULL. + /// + void(CEF_CALLBACK* set_placeholder_text)(struct _cef_textfield_t* self, + const cef_string_t* text); + + /// + /// Returns the placeholder text that will be displayed when the Textfield is + /// NULL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_placeholder_text)( + struct _cef_textfield_t* self); + + /// + /// Sets the placeholder text color. + /// + void(CEF_CALLBACK* set_placeholder_text_color)(struct _cef_textfield_t* self, + cef_color_t color); + + /// + /// Set the accessible name that will be exposed to assistive technology (AT). + /// + void(CEF_CALLBACK* set_accessible_name)(struct _cef_textfield_t* self, + const cef_string_t* name); +} cef_textfield_t; + +/// +/// Create a new Textfield. +/// +CEF_EXPORT cef_textfield_t* cef_textfield_create( + struct _cef_textfield_delegate_t* delegate); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_CAPI_H_ diff --git a/include/capi/views/cef_textfield_delegate_capi.h b/include/capi/views/cef_textfield_delegate_capi.h new file mode 100644 index 00000000..a14c0bfe --- /dev/null +++ b/include/capi/views/cef_textfield_delegate_capi.h @@ -0,0 +1,83 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=482b091326684014bd799fef864e3dfdfc8693a1$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_DELEGATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_DELEGATE_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_view_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_textfield_t; + +/// +/// Implement this structure to handle Textfield events. The functions of this +/// structure will be called on the browser process UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_textfield_delegate_t { + /// + /// Base structure. + /// + cef_view_delegate_t base; + + /// + /// Called when |textfield| recieves a keyboard event. |event| contains + /// information about the keyboard event. Return true (1) if the keyboard + /// event was handled or false (0) otherwise for default handling. + /// + int(CEF_CALLBACK* on_key_event)(struct _cef_textfield_delegate_t* self, + struct _cef_textfield_t* textfield, + const cef_key_event_t* event); + + /// + /// Called after performing a user action that may change |textfield|. + /// + void(CEF_CALLBACK* on_after_user_action)( + struct _cef_textfield_delegate_t* self, + struct _cef_textfield_t* textfield); +} cef_textfield_delegate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_DELEGATE_CAPI_H_ diff --git a/include/capi/views/cef_view_capi.h b/include/capi/views/cef_view_capi.h new file mode 100644 index 00000000..5372f61f --- /dev/null +++ b/include/capi/views/cef_view_capi.h @@ -0,0 +1,413 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=cb5950b283944d06312903eb554cc4c980713e98$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_view_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_browser_view_t; +struct _cef_button_t; +struct _cef_panel_t; +struct _cef_scroll_view_t; +struct _cef_textfield_t; +struct _cef_window_t; + +/// +/// A View is a rectangle within the views View hierarchy. It is the base +/// structure for all Views. All size and position values are in density +/// independent pixels (DIP) unless otherwise indicated. Methods must be called +/// on the browser process UI thread unless otherwise indicated. +/// +typedef struct _cef_view_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Returns this View as a BrowserView or NULL if this is not a BrowserView. + /// + struct _cef_browser_view_t*(CEF_CALLBACK* as_browser_view)( + struct _cef_view_t* self); + + /// + /// Returns this View as a Button or NULL if this is not a Button. + /// + struct _cef_button_t*(CEF_CALLBACK* as_button)(struct _cef_view_t* self); + + /// + /// Returns this View as a Panel or NULL if this is not a Panel. + /// + struct _cef_panel_t*(CEF_CALLBACK* as_panel)(struct _cef_view_t* self); + + /// + /// Returns this View as a ScrollView or NULL if this is not a ScrollView. + /// + struct _cef_scroll_view_t*(CEF_CALLBACK* as_scroll_view)( + struct _cef_view_t* self); + + /// + /// Returns this View as a Textfield or NULL if this is not a Textfield. + /// + struct _cef_textfield_t*(CEF_CALLBACK* as_textfield)( + struct _cef_view_t* self); + + /// + /// Returns the type of this View as a string. Used primarily for testing + /// purposes. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_type_string)( + struct _cef_view_t* self); + + /// + /// Returns a string representation of this View which includes the type and + /// various type-specific identifying attributes. If |include_children| is + /// true (1) any child Views will also be included. Used primarily for testing + /// purposes. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* to_string)(struct _cef_view_t* self, + int include_children); + + /// + /// Returns true (1) if this View is valid. + /// + int(CEF_CALLBACK* is_valid)(struct _cef_view_t* self); + + /// + /// Returns true (1) if this View is currently attached to another View. A + /// View can only be attached to one View at a time. + /// + int(CEF_CALLBACK* is_attached)(struct _cef_view_t* self); + + /// + /// Returns true (1) if this View is the same as |that| View. + /// + int(CEF_CALLBACK* is_same)(struct _cef_view_t* self, + struct _cef_view_t* that); + + /// + /// Returns the delegate associated with this View, if any. + /// + struct _cef_view_delegate_t*(CEF_CALLBACK* get_delegate)( + struct _cef_view_t* self); + + /// + /// Returns the top-level Window hosting this View, if any. + /// + struct _cef_window_t*(CEF_CALLBACK* get_window)(struct _cef_view_t* self); + + /// + /// Returns the ID for this View. + /// + int(CEF_CALLBACK* get_id)(struct _cef_view_t* self); + + /// + /// Sets the ID for this View. ID should be unique within the subtree that you + /// intend to search for it. 0 is the default ID for views. + /// + void(CEF_CALLBACK* set_id)(struct _cef_view_t* self, int id); + + /// + /// Returns the group id of this View, or -1 if not set. + /// + int(CEF_CALLBACK* get_group_id)(struct _cef_view_t* self); + + /// + /// A group id is used to tag Views which are part of the same logical group. + /// Focus can be moved between views with the same group using the arrow keys. + /// The group id is immutable once it's set. + /// + void(CEF_CALLBACK* set_group_id)(struct _cef_view_t* self, int group_id); + + /// + /// Returns the View that contains this View, if any. + /// + struct _cef_view_t*(CEF_CALLBACK* get_parent_view)(struct _cef_view_t* self); + + /// + /// Recursively descends the view tree starting at this View, and returns the + /// first child that it encounters with the given ID. Returns NULL if no + /// matching child view is found. + /// + struct _cef_view_t*(CEF_CALLBACK* get_view_for_id)(struct _cef_view_t* self, + int id); + + /// + /// Sets the bounds (size and position) of this View. |bounds| is in parent + /// coordinates, or DIP screen coordinates if there is no parent. + /// + void(CEF_CALLBACK* set_bounds)(struct _cef_view_t* self, + const cef_rect_t* bounds); + + /// + /// Returns the bounds (size and position) of this View in parent coordinates, + /// or DIP screen coordinates if there is no parent. + /// + cef_rect_t(CEF_CALLBACK* get_bounds)(struct _cef_view_t* self); + + /// + /// Returns the bounds (size and position) of this View in DIP screen + /// coordinates. + /// + cef_rect_t(CEF_CALLBACK* get_bounds_in_screen)(struct _cef_view_t* self); + + /// + /// Sets the size of this View without changing the position. |size| in parent + /// coordinates, or DIP screen coordinates if there is no parent. + /// + void(CEF_CALLBACK* set_size)(struct _cef_view_t* self, + const cef_size_t* size); + + /// + /// Returns the size of this View in parent coordinates, or DIP screen + /// coordinates if there is no parent. + /// + cef_size_t(CEF_CALLBACK* get_size)(struct _cef_view_t* self); + + /// + /// Sets the position of this View without changing the size. |position| is in + /// parent coordinates, or DIP screen coordinates if there is no parent. + /// + void(CEF_CALLBACK* set_position)(struct _cef_view_t* self, + const cef_point_t* position); + + /// + /// Returns the position of this View. Position is in parent coordinates, or + /// DIP screen coordinates if there is no parent. + /// + cef_point_t(CEF_CALLBACK* get_position)(struct _cef_view_t* self); + + /// + /// Sets the insets for this View. |insets| is in parent coordinates, or DIP + /// screen coordinates if there is no parent. + /// + void(CEF_CALLBACK* set_insets)(struct _cef_view_t* self, + const cef_insets_t* insets); + + /// + /// Returns the insets for this View in parent coordinates, or DIP screen + /// coordinates if there is no parent. + /// + cef_insets_t(CEF_CALLBACK* get_insets)(struct _cef_view_t* self); + + /// + /// Returns the size this View would like to be if enough space is available. + /// Size is in parent coordinates, or DIP screen coordinates if there is no + /// parent. + /// + cef_size_t(CEF_CALLBACK* get_preferred_size)(struct _cef_view_t* self); + + /// + /// Size this View to its preferred size. Size is in parent coordinates, or + /// DIP screen coordinates if there is no parent. + /// + void(CEF_CALLBACK* size_to_preferred_size)(struct _cef_view_t* self); + + /// + /// Returns the minimum size for this View. Size is in parent coordinates, or + /// DIP screen coordinates if there is no parent. + /// + cef_size_t(CEF_CALLBACK* get_minimum_size)(struct _cef_view_t* self); + + /// + /// Returns the maximum size for this View. Size is in parent coordinates, or + /// DIP screen coordinates if there is no parent. + /// + cef_size_t(CEF_CALLBACK* get_maximum_size)(struct _cef_view_t* self); + + /// + /// Returns the height necessary to display this View with the provided width. + /// + int(CEF_CALLBACK* get_height_for_width)(struct _cef_view_t* self, int width); + + /// + /// Indicate that this View and all parent Views require a re-layout. This + /// ensures the next call to layout() will propagate to this View even if the + /// bounds of parent Views do not change. + /// + void(CEF_CALLBACK* invalidate_layout)(struct _cef_view_t* self); + + /// + /// Sets whether this View is visible. Windows are hidden by default and other + /// views are visible by default. This View and any parent views must be set + /// as visible for this View to be drawn in a Window. If this View is set as + /// hidden then it and any child views will not be drawn and, if any of those + /// views currently have focus, then focus will also be cleared. Painting is + /// scheduled as needed. If this View is a Window then calling this function + /// is equivalent to calling the Window show() and hide() functions. + /// + void(CEF_CALLBACK* set_visible)(struct _cef_view_t* self, int visible); + + /// + /// Returns whether this View is visible. A view may be visible but still not + /// drawn in a Window if any parent views are hidden. If this View is a Window + /// then a return value of true (1) indicates that this Window is currently + /// visible to the user on-screen. If this View is not a Window then call + /// is_drawn() to determine whether this View and all parent views are visible + /// and will be drawn. + /// + int(CEF_CALLBACK* is_visible)(struct _cef_view_t* self); + + /// + /// Returns whether this View is visible and drawn in a Window. A view is + /// drawn if it and all parent views are visible. If this View is a Window + /// then calling this function is equivalent to calling is_visible(). + /// Otherwise, to determine if the containing Window is visible to the user + /// on-screen call is_visible() on the Window. + /// + int(CEF_CALLBACK* is_drawn)(struct _cef_view_t* self); + + /// + /// Set whether this View is enabled. A disabled View does not receive + /// keyboard or mouse inputs. If |enabled| differs from the current value the + /// View will be repainted. Also, clears focus if the focused View is + /// disabled. + /// + void(CEF_CALLBACK* set_enabled)(struct _cef_view_t* self, int enabled); + + /// + /// Returns whether this View is enabled. + /// + int(CEF_CALLBACK* is_enabled)(struct _cef_view_t* self); + + /// + /// Sets whether this View is capable of taking focus. It will clear focus if + /// the focused View is set to be non-focusable. This is false (0) by default + /// so that a View used as a container does not get the focus. + /// + void(CEF_CALLBACK* set_focusable)(struct _cef_view_t* self, int focusable); + + /// + /// Returns true (1) if this View is focusable, enabled and drawn. + /// + int(CEF_CALLBACK* is_focusable)(struct _cef_view_t* self); + + /// + /// Return whether this View is focusable when the user requires full keyboard + /// access, even though it may not be normally focusable. + /// + int(CEF_CALLBACK* is_accessibility_focusable)(struct _cef_view_t* self); + + /// + /// Request keyboard focus. If this View is focusable it will become the + /// focused View. + /// + void(CEF_CALLBACK* request_focus)(struct _cef_view_t* self); + + /// + /// Sets the background color for this View. + /// + void(CEF_CALLBACK* set_background_color)(struct _cef_view_t* self, + cef_color_t color); + + /// + /// Returns the background color for this View. + /// + cef_color_t(CEF_CALLBACK* get_background_color)(struct _cef_view_t* self); + + /// + /// Convert |point| from this View's coordinate system to DIP screen + /// coordinates. This View must belong to a Window when calling this function. + /// Returns true (1) if the conversion is successful or false (0) otherwise. + /// Use cef_display_t::convert_point_to_pixels() after calling this function + /// if further conversion to display-specific pixel coordinates is desired. + /// + int(CEF_CALLBACK* convert_point_to_screen)(struct _cef_view_t* self, + cef_point_t* point); + + /// + /// Convert |point| to this View's coordinate system from DIP screen + /// coordinates. This View must belong to a Window when calling this function. + /// Returns true (1) if the conversion is successful or false (0) otherwise. + /// Use cef_display_t::convert_point_from_pixels() before calling this + /// function if conversion from display-specific pixel coordinates is + /// necessary. + /// + int(CEF_CALLBACK* convert_point_from_screen)(struct _cef_view_t* self, + cef_point_t* point); + + /// + /// Convert |point| from this View's coordinate system to that of the Window. + /// This View must belong to a Window when calling this function. Returns true + /// (1) if the conversion is successful or false (0) otherwise. + /// + int(CEF_CALLBACK* convert_point_to_window)(struct _cef_view_t* self, + cef_point_t* point); + + /// + /// Convert |point| to this View's coordinate system from that of the Window. + /// This View must belong to a Window when calling this function. Returns true + /// (1) if the conversion is successful or false (0) otherwise. + /// + int(CEF_CALLBACK* convert_point_from_window)(struct _cef_view_t* self, + cef_point_t* point); + + /// + /// Convert |point| from this View's coordinate system to that of |view|. + /// |view| needs to be in the same Window but not necessarily the same view + /// hierarchy. Returns true (1) if the conversion is successful or false (0) + /// otherwise. + /// + int(CEF_CALLBACK* convert_point_to_view)(struct _cef_view_t* self, + struct _cef_view_t* view, + cef_point_t* point); + + /// + /// Convert |point| to this View's coordinate system from that |view|. |view| + /// needs to be in the same Window but not necessarily the same view + /// hierarchy. Returns true (1) if the conversion is successful or false (0) + /// otherwise. + /// + int(CEF_CALLBACK* convert_point_from_view)(struct _cef_view_t* self, + struct _cef_view_t* view, + cef_point_t* point); +} cef_view_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_CAPI_H_ diff --git a/include/capi/views/cef_view_delegate_capi.h b/include/capi/views/cef_view_delegate_capi.h new file mode 100644 index 00000000..4f4b8f01 --- /dev/null +++ b/include/capi/views/cef_view_delegate_capi.h @@ -0,0 +1,149 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=70646cb55b5bf98ccfa2a93b2cf57bd5ba367268$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_DELEGATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_DELEGATE_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_view_t; + +/// +/// Implement this structure to handle view events. All size and position values +/// are in density independent pixels (DIP) unless otherwise indicated. The +/// functions of this structure will be called on the browser process UI thread +/// unless otherwise indicated. +/// +typedef struct _cef_view_delegate_t { + /// + /// Base structure. + /// + cef_base_ref_counted_t base; + + /// + /// Return the preferred size for |view|. The Layout will use this information + /// to determine the display size. + /// + cef_size_t(CEF_CALLBACK* get_preferred_size)( + struct _cef_view_delegate_t* self, + struct _cef_view_t* view); + + /// + /// Return the minimum size for |view|. + /// + cef_size_t(CEF_CALLBACK* get_minimum_size)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view); + + /// + /// Return the maximum size for |view|. + /// + cef_size_t(CEF_CALLBACK* get_maximum_size)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view); + + /// + /// Return the height necessary to display |view| with the provided |width|. + /// If not specified the result of get_preferred_size().height will be used by + /// default. Override if |view|'s preferred height depends upon the width (for + /// example, with Labels). + /// + int(CEF_CALLBACK* get_height_for_width)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view, + int width); + + /// + /// Called when the parent of |view| has changed. If |view| is being added to + /// |parent| then |added| will be true (1). If |view| is being removed from + /// |parent| then |added| will be false (0). If |view| is being reparented the + /// remove notification will be sent before the add notification. Do not + /// modify the view hierarchy in this callback. + /// + void(CEF_CALLBACK* on_parent_view_changed)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view, + int added, + struct _cef_view_t* parent); + + /// + /// Called when a child of |view| has changed. If |child| is being added to + /// |view| then |added| will be true (1). If |child| is being removed from + /// |view| then |added| will be false (0). If |child| is being reparented the + /// remove notification will be sent to the old parent before the add + /// notification is sent to the new parent. Do not modify the view hierarchy + /// in this callback. + /// + void(CEF_CALLBACK* on_child_view_changed)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view, + int added, + struct _cef_view_t* child); + + /// + /// Called when |view| is added or removed from the cef_window_t. + /// + void(CEF_CALLBACK* on_window_changed)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view, + int added); + + /// + /// Called when the layout of |view| has changed. + /// + void(CEF_CALLBACK* on_layout_changed)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view, + const cef_rect_t* new_bounds); + + /// + /// Called when |view| gains focus. + /// + void(CEF_CALLBACK* on_focus)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view); + + /// + /// Called when |view| loses focus. + /// + void(CEF_CALLBACK* on_blur)(struct _cef_view_delegate_t* self, + struct _cef_view_t* view); +} cef_view_delegate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_DELEGATE_CAPI_H_ diff --git a/include/capi/views/cef_window_capi.h b/include/capi/views/cef_window_capi.h new file mode 100644 index 00000000..912e4ba6 --- /dev/null +++ b/include/capi/views/cef_window_capi.h @@ -0,0 +1,349 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=04aa6e193cc5d5658c0ef28a42c0777c0a955409$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_CAPI_H_ +#pragma once + +#include "include/capi/cef_image_capi.h" +#include "include/capi/cef_menu_model_capi.h" +#include "include/capi/views/cef_display_capi.h" +#include "include/capi/views/cef_overlay_controller_capi.h" +#include "include/capi/views/cef_panel_capi.h" +#include "include/capi/views/cef_window_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// A Window is a top-level Window/widget in the Views hierarchy. By default it +/// will have a non-client area with title bar, icon and buttons that supports +/// moving and resizing. All size and position values are in density independent +/// pixels (DIP) unless otherwise indicated. Methods must be called on the +/// browser process UI thread unless otherwise indicated. +/// +typedef struct _cef_window_t { + /// + /// Base structure. + /// + cef_panel_t base; + + /// + /// Show the Window. + /// + void(CEF_CALLBACK* show)(struct _cef_window_t* self); + + /// + /// Hide the Window. + /// + void(CEF_CALLBACK* hide)(struct _cef_window_t* self); + + /// + /// Sizes the Window to |size| and centers it in the current display. + /// + void(CEF_CALLBACK* center_window)(struct _cef_window_t* self, + const cef_size_t* size); + + /// + /// Close the Window. + /// + void(CEF_CALLBACK* close)(struct _cef_window_t* self); + + /// + /// Returns true (1) if the Window has been closed. + /// + int(CEF_CALLBACK* is_closed)(struct _cef_window_t* self); + + /// + /// Activate the Window, assuming it already exists and is visible. + /// + void(CEF_CALLBACK* activate)(struct _cef_window_t* self); + + /// + /// Deactivate the Window, making the next Window in the Z order the active + /// Window. + /// + void(CEF_CALLBACK* deactivate)(struct _cef_window_t* self); + + /// + /// Returns whether the Window is the currently active Window. + /// + int(CEF_CALLBACK* is_active)(struct _cef_window_t* self); + + /// + /// Bring this Window to the top of other Windows in the Windowing system. + /// + void(CEF_CALLBACK* bring_to_top)(struct _cef_window_t* self); + + /// + /// Set the Window to be on top of other Windows in the Windowing system. + /// + void(CEF_CALLBACK* set_always_on_top)(struct _cef_window_t* self, int on_top); + + /// + /// Returns whether the Window has been set to be on top of other Windows in + /// the Windowing system. + /// + int(CEF_CALLBACK* is_always_on_top)(struct _cef_window_t* self); + + /// + /// Maximize the Window. + /// + void(CEF_CALLBACK* maximize)(struct _cef_window_t* self); + + /// + /// Minimize the Window. + /// + void(CEF_CALLBACK* minimize)(struct _cef_window_t* self); + + /// + /// Restore the Window. + /// + void(CEF_CALLBACK* restore)(struct _cef_window_t* self); + + /// + /// Set fullscreen Window state. + /// + void(CEF_CALLBACK* set_fullscreen)(struct _cef_window_t* self, + int fullscreen); + + /// + /// Returns true (1) if the Window is maximized. + /// + int(CEF_CALLBACK* is_maximized)(struct _cef_window_t* self); + + /// + /// Returns true (1) if the Window is minimized. + /// + int(CEF_CALLBACK* is_minimized)(struct _cef_window_t* self); + + /// + /// Returns true (1) if the Window is fullscreen. + /// + int(CEF_CALLBACK* is_fullscreen)(struct _cef_window_t* self); + + /// + /// Set the Window title. + /// + void(CEF_CALLBACK* set_title)(struct _cef_window_t* self, + const cef_string_t* title); + + /// + /// Get the Window title. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t(CEF_CALLBACK* get_title)(struct _cef_window_t* self); + + /// + /// Set the Window icon. This should be a 16x16 icon suitable for use in the + /// Windows's title bar. + /// + void(CEF_CALLBACK* set_window_icon)(struct _cef_window_t* self, + struct _cef_image_t* image); + + /// + /// Get the Window icon. + /// + struct _cef_image_t*(CEF_CALLBACK* get_window_icon)( + struct _cef_window_t* self); + + /// + /// Set the Window App icon. This should be a larger icon for use in the host + /// environment app switching UI. On Windows, this is the ICON_BIG used in + /// Alt-Tab list and Windows taskbar. The Window icon will be used by default + /// if no Window App icon is specified. + /// + void(CEF_CALLBACK* set_window_app_icon)(struct _cef_window_t* self, + struct _cef_image_t* image); + + /// + /// Get the Window App icon. + /// + struct _cef_image_t*(CEF_CALLBACK* get_window_app_icon)( + struct _cef_window_t* self); + + /// + /// Add a View that will be overlayed on the Window contents with absolute + /// positioning and high z-order. Positioning is controlled by |docking_mode| + /// as described below. The returned cef_overlay_controller_t object is used + /// to control the overlay. Overlays are hidden by default. + /// + /// With CEF_DOCKING_MODE_CUSTOM: + /// 1. The overlay is initially hidden, sized to |view|'s preferred size, + /// and positioned in the top-left corner. + /// 2. Optionally change the overlay position and/or size by calling + /// CefOverlayController methods. + /// 3. Call CefOverlayController::SetVisible(true) to show the overlay. + /// 4. The overlay will be automatically re-sized if |view|'s layout + /// changes. Optionally change the overlay position and/or size when + /// OnLayoutChanged is called on the Window's delegate to indicate a + /// change in Window bounds. + /// + /// With other docking modes: + /// 1. The overlay is initially hidden, sized to |view|'s preferred size, + /// and positioned based on |docking_mode|. + /// 2. Call CefOverlayController::SetVisible(true) to show the overlay. + /// 3. The overlay will be automatically re-sized if |view|'s layout changes + /// and re-positioned as appropriate when the Window resizes. + /// + /// Overlays created by this function will receive a higher z-order then any + /// child Views added previously. It is therefore recommended to call this + /// function last after all other child Views have been added so that the + /// overlay displays as the top-most child of the Window. + /// + struct _cef_overlay_controller_t*(CEF_CALLBACK* add_overlay_view)( + struct _cef_window_t* self, + struct _cef_view_t* view, + cef_docking_mode_t docking_mode); + + /// + /// Show a menu with contents |menu_model|. |screen_point| specifies the menu + /// position in screen coordinates. |anchor_position| specifies how the menu + /// will be anchored relative to |screen_point|. + /// + void(CEF_CALLBACK* show_menu)(struct _cef_window_t* self, + struct _cef_menu_model_t* menu_model, + const cef_point_t* screen_point, + cef_menu_anchor_position_t anchor_position); + + /// + /// Cancel the menu that is currently showing, if any. + /// + void(CEF_CALLBACK* cancel_menu)(struct _cef_window_t* self); + + /// + /// Returns the Display that most closely intersects the bounds of this + /// Window. May return NULL if this Window is not currently displayed. + /// + struct _cef_display_t*(CEF_CALLBACK* get_display)(struct _cef_window_t* self); + + /// + /// Returns the bounds (size and position) of this Window's client area. + /// Position is in screen coordinates. + /// + cef_rect_t(CEF_CALLBACK* get_client_area_bounds_in_screen)( + struct _cef_window_t* self); + + /// + /// Set the regions where mouse events will be intercepted by this Window to + /// support drag operations. Call this function with an NULL vector to clear + /// the draggable regions. The draggable region bounds should be in window + /// coordinates. + /// + void(CEF_CALLBACK* set_draggable_regions)( + struct _cef_window_t* self, + size_t regionsCount, + cef_draggable_region_t const* regions); + + /// + /// Retrieve the platform window handle for this Window. + /// + cef_window_handle_t(CEF_CALLBACK* get_window_handle)( + struct _cef_window_t* self); + + /// + /// Simulate a key press. |key_code| is the VKEY_* value from Chromium's + /// ui/events/keycodes/keyboard_codes.h header (VK_* values on Windows). + /// |event_flags| is some combination of EVENTFLAG_SHIFT_DOWN, + /// EVENTFLAG_CONTROL_DOWN and/or EVENTFLAG_ALT_DOWN. This function is exposed + /// primarily for testing purposes. + /// + void(CEF_CALLBACK* send_key_press)(struct _cef_window_t* self, + int key_code, + uint32 event_flags); + + /// + /// Simulate a mouse move. The mouse cursor will be moved to the specified + /// (screen_x, screen_y) position. This function is exposed primarily for + /// testing purposes. + /// + void(CEF_CALLBACK* send_mouse_move)(struct _cef_window_t* self, + int screen_x, + int screen_y); + + /// + /// Simulate mouse down and/or mouse up events. |button| is the mouse button + /// type. If |mouse_down| is true (1) a mouse down event will be sent. If + /// |mouse_up| is true (1) a mouse up event will be sent. If both are true (1) + /// a mouse down event will be sent followed by a mouse up event (equivalent + /// to clicking the mouse button). The events will be sent using the current + /// cursor position so make sure to call send_mouse_move() first to position + /// the mouse. This function is exposed primarily for testing purposes. + /// + void(CEF_CALLBACK* send_mouse_events)(struct _cef_window_t* self, + cef_mouse_button_type_t button, + int mouse_down, + int mouse_up); + + /// + /// Set the keyboard accelerator for the specified |command_id|. |key_code| + /// can be any virtual key or character value. + /// cef_window_delegate_t::OnAccelerator will be called if the keyboard + /// combination is triggered while this window has focus. + /// + void(CEF_CALLBACK* set_accelerator)(struct _cef_window_t* self, + int command_id, + int key_code, + int shift_pressed, + int ctrl_pressed, + int alt_pressed); + + /// + /// Remove the keyboard accelerator for the specified |command_id|. + /// + void(CEF_CALLBACK* remove_accelerator)(struct _cef_window_t* self, + int command_id); + + /// + /// Remove all keyboard accelerators. + /// + void(CEF_CALLBACK* remove_all_accelerators)(struct _cef_window_t* self); +} cef_window_t; + +/// +/// Create a new Window. +/// +CEF_EXPORT cef_window_t* cef_window_create_top_level( + struct _cef_window_delegate_t* delegate); + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_CAPI_H_ diff --git a/include/capi/views/cef_window_delegate_capi.h b/include/capi/views/cef_window_delegate_capi.h new file mode 100644 index 00000000..ce63b865 --- /dev/null +++ b/include/capi/views/cef_window_delegate_capi.h @@ -0,0 +1,207 @@ +// Copyright (c) 2023 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// 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. +// +// $hash=9f0389a439e6787282880d53375369829adb6a3d$ +// + +#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_DELEGATE_CAPI_H_ +#define CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_DELEGATE_CAPI_H_ +#pragma once + +#include "include/capi/views/cef_panel_delegate_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct _cef_window_t; + +/// +/// Implement this structure to handle window events. The functions of this +/// structure will be called on the browser process UI thread unless otherwise +/// indicated. +/// +typedef struct _cef_window_delegate_t { + /// + /// Base structure. + /// + cef_panel_delegate_t base; + + /// + /// Called when |window| is created. + /// + void(CEF_CALLBACK* on_window_created)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Called when |window| is closing. + /// + void(CEF_CALLBACK* on_window_closing)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Called when |window| is destroyed. Release all references to |window| and + /// do not attempt to execute any functions on |window| after this callback + /// returns. + /// + void(CEF_CALLBACK* on_window_destroyed)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Called when |window| is activated or deactivated. + /// + void(CEF_CALLBACK* on_window_activation_changed)( + struct _cef_window_delegate_t* self, + struct _cef_window_t* window, + int active); + + /// + /// Called when |window| bounds have changed. |new_bounds| will be in DIP + /// screen coordinates. + /// + void(CEF_CALLBACK* on_window_bounds_changed)( + struct _cef_window_delegate_t* self, + struct _cef_window_t* window, + const cef_rect_t* new_bounds); + + /// + /// Return the parent for |window| or NULL if the |window| does not have a + /// parent. Windows with parents will not get a taskbar button. Set |is_menu| + /// to true (1) if |window| will be displayed as a menu, in which case it will + /// not be clipped to the parent window bounds. Set |can_activate_menu| to + /// false (0) if |is_menu| is true (1) and |window| should not be activated + /// (given keyboard focus) when displayed. + /// + struct _cef_window_t*(CEF_CALLBACK* get_parent_window)( + struct _cef_window_delegate_t* self, + struct _cef_window_t* window, + int* is_menu, + int* can_activate_menu); + + /// + /// Return the initial bounds for |window| in density independent pixel (DIP) + /// coordinates. If this function returns an NULL CefRect then + /// get_preferred_size() will be called to retrieve the size, and the window + /// will be placed on the screen with origin (0,0). This function can be used + /// in combination with cef_view_t::get_bounds_in_screen() to restore the + /// previous window bounds. + /// + cef_rect_t(CEF_CALLBACK* get_initial_bounds)( + struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Return the initial show state for |window|. + /// + cef_show_state_t(CEF_CALLBACK* get_initial_show_state)( + struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Return true (1) if |window| should be created without a frame or title + /// bar. The window will be resizable if can_resize() returns true (1). Use + /// cef_window_t::set_draggable_regions() to specify draggable regions. + /// + int(CEF_CALLBACK* is_frameless)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Return true (1) if |window| should be created with standard window buttons + /// like close, minimize and zoom. + /// + int(CEF_CALLBACK* with_standard_window_buttons)( + struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Return whether the titlebar height should be overridden, and sets the + /// height of the titlebar in |titlebar_height|. On macOS, it can also be used + /// to adjust the vertical position of the traffic light buttons in frameless + /// windows. The buttons will be positioned halfway down the titlebar at a + /// height of |titlebar_height| / 2. + /// + int(CEF_CALLBACK* get_titlebar_height)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window, + float* titlebar_height); + + /// + /// Return true (1) if |window| can be resized. + /// + int(CEF_CALLBACK* can_resize)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Return true (1) if |window| can be maximized. + /// + int(CEF_CALLBACK* can_maximize)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Return true (1) if |window| can be minimized. + /// + int(CEF_CALLBACK* can_minimize)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Return true (1) if |window| can be closed. This will be called for user- + /// initiated window close actions and when cef_window_t::close() is called. + /// + int(CEF_CALLBACK* can_close)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window); + + /// + /// Called when a keyboard accelerator registered with + /// cef_window_t::SetAccelerator is triggered. Return true (1) if the + /// accelerator was handled or false (0) otherwise. + /// + int(CEF_CALLBACK* on_accelerator)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window, + int command_id); + + /// + /// Called after all other controls in the window have had a chance to handle + /// the event. |event| contains information about the keyboard event. Return + /// true (1) if the keyboard event was handled or false (0) otherwise. + /// + int(CEF_CALLBACK* on_key_event)(struct _cef_window_delegate_t* self, + struct _cef_window_t* window, + const cef_key_event_t* event); +} cef_window_delegate_t; + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_DELEGATE_CAPI_H_ |